c48ec3adff
This shouldn't change behavior (or even object code) at all because those assignments are all without effect. Removing that code removes noise which helps working with code analysis tools.
1148 lines
35 KiB
C
1148 lines
35 KiB
C
/*
|
||
* CDE - Common Desktop Environment
|
||
*
|
||
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
|
||
*
|
||
* These libraries and programs are free software; you can
|
||
* redistribute them and/or modify them under the terms of the GNU
|
||
* Lesser General Public License as published by the Free Software
|
||
* Foundation; either version 2 of the License, or (at your option)
|
||
* any later version.
|
||
*
|
||
* These libraries and programs are distributed in the hope that
|
||
* they will be useful, but WITHOUT ANY WARRANTY; without even the
|
||
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||
* PURPOSE. See the GNU Lesser General Public License for more
|
||
* details.
|
||
*
|
||
* You should have received a copy of the GNU Lesser General Public
|
||
* License along with these libraries and programs; if not, write
|
||
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
||
* Floor, Boston, MA 02110-1301 USA
|
||
*/
|
||
/* *
|
||
* (c) Copyright 1993, 1994, 1996 Hewlett-Packard Company *
|
||
* (c) Copyright 1993, 1994, 1996 International Business Machines Corp. *
|
||
* (c) Copyright 1993, 1994, 1996 Sun Microsystems, Inc. *
|
||
* (c) Copyright 1993, 1994, 1996 Novell, Inc. *
|
||
* (c) Copyright 1996 Digital Equipment Corporation. *
|
||
* (c) Copyright 1996 FUJITSU LIMITED. *
|
||
* (c) Copyright 1996 Hitachi. *
|
||
*/
|
||
|
||
#include "TermHeader.h"
|
||
#include "TermPrimDebug.h"
|
||
#include "TermPrimI.h"
|
||
#include "TermP.h"
|
||
#include "TermBuffer.h"
|
||
#include "TermData.h"
|
||
#include "TermPrimData.h"
|
||
#include "TermFunction.h"
|
||
#include "TermPrimSetPty.h"
|
||
#include "TermPrimMessageCatI.h"
|
||
#include "TermPrimParserP.h"
|
||
#include "TermParseTable.h"
|
||
|
||
static void
|
||
termFuncErase
|
||
(
|
||
Widget w,
|
||
int count,
|
||
DtEraseMode eraseSwitch,
|
||
FunctionSource functionSource
|
||
);
|
||
|
||
|
||
|
||
/*** SCROLL *******************************************************************
|
||
*
|
||
* #### #### ##### #### # #
|
||
* # # # # # # # # #
|
||
* #### # # # # # # #
|
||
* # # ##### # # # #
|
||
* # # # # # # # # # #
|
||
* #### #### # # #### ###### ######
|
||
*/
|
||
#define EXIT_IF_MARGINS_SET(w) if( (w)->term.tpd->scrollLockTopRow != 0 || \
|
||
(w)->term.tpd->scrollLockBottomRow != \
|
||
(w)->term.rows-1 ) \
|
||
return;
|
||
|
||
static void
|
||
doScroll(Widget w, short lines)
|
||
{
|
||
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
|
||
struct termData *tpd = tw->term.tpd;
|
||
short newtop;
|
||
|
||
EXIT_IF_MARGINS_SET(tw)
|
||
newtop = tpd->topRow + lines;
|
||
/* don't go past top of active buffer or past end of history buffer */
|
||
if (newtop>0) newtop=0;
|
||
if (newtop<-tpd->lastUsedHistoryRow) newtop=-tpd->lastUsedHistoryRow;
|
||
/* perform scroll... */
|
||
(void) _DtTermPrimScrollTextTo(w, newtop);
|
||
(void) _DtTermPrimScrollComplete((Widget) tw, True);
|
||
}
|
||
|
||
|
||
void
|
||
_DtTermFuncScroll(Widget w, int count, FunctionSource functionSource)
|
||
{
|
||
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
|
||
|
||
/* make sure the cursor is off... */
|
||
(void) _DtTermPrimCursorOff(w);
|
||
|
||
/* and scroll the text... */
|
||
(void) doScroll(w, count);
|
||
(void) _DtTermPrimCursorOn(w);
|
||
return;
|
||
}
|
||
|
||
void
|
||
_DtTermFuncBeginningOfBuffer(Widget w, int count, FunctionSource functionSource)
|
||
{
|
||
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
|
||
DtTermWidget vtw = (DtTermWidget) w;
|
||
struct termData *tpd = tw->term.tpd;
|
||
|
||
EXIT_IF_MARGINS_SET(tw)
|
||
/* make sure the cursor is off... */
|
||
(void) _DtTermPrimCursorOff(w);
|
||
(void) _DtTermPrimScrollTextTo(w, -tpd->lastUsedHistoryRow);
|
||
(void) _DtTermPrimScrollComplete((Widget) tw, True);
|
||
(void) _DtTermPrimCursorOn(w);
|
||
}
|
||
|
||
void
|
||
_DtTermFuncEndOfBuffer(Widget w, int count, FunctionSource functionSource)
|
||
{
|
||
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
|
||
|
||
EXIT_IF_MARGINS_SET(tw)
|
||
(void) _DtTermPrimCursorOff(w);
|
||
(void) _DtTermPrimScrollTextTo(w, 0);
|
||
(void) _DtTermPrimScrollComplete((Widget) tw, True);
|
||
(void) _DtTermPrimCursorOn(w);
|
||
}
|
||
|
||
|
||
/*** CLEAR MEMORY / LINE ******************************************************
|
||
*
|
||
* #### # ###### ## #####
|
||
* # # # # # # # #
|
||
* # # ##### # # # #
|
||
* # # # ###### #####
|
||
* # # # # # # # #
|
||
* #### ###### ###### # # # #
|
||
*
|
||
* #
|
||
* # # ###### # # # # # # # ######
|
||
* ## ## # ## ## # # # ## # #
|
||
* # ## # ##### # ## # # # # # # # #####
|
||
* # # # # # # # # # # # #
|
||
* # # # # # # # # # ## #
|
||
* # # ###### # # # ###### # # # ######
|
||
*/
|
||
|
||
static void
|
||
clearToEndOfMemory(Widget w)
|
||
{
|
||
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
|
||
struct termData *tpd = tw->term.tpd;
|
||
int i;
|
||
|
||
/* clear from current cursor to end of memory... */
|
||
if (tpd->cursorRow + tpd->topRow < tpd->lastUsedRow) {
|
||
/* clear the current line to end of memory... */
|
||
(void) _DtTermPrimBufferClearLine(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow, tpd->cursorColumn);
|
||
|
||
/* clear the next line to the end of memory... */
|
||
for (i = tpd->topRow + tpd->cursorRow + 1; i < tpd->lastUsedRow; i++)
|
||
(void) _DtTermPrimBufferClearLine(tpd->termBuffer, i, 0);
|
||
|
||
/* render the current line from cursor to end of line... */
|
||
(void) _DtTermPrimRefreshText(w, tpd->cursorColumn, tpd->cursorRow,
|
||
tw->term.columns, tpd->cursorRow);
|
||
|
||
/* render the rest of the lines... */
|
||
if (tpd->cursorRow + 1 < tw->term.rows) {
|
||
(void) _DtTermPrimRefreshText(w, 0, tpd->cursorRow + 1,
|
||
tw->term.columns, tw->term.rows - 1);
|
||
}
|
||
|
||
/* set the lastUsedRow... */
|
||
if (tpd->cursorRow > tpd->memoryLockRow) {
|
||
if (tpd->cursorColumn == 0) {
|
||
/* don't count the current line -- lastUsedRow is the
|
||
* line above...
|
||
*/
|
||
tpd->lastUsedRow = tpd->topRow + tpd->cursorRow;
|
||
} else {
|
||
tpd->lastUsedRow = tpd->topRow + tpd->cursorRow + 1;
|
||
}
|
||
} else {
|
||
tpd->lastUsedRow = tpd->topRow + tpd->memoryLockRow + 1;
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
/*
|
||
** Erase characters on the specified row (and clear the enhancements) with
|
||
** the appropriate semantics. For VT class emulators, there are several
|
||
** ways to erase characters:
|
||
** - from the active position to the end of line
|
||
** - erase the specified number of characters starting at the current
|
||
** cursor position
|
||
** - from the start of the line to the active position
|
||
** - erase the entire line
|
||
** - from the active position to the end of the buffer
|
||
** - erase the specified number of lines starting at the current
|
||
** cursor position
|
||
** - from the start of the buffer to the active position
|
||
** - erase the entire buffer
|
||
**
|
||
** We handle the easy stuff here, and pass the rest to _DtTermBufferErase.
|
||
*/
|
||
static void
|
||
termFuncErase
|
||
(
|
||
Widget w,
|
||
int count,
|
||
DtEraseMode eraseSwitch,
|
||
FunctionSource functionSource
|
||
)
|
||
{
|
||
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
|
||
DtTermPrimData tpd = tw->term.tpd;
|
||
short row;
|
||
short col;
|
||
|
||
switch(eraseSwitch)
|
||
{
|
||
case eraseToEOL:
|
||
/*
|
||
** erase from the current cursor position to the end of the line
|
||
*/
|
||
_DtTermFuncClearToEndOfLine(w, 1, functionSource);
|
||
break;
|
||
|
||
case eraseLine:
|
||
/*
|
||
** erase the current line
|
||
*/
|
||
_DtTermFuncClearLine(w, 1, functionSource);
|
||
break;
|
||
|
||
case eraseToEOB:
|
||
(void) _DtTermFuncClearToEndOfBuffer(w, 1, functionSource);
|
||
break;
|
||
|
||
case eraseFromRow0Col0:
|
||
/*
|
||
** first clear all lines from the top of the screen upto the
|
||
** current line...
|
||
*/
|
||
row = tpd->cursorRow;
|
||
col = tpd->cursorColumn;
|
||
|
||
tpd->cursorColumn = 0;
|
||
for (tpd->cursorRow = tpd->topRow;
|
||
tpd->cursorRow < row;
|
||
tpd->cursorRow++)
|
||
{
|
||
_DtTermFuncClearLine(w, 1, functionSource);
|
||
}
|
||
tpd->cursorRow = row;
|
||
tpd->cursorColumn = col;
|
||
|
||
/*
|
||
** now clear all characters from col 0 to the current cursor position
|
||
** on the current line...
|
||
*/
|
||
_DtTermBufferErase(((DtTermPrimitiveWidget)w)->term.tpd->termBuffer,
|
||
tpd->cursorRow + tpd->topRow, tpd->cursorColumn,
|
||
count, eraseFromCol0);
|
||
|
||
(void) _DtTermPrimRefreshText(w, 0, tpd->cursorRow,
|
||
tpd->cursorColumn + 1 + (tpd->mbCurMax > 1 ? 1:0),
|
||
tpd->cursorRow);
|
||
break;
|
||
|
||
case eraseBuffer:
|
||
(void) _DtTermFuncClearBuffer(w, 0, functionSource);
|
||
break;
|
||
|
||
case eraseFromCol0:
|
||
_DtTermBufferErase(((DtTermPrimitiveWidget)w)->term.tpd->termBuffer,
|
||
tpd->cursorRow + tpd->topRow, tpd->cursorColumn,
|
||
count, eraseSwitch);
|
||
(void) _DtTermPrimRefreshText(w, 0, tpd->cursorRow,
|
||
tpd->cursorColumn + 1 + (tpd->mbCurMax > 1 ? 1:0),
|
||
tpd->cursorRow);
|
||
case eraseCharCount:
|
||
_DtTermBufferErase(((DtTermPrimitiveWidget)w)->term.tpd->termBuffer,
|
||
tpd->cursorRow + tpd->topRow, tpd->cursorColumn,
|
||
count, eraseSwitch);
|
||
(void) _DtTermPrimRefreshText(w,
|
||
tpd->cursorColumn - (tpd->mbCurMax > 1 ? 1:0),
|
||
tpd->cursorRow,
|
||
tpd->cursorColumn + count + (tpd->mbCurMax > 1 ? 1:0),
|
||
tpd->cursorRow);
|
||
break;
|
||
}
|
||
}
|
||
|
||
void
|
||
_DtTermFuncEraseInDisplay
|
||
(
|
||
Widget w,
|
||
int count,
|
||
FunctionSource functionSource
|
||
)
|
||
{
|
||
termFuncErase(w, 0, (DtEraseMode)count, functionSource);
|
||
}
|
||
|
||
void
|
||
_DtTermFuncEraseInLine
|
||
(
|
||
Widget w,
|
||
int count,
|
||
FunctionSource functionSource
|
||
)
|
||
{
|
||
termFuncErase(w, 0, (DtEraseMode)count, functionSource);
|
||
}
|
||
|
||
void
|
||
_DtTermFuncEraseCharacter
|
||
(
|
||
Widget w,
|
||
int count,
|
||
FunctionSource functionSource
|
||
)
|
||
{
|
||
termFuncErase(w, count, eraseCharCount, functionSource);
|
||
}
|
||
|
||
void
|
||
_DtTermFuncClearToEndOfBuffer(Widget w, int count, FunctionSource functionSource)
|
||
{
|
||
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
|
||
|
||
/* turn the cursor off... */
|
||
(void) _DtTermPrimCursorOff(w);
|
||
|
||
(void) clearToEndOfMemory(w);
|
||
}
|
||
|
||
|
||
void
|
||
_DtTermFuncClearBuffer(Widget w, int count, FunctionSource functionSource)
|
||
{
|
||
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
|
||
DtTermWidget vtw = (DtTermWidget) w;
|
||
struct termData *tpd = tw->term.tpd;
|
||
int i;
|
||
|
||
/* turn the cursor off... */
|
||
(void) _DtTermPrimCursorOff(w);
|
||
|
||
/* move the cursor to the first line after locked memory... */
|
||
/* move to cusor column 0 for now so that we will clear the entire
|
||
* line...
|
||
*/
|
||
tpd->cursorColumn = 0;
|
||
tpd->cursorRow = 0;
|
||
|
||
/* and clear from the current cursor position to end of memory... */
|
||
(void) clearToEndOfMemory(w);
|
||
|
||
/* and set the final cursor position if origin mode */
|
||
if ( vtw->vt.td->originMode) {
|
||
tpd->cursorRow = vtw->term.tpd->scrollLockTopRow;
|
||
}
|
||
}
|
||
|
||
|
||
void
|
||
_DtTermFuncClearLine(Widget w, int count, FunctionSource functionSource)
|
||
{
|
||
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
|
||
struct termData *tpd = tw->term.tpd;
|
||
int lineWidth;
|
||
|
||
if (tpd->topRow + tpd->cursorRow < tpd->lastUsedRow) {
|
||
/* get the current width... */
|
||
lineWidth = _DtTermPrimBufferGetLineWidth(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow);
|
||
/* clear line... */
|
||
(void) _DtTermPrimBufferClearLine(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow, 0);
|
||
/* render the line. We only need to refresh the old line
|
||
* width...
|
||
*/
|
||
if (lineWidth > 0)
|
||
(void) _DtTermPrimRefreshText(w, 0, tpd->cursorRow, lineWidth,
|
||
tpd->cursorRow);
|
||
}
|
||
}
|
||
|
||
|
||
void
|
||
_DtTermFuncClearToEndOfLine(Widget w, int count, FunctionSource functionSource)
|
||
{
|
||
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
|
||
struct termData *tpd = tw->term.tpd;
|
||
int lineWidth;
|
||
|
||
if (tpd->topRow + tpd->cursorRow < tpd->lastUsedRow) {
|
||
/* turn the cursor off... */
|
||
(void) _DtTermPrimCursorOff(w);
|
||
|
||
/* get the current width... */
|
||
lineWidth = _DtTermPrimBufferGetLineWidth(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow);
|
||
/* clear line... */
|
||
if (lineWidth > tpd->cursorColumn) {
|
||
(void) _DtTermPrimBufferClearLine(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow, tpd->cursorColumn);
|
||
/* render the line. We only need to refresh the old line
|
||
* width...
|
||
*/
|
||
(void) _DtTermPrimRefreshText(w,
|
||
tpd->cursorColumn - (tpd->mbCurMax > 1 ? 1 : 0),
|
||
tpd->cursorRow,
|
||
lineWidth, tpd->cursorRow);
|
||
}
|
||
/* if this is the last row, we are not in memory lock land,
|
||
* and we are in column 0, it is no longer the last used row...
|
||
*/
|
||
if ((tpd->topRow + tpd->cursorRow == tpd->lastUsedRow - 1) &&
|
||
(tpd->cursorColumn == 0) &&
|
||
(tpd->cursorRow > tpd->memoryLockRow)) {
|
||
tpd->lastUsedRow = tpd->topRow + tpd->cursorRow;
|
||
}
|
||
}
|
||
}
|
||
|
||
/*
|
||
** Delete "count" characters from the buffer, VT class terminals do not
|
||
** support delete with wrap, so no need to worry about it.
|
||
*/
|
||
void
|
||
_DtTermFuncDeleteChar
|
||
(
|
||
Widget w,
|
||
int count,
|
||
FunctionSource functionSource
|
||
)
|
||
{
|
||
DtTermPrimData tpd = ((DtTermPrimitiveWidget) w)->term.tpd;
|
||
short deleteWidth;
|
||
short row;
|
||
short col;
|
||
|
||
row = tpd->topRow + tpd->cursorRow;
|
||
col = tpd->cursorColumn;
|
||
|
||
if (row < tpd->lastUsedRow && count > 0)
|
||
{
|
||
deleteWidth = count;
|
||
(void) _DtTermPrimCursorOff(w);
|
||
_DtTermBufferDelete(tpd->termBuffer, &row, &col, &deleteWidth);
|
||
(void) _DtTermPrimRefreshText(w, col, row,
|
||
((DtTermPrimitiveWidget) w)->term.columns,
|
||
row);
|
||
|
||
}
|
||
}
|
||
|
||
void
|
||
_DtTermFuncDeleteLine(Widget w, int count, FunctionSource functionSource)
|
||
{
|
||
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
|
||
struct termData *tpd = tw->term.tpd;
|
||
|
||
/* we might as well turn the cursor off now, since we will need to
|
||
* change the cursor column to the left margin when we are done
|
||
* anyway...
|
||
*/
|
||
(void) _DtTermPrimCursorOff(w);
|
||
if (tpd->topRow + tpd->cursorRow < tpd->lastUsedRow) {
|
||
/* complete any pending scroll if the scroll area has changed... */
|
||
(void) _DtTermPrimScrollCompleteIfNecessary(w, tpd->cursorRow,
|
||
tw->term.rows - 1, count);
|
||
|
||
/* clip the line count... */
|
||
if (count > tpd->scrollLockBottomRow -tpd->scrollLockTopRow +1)
|
||
count = tpd->scrollLockBottomRow -tpd->scrollLockTopRow +1 ;
|
||
#ifdef BOGUS
|
||
if (tpd->topRow + tpd->cursorRow + count > tpd->lastUsedRow) {
|
||
count = tpd->lastUsedRow - (tpd->topRow + tpd->cursorRow);
|
||
}
|
||
#endif /* BOBUS */
|
||
if (tpd->topRow + tpd->cursorRow + count > tpd->scrollLockBottomRow) {
|
||
count = tpd->scrollLockBottomRow -
|
||
(tpd->topRow + tpd->cursorRow) + 1;
|
||
}
|
||
|
||
/* special case out when there is a single line and we are
|
||
* deleting the top line...
|
||
*/
|
||
if (((tpd->lastUsedRow == 1) && (tpd->cursorRow == 0)) ||
|
||
(tpd->cursorRow + 1 == tpd->lastUsedRow)) {
|
||
/* we need to clear the line, re-render it, and we are done...
|
||
*/
|
||
(void) _DtTermPrimBufferClearLine(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow, 0);
|
||
(void) _DtTermPrimRefreshText(w, 0, tpd->cursorRow, tw->term.columns,
|
||
tpd->cursorRow);
|
||
} else {
|
||
/* delete the lines at the cursor...
|
||
*/
|
||
(void) _DtTermPrimBufferDeleteLine(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow, count, tpd->lastUsedRow);
|
||
/* delete lines at the cursor from the selection... */
|
||
(void) _DtTermPrimSelectDeleteLines(w,
|
||
tpd->lastUsedHistoryRow + tpd->topRow + tpd->cursorRow,
|
||
count);
|
||
|
||
/* insert the lines we just deleted at the bottom of the
|
||
* scrolling region...
|
||
*/
|
||
(void) _DtTermPrimBufferInsertLineFromTB(tpd->termBuffer,
|
||
tpd->topRow + tpd->scrollLockBottomRow - count + 1,
|
||
count, insertFromBottom);
|
||
/* insert lines at the bottom of the scrolling region into
|
||
* the selection...
|
||
*/
|
||
(void) _DtTermPrimSelectInsertLines(w,
|
||
tpd->lastUsedHistoryRow + tpd->topRow +
|
||
tpd->scrollLockBottomRow - count + 1, count);
|
||
|
||
/* and scroll the text on the screen... */
|
||
(void) _DtTermPrimScrollTextArea(w, tpd->cursorRow,
|
||
tpd->scrollLockBottomRow + 1 - tpd->cursorRow, count);
|
||
}
|
||
}
|
||
|
||
/* move to the left margin... */
|
||
tpd->cursorColumn = tpd->leftMargin;
|
||
}
|
||
|
||
|
||
/** HARD/SOFT RESET ***********************************************************
|
||
* #
|
||
* # # ## ##### ##### # #### #### ###### #####
|
||
* # # # # # # # # # # # # # #
|
||
* ###### # # # # # # # #### # # ##### #
|
||
* # # ###### ##### # # # # # # # #
|
||
* # # # # # # # # # # # # # # #
|
||
* # # # # # # ##### # #### #### # #
|
||
*
|
||
*
|
||
* ##### ###### #### ###### #####
|
||
* # # # # # #
|
||
* # # ##### #### ##### #
|
||
* ##### # # # #
|
||
* # # # # # # #
|
||
* # # ###### #### ###### #
|
||
*/
|
||
void
|
||
_DtTermFuncHardReset(Widget w, int count, FunctionSource functionSource)
|
||
{
|
||
DtTermWidget vtw = (DtTermWidget) w;
|
||
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
|
||
struct termData *tpd = tw->term.tpd;
|
||
|
||
(void) _DtTermPrimScrollComplete(w, True);
|
||
/* ring the bell... */
|
||
(void) _DtTermPrimBell(w);
|
||
(void) _DtTermPrimCursorOn(w);
|
||
|
||
_DtTermFuncSoftReset(w, count, functionSource) ;
|
||
|
||
/* Do this after soft reset */
|
||
|
||
vtw->term.reverseVideo = False;
|
||
tpd->topRow = 0 ;
|
||
tpd->autoLineFeed=False ;
|
||
vtw->term.jumpScroll = True ;
|
||
/* auto key repeat is X server issue - do nothing here */
|
||
_DtTermFuncClearBuffer(w, 0, (FunctionSource) NULL ) ;
|
||
_DtTermFunctionKeyClear(w) ;
|
||
|
||
(void) _DtTermPrimSetCursorVisible(w, True);
|
||
(void) _DtTermPrimCursorOn(w);
|
||
|
||
return;
|
||
}
|
||
|
||
void
|
||
_DtTermFuncSoftReset(Widget w, int count, FunctionSource functionSource)
|
||
{
|
||
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
|
||
struct termData *tpd = tw->term.tpd;
|
||
DtTermWidget vtw = (DtTermWidget) w;
|
||
DtTermData td = vtw->vt.td;
|
||
|
||
(void) _DtTermPrimScrollComplete(w, True);
|
||
/* ring the bell... */
|
||
(void) _DtTermPrimBell(w);
|
||
/* the following locks don't make sense in the vt context, but
|
||
I'll initialize them to make sure they're not corrupted in the
|
||
"prim" layer
|
||
*/
|
||
tpd->keyboardLocked.xferPending = False;
|
||
tpd->keyboardLocked.error = False;
|
||
tpd->keyboardLocked.record = False;
|
||
|
||
/* ANSI and vt220 resets (from RM) */
|
||
tpd->keyboardLocked.escape = False;
|
||
_DtTermPrimInsertCharUpdate(w, DtTERM_INSERT_CHAR_OFF);
|
||
|
||
/* vt 220 soft resets (DECRST, DECSTBM, from spec) */
|
||
tpd->autoWrapRight=True; /* We are NOT following the vt spec here*/
|
||
td->originMode=False;
|
||
td->applicationMode=False; /* Normal cursor mode */
|
||
td->applicationKPMode=False; /* Numeric keypad mode */
|
||
td->originMode=False;
|
||
/* no scroll lock */
|
||
tpd->memoryLockMode=SCROLL_LOCKoff ;
|
||
tpd->scrollLockTopRow = 0;
|
||
tpd->scrollLockBottomRow = tw->term.rows-1;
|
||
/* cursor state stuff for next restore cursor (DECRC) */
|
||
td->saveCursor.cursorRow = 0;
|
||
td->saveCursor.cursorColumn = 0;
|
||
td->saveCursor.enhFieldState = FIELD_UNPROTECT;
|
||
td->saveCursor.enhVideoState = (char)0;
|
||
td->saveCursor.originMode = False;
|
||
td->saveCursor.enhFgColorState = 0;
|
||
td->saveCursor.enhBgColorState = 0;
|
||
td->saveCursor.GL = &td->G0;
|
||
td->saveCursor.GR = &td->G0;
|
||
td->saveCursor.G0 = RENDER_FONT_NORMAL;
|
||
td->saveCursor.G1 = RENDER_FONT_LINEDRAW;
|
||
td->saveCursor.G2 = RENDER_FONT_NORMAL;
|
||
td->saveCursor.G3 = RENDER_FONT_NORMAL;
|
||
td->saveCursor.singleShiftFont = RENDER_FONT_NORMAL;
|
||
td->saveCursor.singleShiftPending = False;
|
||
/* this is saved by termprim td->saveCursor.wrapMode = False ; */
|
||
|
||
/*
|
||
** xterm resets (xterm extensions to DECRST
|
||
** xterm does not reset this stuff so I won't either
|
||
** td->allow80_132ColMode = False ;
|
||
** td->doCursesFixMode = False ;
|
||
** td->marginBellMode = False ;
|
||
** tpd->logging = False ;
|
||
** when implemented in Term, set "NOT alternate buffer"
|
||
*/
|
||
vtw->vt.td->reverseWrapMode = False; /* this is inconsistant with xterm*/
|
||
|
||
|
||
/* Set the "other" state variables?
|
||
*/
|
||
/* video... */
|
||
td->enhVideoState &= ~VIDEO_MASK;
|
||
(void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhVideo,
|
||
td->enhVideoState);
|
||
|
||
/* field... */
|
||
td->enhFieldState = FIELD_UNPROTECT;
|
||
(void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhField,
|
||
td->enhFieldState);
|
||
|
||
/* foreground... */
|
||
td->enhFgColorState = 0;
|
||
(void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhFgColor,
|
||
td->enhFgColorState);
|
||
|
||
/* background... */
|
||
td->enhBgColorState = 0;
|
||
(void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhBgColor,
|
||
td->enhBgColorState);
|
||
|
||
/* font... */
|
||
td->GL = &td->G0;
|
||
td->GR = &td->G0;
|
||
td->G0 = FONT_NORMAL;
|
||
td->G1 = FONT_NORMAL;
|
||
td->G2 = FONT_NORMAL;
|
||
td->G3 = FONT_NORMAL;
|
||
td->enhFontState = *td->GL;
|
||
(void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhFont,
|
||
td->enhFontState);
|
||
|
||
/* reset the parser */
|
||
{
|
||
ParserContext context ;
|
||
context = GetParserContext(w) ;
|
||
context->stateTable = _DtTermStateStart ;
|
||
_DtTermClearParam(w) ;
|
||
}
|
||
|
||
(void) _DtTermPrimSetCursorVisible(w, True);
|
||
(void) _DtTermPrimCursorOn(w);
|
||
|
||
/* flush any pending text that we have queued up to send down the
|
||
* pty...
|
||
*/
|
||
(void) _DtTermPrimPendingTextFlush(tpd->pendingWrite);
|
||
return;
|
||
}
|
||
|
||
|
||
/*** INSERT CHAR/LINE *********************************************************
|
||
*
|
||
* # # # #### ###### ##### #####
|
||
* # ## # # # # # #
|
||
* # # # # #### ##### # # #
|
||
* # # # # # # ##### #
|
||
* # # ## # # # # # #
|
||
* # # # #### ###### # # #
|
||
*
|
||
* #
|
||
* #### # # ## ##### # # # # # ######
|
||
* # # # # # # # # # # # ## # #
|
||
* # ###### # # # # # # # # # # #####
|
||
* # # # ###### ##### # # # # # # #
|
||
* # # # # # # # # # # # # ## #
|
||
* #### # # # # # # # ###### # # # ######
|
||
*/
|
||
|
||
void
|
||
_DtTermFuncInsertLine(Widget w, int count, FunctionSource functionSource)
|
||
{
|
||
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
|
||
struct termData *tpd = tw->term.tpd;
|
||
int insertedRows = 0;
|
||
int moveCount;
|
||
int src;
|
||
int i;
|
||
|
||
/* as with delete line, turn the cursor off now since we will
|
||
* pretty much need to turn it off later to change the cursor
|
||
* column to the left margin...
|
||
*/
|
||
(void) _DtTermPrimCursorOff(w);
|
||
|
||
/* move the cursor to the left column... */
|
||
tpd->cursorColumn = tpd->leftMargin;
|
||
|
||
/* if the cursor is below used memory, we don't need to do anything...
|
||
*/
|
||
if (tpd->topRow + tpd->cursorRow >= tpd->lastUsedRow) {
|
||
return;
|
||
}
|
||
|
||
/* complete any pending scroll if the scroll area has changed... */
|
||
(void) _DtTermPrimScrollCompleteIfNecessary(w, tpd->cursorRow,
|
||
tw->term.rows - 1, -count);
|
||
|
||
/* first, insert any unused memory (from below lastUsedRow)... */
|
||
if (tpd->lastUsedRow < tpd->bufferRows) {
|
||
/* the most we can insert from the bottom is the number of lines
|
||
* not yet used...
|
||
*/
|
||
moveCount = tpd->bufferRows - tpd->lastUsedRow;
|
||
if (moveCount > count) {
|
||
moveCount = count;
|
||
}
|
||
|
||
/* insert them...
|
||
*/
|
||
(void) _DtTermPrimBufferInsertLineFromTB(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow,
|
||
moveCount, insertFromBottom);
|
||
/* inform the selection code that the selection has been moved... */
|
||
(void) _DtTermPrimSelectInsertLines(w,
|
||
tpd->lastUsedHistoryRow + tpd->topRow + tpd->cursorRow,
|
||
moveCount);
|
||
|
||
/* update screen info and counts... */
|
||
count -= moveCount;
|
||
insertedRows += moveCount;
|
||
tpd->lastUsedRow += moveCount;
|
||
}
|
||
|
||
if (count > 0) {
|
||
/* insert used memory...
|
||
*/
|
||
/* first insert as much as we can from above the screen... */
|
||
if (count > tpd->topRow) {
|
||
moveCount = tpd->topRow;
|
||
} else {
|
||
moveCount = count;
|
||
}
|
||
|
||
if (moveCount > 0) {
|
||
/* insert them into the buffer before we modify the selecction...
|
||
*/
|
||
(void) _DtTermPrimBufferInsertLineFromTB(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow - moveCount,
|
||
moveCount, insertFromTop);
|
||
|
||
/* delete the lines at the top of the buffer from the selection...
|
||
*/
|
||
(void) _DtTermPrimSelectDeleteLines(w, tpd->lastUsedHistoryRow,
|
||
moveCount);
|
||
|
||
/* insert the lines at the bottom of the buffer in the
|
||
* selection...
|
||
*/
|
||
(void) _DtTermPrimSelectInsertLines(w,
|
||
tpd->lastUsedHistoryRow + tpd->topRow + tpd->cursorRow -
|
||
moveCount, moveCount);
|
||
|
||
/* update screen info and counts... */
|
||
count -= moveCount;
|
||
insertedRows += moveCount;
|
||
tpd->topRow -= moveCount;
|
||
}
|
||
|
||
/* now insert whatever else we need from the bottom... */
|
||
if (count > 0) {
|
||
/* DKS: we need to clip here so we don't self destruct... */
|
||
moveCount = count;
|
||
|
||
/* insert them... */
|
||
if ((tpd->cursorRow >= tpd->scrollLockTopRow) &&
|
||
(tpd->cursorRow <= tpd->scrollLockBottomRow)) {
|
||
/* scroll within the scroll region. So, take memory
|
||
* from the bottom of the scroll region instead of the
|
||
* bottom of memory...
|
||
*/
|
||
/* insert lines into the selection... */
|
||
(void) _DtTermPrimBufferInsertLine(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow, moveCount,
|
||
tpd->scrollLockBottomRow - moveCount + 1);
|
||
/* then adjust the selection... */
|
||
(void) _DtTermPrimSelectInsertLines(w,
|
||
tpd->lastUsedHistoryRow + tpd->topRow + tpd->cursorRow,
|
||
moveCount);
|
||
} else {
|
||
/* just take the lines from the bottom... */
|
||
/* we don't need to delete lines from the bottom since
|
||
* that doesn't move the selection...
|
||
*/
|
||
/* insert lines into the selection... */
|
||
(void) _DtTermPrimBufferInsertLineFromTB(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow, moveCount,
|
||
insertFromBottom);
|
||
/* then adjust the selection... */
|
||
(void) _DtTermPrimSelectInsertLines(w,
|
||
tpd->lastUsedHistoryRow + tpd->topRow + tpd->cursorRow,
|
||
moveCount);
|
||
}
|
||
|
||
/* update screen info and counts... */
|
||
insertedRows += moveCount;
|
||
}
|
||
}
|
||
|
||
/* now we need to scroll below us. Remember, in order to scroll text
|
||
* down, the count needs to be *negative*...
|
||
*/
|
||
if ((tpd->cursorRow >= tpd->scrollLockTopRow) &&
|
||
(tpd->cursorRow <= tpd->scrollLockBottomRow)) {
|
||
(void) _DtTermPrimScrollTextArea(w, tpd->cursorRow,
|
||
tpd->scrollLockBottomRow + 1 - tpd->cursorRow, -insertedRows);
|
||
} else {
|
||
(void) _DtTermPrimScrollTextArea(w, tpd->cursorRow,
|
||
tw->term.rows - tpd->cursorRow, -insertedRows);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/*** CURSOR MOTION ************************************************************
|
||
*
|
||
* #### # # ##### #### #### #####
|
||
* # # # # # # # # # # #
|
||
* # # # # # #### # # # #
|
||
* # # # ##### # # # #####
|
||
* # # # # # # # # # # # #
|
||
* #### #### # # #### #### # #
|
||
*
|
||
*
|
||
* # # #### ##### # #### # #
|
||
* ## ## # # # # # # ## #
|
||
* # ## # # # # # # # # # #
|
||
* # # # # # # # # # # #
|
||
* # # # # # # # # # ##
|
||
* # # #### # # #### # #
|
||
*/
|
||
|
||
|
||
void
|
||
_DtTermFuncTab(Widget w, int count, FunctionSource functionSource)
|
||
{
|
||
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget)w;
|
||
struct termData *tpd = tw->term.tpd;
|
||
TermBuffer tBuffer = tpd->termBuffer;
|
||
short nextTab;
|
||
|
||
(void) _DtTermPrimCursorOff(w);
|
||
|
||
/* Move to the next tab stop. Note that this cursor motion is
|
||
* similar to the right arrow cursor motion in that
|
||
* it doesn't set the line width until a character is entered.
|
||
*/
|
||
/* DKS: this code currently enforces tabs at every 8 character
|
||
* positions. It needs to be worked on to support the margins/tabs
|
||
* buffer...
|
||
*/
|
||
nextTab = _DtTermPrimBufferGetNextTab(tBuffer, tpd->cursorColumn);
|
||
|
||
/* check to see if we are past the end of the line... */
|
||
if ((nextTab <= 0) || (nextTab >= tpd->rightMargin)) {
|
||
tpd->cursorColumn = tpd->rightMargin;
|
||
} else {
|
||
tpd->cursorColumn = nextTab;
|
||
}
|
||
return;
|
||
}
|
||
|
||
|
||
|
||
/* The remainder of this file is new for ANSI and should be merged with
|
||
the above (some of which may be incorrect for ANSI)
|
||
*/
|
||
|
||
/*** VIDEO ENHANCEMENTS *******************************************************
|
||
*
|
||
* # # # ##### ###### ####
|
||
* # # # # # # # #
|
||
* # # # # # ##### # #
|
||
* # # # # # # # #
|
||
* # # # # # # # #
|
||
* ## # ##### ###### ####
|
||
*
|
||
*
|
||
* ###### # # # # ## # # #### ######
|
||
* # ## # # # # # ## # # # #
|
||
* ##### # # # ###### # # # # # # #####
|
||
* # # # # # # ###### # # # # # ###
|
||
* # # ## # # # # # ## # # # ###
|
||
* ###### # # # # # # # # #### ###### ###
|
||
*/
|
||
|
||
void
|
||
_DtTermVideoEnhancement(Widget w,int value)
|
||
{
|
||
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
|
||
DtTermPrimData tpd = tw->term.tpd;
|
||
DtTermWidget vtw = (DtTermWidget) w;
|
||
DtTermData td = vtw->vt.td;
|
||
|
||
switch(value) {
|
||
case 0:
|
||
/* reset video */
|
||
td->enhVideoState &= ~VIDEO_MASK ;
|
||
|
||
/* reset color */
|
||
td->enhFgColorState = 0;
|
||
(void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
|
||
enhFgColor, td->enhFgColorState);
|
||
td->enhBgColorState = 0;
|
||
(void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
|
||
enhBgColor, td->enhBgColorState);
|
||
break;
|
||
|
||
case 1: /* Bold... */
|
||
td->enhVideoState |= BOLD;
|
||
td->enhVideoState &= ~HALF_BRIGHT ;
|
||
break;
|
||
|
||
case 2: /* Half bright... */
|
||
td->enhVideoState |= HALF_BRIGHT ;
|
||
td->enhVideoState &= ~BOLD ;
|
||
break;
|
||
|
||
case 4: /* Underline... */
|
||
td->enhVideoState |= UNDERLINE;
|
||
break;
|
||
|
||
case 5: /* we don't do blink, so use inverse */
|
||
case 7: /* Inverse Video... */
|
||
td->enhVideoState |= INVERSE ;
|
||
break;
|
||
|
||
case 8: /* Secure Video... */
|
||
td->enhVideoState |= SECURE ;
|
||
break;
|
||
|
||
case 22: /* Half bright off... */
|
||
td->enhVideoState &= ~HALF_BRIGHT ;
|
||
td->enhVideoState &= ~BOLD ;
|
||
break;
|
||
|
||
case 24: /* Underline off... */
|
||
td->enhVideoState &= ~UNDERLINE ;
|
||
break;
|
||
|
||
case 25: /* we don't do blink, so use inverse */
|
||
|
||
case 27: /* Inverse Video off... */
|
||
td->enhVideoState &= ~INVERSE ;
|
||
break;
|
||
|
||
case 28: /* Secure Video off... */
|
||
td->enhVideoState &= ~SECURE ;
|
||
break;
|
||
|
||
case 30:
|
||
case 31:
|
||
case 32:
|
||
case 33:
|
||
case 34:
|
||
case 35:
|
||
case 36:
|
||
case 37:
|
||
td->enhFgColorState = value - 30 + 1;
|
||
(void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
|
||
enhFgColor, td->enhFgColorState);
|
||
return;
|
||
break;
|
||
case 39:
|
||
td->enhFgColorState = 0;
|
||
(void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
|
||
enhFgColor, td->enhFgColorState);
|
||
return;
|
||
break;
|
||
|
||
case 40:
|
||
case 41:
|
||
case 42:
|
||
case 43:
|
||
case 44:
|
||
case 45:
|
||
case 46:
|
||
case 47:
|
||
td->enhBgColorState = value - 40 + 1;
|
||
(void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
|
||
enhBgColor, td->enhBgColorState);
|
||
return;
|
||
break;
|
||
case 49:
|
||
td->enhBgColorState = 0;
|
||
(void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
|
||
enhBgColor, td->enhBgColorState);
|
||
return;
|
||
break;
|
||
|
||
default: break;
|
||
/* fprintf(stderr,"wrong param in SGR esc seq\n") ;*/
|
||
}
|
||
|
||
/* set the enhancement */
|
||
(void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhVideo,
|
||
td->enhVideoState);
|
||
return;
|
||
}
|
||
|
||
void
|
||
_DtTermFontEnhancement(Widget w,int value)
|
||
{
|
||
DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
|
||
DtTermPrimData tpd = tw->term.tpd;
|
||
DtTermWidget vtw = (DtTermWidget) w;
|
||
|
||
(void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
|
||
tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhFont, value);
|
||
}
|
||
|
||
/* This are utility functions for the terminal dialog to use to effect the
|
||
function key lock
|
||
*/
|
||
void _DtTermSetUserKeyLock(
|
||
Widget w,
|
||
Boolean lock_state)
|
||
{
|
||
_DtTermWidgetToAppContext(w);
|
||
|
||
_DtTermAppLock(app);
|
||
((DtTermWidget)w)->vt.td->userKeysLocked = lock_state ;
|
||
_DtTermAppUnlock(app);
|
||
}
|
||
|
||
Boolean _DtTermGetUserKeyLock(
|
||
Widget w)
|
||
{
|
||
Boolean lock_state;
|
||
_DtTermWidgetToAppContext(w);
|
||
|
||
_DtTermAppLock(app);
|
||
lock_state = ((DtTermWidget)w)->vt.td->userKeysLocked;
|
||
_DtTermAppUnlock(app);
|
||
return(lock_state);
|
||
}
|
||
|
||
void _DtTermSetAutoLineFeed(
|
||
Widget w,
|
||
Boolean alf_state)
|
||
{
|
||
_DtTermWidgetToAppContext(w);
|
||
|
||
_DtTermAppLock(app);
|
||
((DtTermWidget)w)->vt.td->tpd->autoLineFeed = alf_state ;
|
||
_DtTermAppUnlock(app);
|
||
}
|
||
|
||
Boolean _DtTermGetAutoLineFeed(
|
||
Widget w)
|
||
{
|
||
Boolean alf_state;
|
||
_DtTermWidgetToAppContext(w);
|
||
|
||
_DtTermAppLock(app);
|
||
alf_state = ((DtTermWidget)w)->vt.td->tpd->autoLineFeed;
|
||
_DtTermAppUnlock(app);
|
||
return(alf_state);
|
||
}
|
||
|
||
void _DtTermSetCurrentWorkingDirectory(
|
||
Widget w,
|
||
char *cwd)
|
||
{
|
||
DtTermWidget vtw = (DtTermWidget) w;
|
||
_DtTermWidgetToAppContext(w);
|
||
|
||
_DtTermAppLock(app);
|
||
vtw->term.subprocessCWD =
|
||
XtRealloc(vtw->term.subprocessCWD, strlen(cwd) + 1);
|
||
(void) strcpy(vtw->term.subprocessCWD, cwd);
|
||
_DtTermAppUnlock(app);
|
||
}
|
||
|
||
char *_DtTermGetCurrentWorkingDirectory(
|
||
Widget w)
|
||
{
|
||
DtTermWidget vtw = (DtTermWidget) w;
|
||
char *cwd;
|
||
_DtTermWidgetToAppContext(w);
|
||
|
||
_DtTermAppLock(app);
|
||
cwd = vtw->term.subprocessCWD;
|
||
_DtTermAppUnlock(app);
|
||
return(cwd);
|
||
}
|