2 * CDE - Common Desktop Environment
4 * Copyright (c) 1993-2012, The Open Group. All rights reserved.
6 * These libraries and programs are free software; you can
7 * redistribute them and/or modify them under the terms of the GNU
8 * Lesser General Public License as published by the Free Software
9 * Foundation; either version 2 of the License, or (at your option)
12 * These libraries and programs are distributed in the hope that
13 * they will be useful, but WITHOUT ANY WARRANTY; without even the
14 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15 * PURPOSE. See the GNU Lesser General Public License for more
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with these librararies and programs; if not, write
20 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
21 * Floor, Boston, MA 02110-1301 USA
24 #ifdef VERBOSE_REV_INFO
25 static char rcs_id[] = "$TOG: TermParse.c /main/3 1999/10/15 12:25:13 mgreess $";
26 #endif /* VERBOSE_REV_INFO */
30 * (c) Copyright 1993, 1994, 1996 Hewlett-Packard Company *
31 * (c) Copyright 1993, 1994, 1996 International Business Machines Corp. *
32 * (c) Copyright 1993, 1994, 1996 Sun Microsystems, Inc. *
33 * (c) Copyright 1993, 1994, 1996 Novell, Inc. *
34 * (c) Copyright 1996 Digital Equipment Corporation. *
35 * (c) Copyright 1996 FUJITSU LIMITED. *
36 * (c) Copyright 1996 Hitachi. *
41 #include "TermHeader.h"
42 #include "TermPrimDebug.h"
43 #include "TermPrimP.h"
44 #include "TermPrimI.h"
46 #include "TermPrimData.h"
48 #include "TermPrimBuffer.h"
49 #include "TermPrimParserP.h"
50 #include "TermFunction.h"
51 #include "TermBuffer.h"
52 #include "TermFunctionKey.h"
53 #include "TermParseTableP.h"
54 #include "TermBufferP.h"
55 #include "TermPrimUtil.h"
56 #include "TermPrimParseTable.h"
60 * On HP MAXINT is defined in both <values.h> and <sys/param.h>
64 #if defined(CSRG_BASED)
65 #define MAXSHORT SHRT_MAX
70 #if defined(USL) || defined(__uxp__)
75 /*****************************************************************************/
78 #define PCOUNT(c) ((c)->parms[0])
79 #define BASE 1 /* row and column count base 0 or 1 */
81 /*********************************************************************
82 * Macros for handling cursor constraints - return values in coordinate
83 * system for Term widget (base 0) BASE which is 1 reflects the Vt base
85 * These defines need to account of for Origin mode eventually TMH */
87 #define TOPROW(w) (1-BASE)
88 #define TOPMARGIN(w) ((w)->term.tpd->scrollLockTopRow-(1-BASE))
89 #define BOTTOMMARGIN(w) ((w)->term.tpd->scrollLockBottomRow-(1-BASE))
90 #define BOTTOMROW(w) ((w)->term.rows-BASE)
91 /* FIRSTCOLUMN(w) ABS(BASE-1) */
92 #define FIRSTCOLUMN(w) 0
93 #define LASTCOLUMN(w) ((w)->term.columns-BASE)
94 #define FLOOR(w) ((w)->vt.td->originMode?(w)->term.tpd->scrollLockBottomRow:\
96 #define CEILING(w) ((w)->vt.td->originMode?(w)->term.tpd->scrollLockTopRow:\
98 #define KILLWRAP(w) if((w)->term.tpd->cursorColumn>LASTCOLUMN(w)) \
99 (w)->term.tpd->cursorColumn=LASTCOLUMN(w)
100 #define STORELASTARG(c) (c)->parms[PCOUNT(c)]=(c)->workingNum
102 /******************************************************************
103 * Upon entering a parse routine the parameter count is contained
104 * in context->parms[0].
106 * The last parmameter parsed is in context->workingNum
107 * Next to last parmameter is in {context->parms[0]==1?context->workingNum:
108 * context->parms[context->param[0]-1]}
112 * First parameter is in context->parms[1]
114 * In some of the parse routines, the default case of too many parameters
115 * needs to be handled like Vt (silently use the first n parameters)
116 * Vt has a max of 16 numeric parameters; The rest fall off the end
118 *******************************************************************/
121 _DtTermClearParam(Widget w)
123 ParserContext context ;
124 context = GetParserContext(w) ;
127 _DtTermPrimParserClearParm(w) ;
128 _DtTermPrimParserClrStrParm(w) ;
132 _DtTermEnterNum(Widget w)
134 ParserContext context ;
135 context = GetParserContext(w) ;
136 _DtTermPrimParserEnterNum(w) ;
137 if (!PCOUNT(context)) PCOUNT(context)++ ; /* increment for first number ONLY*/
141 _DtTermParsePushNum(Widget w)
143 ParserContext context ;
144 context = GetParserContext(w) ;
145 /* parmN(w,PCOUNT(c)) ; Should use this but not global */
146 if ( context->workingNumIsDefault != True) { /* did we actually parse a num*/
147 _DtTermPrimParserNumParmPush(w,PCOUNT(context)) ;
150 if (!PCOUNT(context)) PCOUNT(context)++ ;/* increment for first number ONLY*/
153 if ( ++PCOUNT(context)>NPARAM ) {
154 Debug('P',fprintf(stderr,">>Too many parameters\n")) ;
160 _DtTermSaveChar(Widget w)
162 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
163 ParserContext context ;
165 context = GetParserContext(w) ;
167 mbtowc(&c,(char *)context->inputChar,MB_CUR_MAX);
168 if ( context->stringParms[0].length < STR_SIZE && iswprint(c) ) {
170 (char *)&context->stringParms[0].str[context->stringParms[0].length]),
171 (char *)context->inputChar, context->inputCharLen) ;
172 context->stringParms[0].length += context->inputCharLen ;
177 _DtTermPrintState(Widget w)
179 ParserContext context ;
180 context = GetParserContext(w) ;
181 /* fprintf(stderr,"Warning: Not a valid escape sequence\n") ;*/
182 context->stateTable = _DtTermStateStart ;
183 _DtTermClearParam(w) ;
186 /* a utility for checking for S8C1TMode */
188 sendEscSequence(Widget w, char *transmitString)
190 DtTermWidget tw = (DtTermWidget)w;
191 DtTermData td = tw->vt.td;
193 if ( td->S8C1TMode ) {
194 char *cbuf =malloc(strlen(transmitString)+1);
195 strcpy(cbuf,transmitString) ;
197 (void) _DtTermPrimSendInput(w, (unsigned char *) (cbuf+1),
202 (void) _DtTermPrimSendInput(w, (unsigned char *) transmitString,
203 strlen(transmitString));
208 _DtTermDeviceStatus(Widget w) /* DSR CSI?pn */
210 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
211 DtTermData vtd = ((DtTermWidget)w)->vt.td;
212 ParserContext context ;
215 Debug('P', fprintf(stderr,">>In func _DtTermDeviceStatus\n")) ;
216 context = GetParserContext(w) ;
217 STORELASTARG(context) ;
218 switch ( context->parms[1] ) {
219 case 15: /* printer status - we don't have one */
220 sendEscSequence(w,"\033[?13n") ;
222 case 25: /* User defined keys locked? */
223 if ( vtd->userKeysLocked )
224 sendEscSequence(w,"\033[?21n") ;
226 sendEscSequence(w,"\033[?20n") ;
228 case 26: /* keyboard status - always send North American */
229 sendEscSequence(w,"\033[?27;1n") ;
235 _DtTermDeviceStatusAnsi(Widget w) /* DSR CSIpn */
237 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
238 DtTermData vtd = ((DtTermWidget)w)->vt.td;
239 ParserContext context ;
242 Debug('P', fprintf(stderr,">>In func _DtTermDeviceStatus\n")) ;
243 context = GetParserContext(w) ;
244 STORELASTARG(context) ;
245 switch ( context->parms[1] ) {
246 case 5: /* as far as I know, all's well... So send OK */
247 sendEscSequence(w,"\033[0n") ;
250 /* cursor could be past last row (for autowrap) */
251 if ((col=tw->term.tpd->cursorColumn)>LASTCOLUMN(tw))
253 row = tw->term.tpd->cursorRow+BASE ;
254 if (vtd->originMode==True) row -= TOPMARGIN(tw) ;
255 sprintf(buf,"\033[%d;%dR",row , col+BASE) ;
256 sendEscSequence(w,buf) ;
262 _DtTermPModeSet(Widget w) /* DECSET CSI?ph */
264 ParserContext context ;
265 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
266 DtTermWidget vtw = (DtTermWidget)w;
268 Debug('P', fprintf(stderr,">>In func _DtTermPModeSet\n")) ;
269 context = GetParserContext(w) ;
270 STORELASTARG(context) ;
271 cnt = PCOUNT(context) ;
272 for (i=1;i<=cnt;i++) {
273 switch ( context->parms[i]) {
275 case 1: /* Cursor key (Application) */
276 vtw->vt.td->applicationMode=True;
278 /* case 2: can't return from vt52 mode */
279 case 3: /* Column (132) */
280 if ( vtw->vt.c132 ) { /* xterm allow 132 mode */
281 (void) _DtTermFuncClearBuffer(w, 0, fromParser);
282 vtw->term.tpd->cursorRow = TOPROW(vtw) ;
283 vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
284 vtw->term.tpd->scrollLockTopRow = TOPROW(vtw);
285 vtw->term.tpd->scrollLockBottomRow = BOTTOMROW(vtw) ;
286 XtVaSetValues(w, DtNcolumns, 132, NULL) ;
287 vtw->vt.td->col132Mode = True ;
290 case 4: /* Scroll (smooth) */
291 _DtTermPrimScrollComplete(w, True) ;
292 vtw->term.jumpScroll = False ;
294 case 5: /* Screen (Reverse) */
295 /*DKS: this is just to test out the functionality... */
296 vtw->term.reverseVideo = True;
297 /* clear the window to force refresh... */
298 (void) XClearArea(XtDisplay(w), XtWindow(w),
301 case 6: /* Origin mode (On) */
302 vtw->vt.td->originMode=True;
303 _DtTermPrimCursorMove(w, TOPMARGIN(vtw), 0);
305 case 7: /* Auto wrap (On) */
306 vtw->term.tpd->autoWrapRight=True ;
308 /* case 8: ** Auto repeat (On)
309 * ** This is handled by the X server
312 * case 18: ** Print form feed (On)
314 * case 19: ** Print extent (full screen)
317 case 25: /* Text cursor enable (On) */
318 (void) _DtTermPrimSetCursorVisible(w, True);
321 case 40: /* 80/132 mode (allow) */
322 vtw->vt.c132 = True ;
324 case 41: /* curses fix */
325 vtw->vt.td->fixCursesMode = True ;
327 case 44: /* margin bell (on) */
328 vtw->term.marginBell = True ;
330 case 45: /* Reverse-wraparound mode */
331 vtw->vt.td->reverseWrapMode=True;
333 case 46: /* logging (start) */
334 vtw->term.logging = True ;
335 _DtTermPrimStartLog(w);
337 /* case 47: ** screen buffer (alternate)
339 * case 1000: ** Send mouse x and y
341 * case 1001: ** Use hilite mouse tracking
350 _DtTermPModeReset(Widget w) /* DECRST CSI?pl */
352 ParserContext context ;
353 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
354 DtTermWidget vtw = (DtTermWidget)w;
356 Debug ('P', fprintf(stderr,">>In func _DtTermPModeReset\n")) ;
357 context = GetParserContext(w) ;
358 STORELASTARG(context) ;
359 cnt = PCOUNT(context) ;
360 for (i=1;i<=cnt;i++) {
361 switch ( context->parms[i]) {
363 case 1: /* Cursor key (Normal) */
364 vtw->vt.td->applicationMode=False;
366 /* case 2: ** set vt52 mode */
367 case 3: /* Column (80) */
368 if (vtw->vt.c132) { /* allow 132 mode */
369 (void) _DtTermFuncClearBuffer(w, 0, fromParser);
370 vtw->term.tpd->cursorRow = TOPROW(vtw) ;
371 vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
372 vtw->term.tpd->scrollLockTopRow = TOPROW(vtw);
373 vtw->term.tpd->scrollLockBottomRow = BOTTOMROW(vtw) ;
374 XtVaSetValues(w, DtNcolumns, 80, NULL) ;
375 vtw->vt.td->col132Mode = False ;
378 case 4: /* Scroll (jump) */
379 _DtTermPrimScrollComplete(w, True) ;
380 vtw->term.jumpScroll = True ;
382 case 5: /* Screen (normal ) */
383 /*DKS: this is just to test out the functionality... */
384 vtw->term.reverseVideo = False;
385 /* clear the window to force refresh... */
386 (void) XClearArea(XtDisplay(w), XtWindow(w),
389 case 6: /* Normal cursor (not Origin mode) */
390 vtw->vt.td->originMode=False;
391 _DtTermPrimCursorMove(w, 0, 0);
393 case 7: /* Auto wrap (Off) */
394 vtw->term.tpd->autoWrapRight=False;
396 /* case 8: ** Auto repeat (Off)
397 * ** implemented in the server
399 * case 18: ** Print form feed (Off)
401 * case 19: ** Print extent (scrolling region)
404 case 25: /* Text cursor enable (Off) */
405 (void) _DtTermPrimSetCursorVisible(w, False);
408 case 40: /* 80/132 mode (disallow) */
409 vtw->vt.c132 = False;
411 case 41: /* curses fix */
412 vtw->vt.td->fixCursesMode = False;
414 case 44: /* margin bell (off) */
415 vtw->term.marginBell = False ;
417 case 45: /* Reverse-wraparound mode */
418 vtw->vt.td->reverseWrapMode=False;
420 case 46: /* logging (stop ) */
421 vtw->term.logging = False ;
422 _DtTermPrimCloseLog(w) ;
424 /* case 47: ** screen buffer (normal)
426 * case 1000: ** don't send mouse x and y
428 * case 1001: ** don't use hilite mouse tracking
436 _DtTermSetMode(Widget w) /* SM CSIph */
438 ParserContext context ;
439 DtTermWidget vtw = (DtTermWidget)w ;
441 Debug('P', fprintf(stderr,">>In func _DtTermSetMode\n")) ;
442 context = GetParserContext(w) ;
443 STORELASTARG(context) ;
444 cnt = PCOUNT(context) ;
445 for (i=1;i<=cnt;i++) {
446 switch ( context->parms[i]) {
447 case 2: /* KAM Keyboard Action (locked) */
448 vtw->term.tpd->keyboardLocked.escape=True ;
449 (void) _DtTermPrimInvokeStatusChangeCallback(w);
451 case 4: /* Insert mode */
452 _DtTermPrimInsertCharUpdate(w, DtTERM_INSERT_CHAR_ON) ;
454 case 12: /* SRM Send/Receive (Off) */
455 vtw->term.tpd->halfDuplex = False;
457 case 20: /* Line feed/newline (new line) */
458 vtw->term.tpd->autoLineFeed=True ;
465 _DtTermResetMode(Widget w) /* RM CSIpl */
467 ParserContext context ;
468 DtTermWidget vtw = (DtTermWidget)w ;
470 Debug('P', fprintf(stderr,">>In func _DtTermResetMode\n")) ;
471 context = GetParserContext(w) ;
472 STORELASTARG(context) ;
473 cnt = PCOUNT(context) ;
474 for (i=1;i<=cnt;i++) {
475 switch ( context->parms[i]) {
476 case 2: /* KAM Keyboard Action (unlocked) */
477 vtw->term.tpd->keyboardLocked.escape=False;
478 (void) _DtTermPrimInvokeStatusChangeCallback(w);
480 case 4: /* Replace mode */
481 _DtTermPrimInsertCharUpdate(w, DtTERM_INSERT_CHAR_OFF) ;
483 case 12: /* SRM Send/Receive (On) */
484 vtw->term.tpd->halfDuplex = True;
486 case 20: /* Line feed/newline (line feed) */
487 vtw->term.tpd->autoLineFeed=False ;
494 _DtTermCursorPos(Widget w) /* CUP CSIp;pH */
496 ParserContext context ;
497 DtTermWidget vtw = (DtTermWidget) w;
499 Debug( 'P', fprintf(stderr,">>In func _DtTermCursorPos\n")) ;
500 context = GetParserContext(w) ;
501 STORELASTARG(context) ;
502 row = context->parms[1] ;
503 col = context->parms[2] ;
506 if (vtw->vt.td->originMode) row += vtw->term.tpd->scrollLockTopRow ;
507 if (row > FLOOR(vtw)) row = FLOOR(vtw) ;
508 if (col > LASTCOLUMN(vtw)) col = LASTCOLUMN(vtw) ;
509 vtw->term.tpd->cursorRow = row ;
510 vtw->term.tpd->cursorColumn = col ;
514 _DtTermEraseDisplay(Widget w) /* ED CSIpJ */
517 DtTermWidget vtw = (DtTermWidget) w;
518 ParserContext context ;
519 DtEraseMode eraseMode;
522 Debug('P', fprintf(stderr,">>In func _DtTermEraseDisplay\n")) ;
523 context = GetParserContext(w) ;
525 STORELASTARG(context) ;
526 row = vtw->term.tpd->cursorRow;
527 col = vtw->term.tpd->cursorColumn ;
530 ** pick the correct erase mode...
532 switch (context->parms[1])
535 eraseMode = eraseToEOB;
538 eraseMode = eraseFromRow0Col0;
541 eraseMode = eraseBuffer;
544 _DtTermFuncEraseInDisplay(w, (int)eraseMode, fromParser);
545 vtw->term.tpd->cursorRow = row;
546 vtw->term.tpd->cursorColumn = col;
550 _DtTermEraseChars(Widget w) /* ECH CSIpX */
552 ParserContext context ;
553 DtTermWidget vtw = (DtTermWidget) w;
555 Debug('P', fprintf(stderr,">>In func _DtTermEraseChars\n")) ;
557 context = GetParserContext(w) ;
558 row = vtw->term.tpd->cursorRow ;
559 col = vtw->term.tpd->cursorColumn ;
560 STORELASTARG(context) ;
561 cnt = context->parms[1] ;
564 if ( cnt > LASTCOLUMN(vtw)-col+1 ) cnt = LASTCOLUMN(vtw)-col+1 ;
566 _DtTermFuncEraseCharacter(w, cnt, fromParser);
570 _DtTermInsertChars(Widget w) /* ICH CSIp@ */
572 DtTermWidget vtw = (DtTermWidget) w;
573 ParserContext context ;
575 DtTermInsertCharMode saveInsertCharMode;
577 Debug('P', fprintf(stderr,">>In func _DtTermInsertChars\n")) ;
579 context = GetParserContext(w) ;
580 vtw->term.tpd->parserNotInStartState = False ;
581 row = vtw->term.tpd->cursorRow ;
582 col = vtw->term.tpd->cursorColumn ;
583 STORELASTARG(context) ;
584 cnt = context->parms[1] ;
588 if (cnt > LASTCOLUMN(vtw) - col + 1)
589 cnt = LASTCOLUMN(vtw) - col + 1;
591 /* save away the insert char mode... */
592 saveInsertCharMode = vtw->term.tpd->insertCharMode;
594 /* turn on insert char mode. We don't want to invoke any status
595 * change callbacks, so we will justs set it directly...
597 vtw->term.tpd->insertCharMode = DtTERM_INSERT_CHAR_ON;
599 /* insert blanks... */
601 (void) _DtTermPrimInsertText(w,(unsigned char *) " ", 1) ;
603 /* restore the insert char mode... */
604 vtw->term.tpd->insertCharMode = saveInsertCharMode;
606 _DtTermPrimCursorMove(w,row,col) ;
610 _DtTermCursorUp(Widget w) /* CUU CISpA */
612 ParserContext context ;
613 DtTermWidget vtw = (DtTermWidget) w;
614 int trow, row, tmargin, cnt;
615 Debug('P', fprintf(stderr,">>In func _DtTermCursorUp\n")) ;
616 context = GetParserContext(w) ;
618 tmargin = TOPMARGIN(vtw) ;
620 STORELASTARG(context) ;
621 cnt = context->parms[1] ;
623 else if (cnt>MAXSHORT) cnt=MAXSHORT-100;
624 row = vtw->term.tpd->cursorRow-cnt;
625 /* are we about the top margin and did we actually cross it? */
626 /* This handles the case top margin == top row */
627 if (row < tmargin && row+cnt >= tmargin) row = tmargin;
628 _DtTermPrimCursorMove(w, row, vtw->term.tpd->cursorColumn) ;
632 _DtTermCursorDown(Widget w) /* CUD CISpB */
634 ParserContext context ;
635 DtTermWidget vtw = (DtTermWidget) w;
636 int bmargin, row, cnt, brow ;
637 Debug('P', fprintf(stderr,">>In func _DtTermCursorDown\n")) ;
638 context = GetParserContext(w) ;
640 bmargin = BOTTOMMARGIN(vtw) ;
641 brow = BOTTOMROW(vtw) ;
642 STORELASTARG(context) ;
643 cnt = context->parms[1] ;
645 row = vtw->term.tpd->cursorRow+cnt;
646 /* are we below bottom margin and did we actually cross it? */
647 /* NOTE that this also handles the case when bmargin == brow */
648 if (row > bmargin && row-cnt <= bmargin) row = bmargin;
649 /* did we start below bottom margin and cross bottom row? */
650 if (row > brow && bmargin < brow ) row = brow;
651 _DtTermPrimCursorMove(w, row, vtw->term.tpd->cursorColumn) ;
655 _DtTermCursorForward(Widget w) /* CUF CISpC */
657 ParserContext context ;
658 DtTermWidget vtw = (DtTermWidget) w;
660 Debug('P', fprintf(stderr,">>In func _DtTermCursorForward\n")) ;
661 context = GetParserContext(w) ;
663 lcol = LASTCOLUMN(vtw) ;
664 STORELASTARG(context) ;
665 cnt = context->parms[1] ;
667 col = vtw->term.tpd->cursorColumn+cnt;
668 if (col>lcol) col=lcol;
669 _DtTermPrimCursorMove(w,vtw->term.tpd->cursorRow,col);
673 _DtTermCursorBack(Widget w) /* CUB CISpD */
675 ParserContext context ;
676 DtTermWidget vtw = (DtTermWidget) w;
677 int i,k,j,row,col,fcol,cnt ;
678 Debug('P', fprintf(stderr,">>In func _DtTermCursorBack\n")) ;
680 context = GetParserContext(w) ;
681 STORELASTARG(context) ;
682 cnt = context->parms[1] ;
683 fcol = FIRSTCOLUMN(vtw) ;
684 row = vtw->term.tpd->cursorRow;
685 col = vtw->term.tpd->cursorColumn;
687 if ((col -= cnt) < 0) {
688 if(vtw->vt.td->reverseWrapMode && vtw->term.tpd->autoWrapRight) {
689 int lastrow = BOTTOMROW(vtw);
690 if (vtw->vt.td->originMode) {
691 row-=TOPMARGIN(vtw) ;
692 lastrow = BOTTOMMARGIN(vtw)-TOPMARGIN(vtw);
694 if((i = (j = LASTCOLUMN(vtw) + 1) * row + col) < 0) {
695 k = j * (lastrow + 1);
696 i += ((-i) / k + 1) * k;
699 if (vtw->vt.td->originMode) row+=TOPMARGIN(vtw);
704 _DtTermPrimCursorMove(w,row,col);
708 _DtTermCursorToLineUp(Widget w) /* CPL CSIpF */
710 DtTermWidget vtw = (DtTermWidget) w;
711 ParserContext context ;
712 Debug('P', fprintf(stderr,">>In func _DtTermCursorToLineUp\n")) ;
714 context = GetParserContext(w) ;
715 vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
720 _DtTermCursorToCol(Widget w) /* CHA CSIpG */
722 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
723 ParserContext context ;
724 context = GetParserContext(w) ;
725 STORELASTARG(context) ;
726 if (!context->parms[1] ) context->parms[1]=1;
727 if (context->parms[1]>tw->term.columns) context->parms[1]=tw->term.columns;
728 tw->term.tpd->cursorColumn = context->parms[1] - BASE ;
732 _DtTermEraseInLine(Widget w) /* EL ESC[pK */
734 DtTermWidget vtw = (DtTermWidget) w;
735 ParserContext context ;
736 DtEraseMode eraseMode;
739 Debug('P', fprintf(stderr,">>In func _DtTermEraseInLine\n")) ;
741 context = GetParserContext(w) ;
742 STORELASTARG(context) ;
744 ** pick the correct erase mode...
746 switch ( context->parms[1] )
749 eraseMode = eraseToEOL;
753 eraseMode = eraseFromCol0;
757 eraseMode = eraseLine;
761 _DtTermFuncEraseInLine(w, (int)eraseMode, fromParser);
765 _DtTermInsertLines(Widget w) /* IL CSIpL */
767 DtTermWidget vtw = (DtTermWidget) w;
768 ParserContext context ;
770 Debug('P', fprintf(stderr,">>In func _DtTermInsertLines\n")) ;
771 if ( vtw->term.tpd->cursorRow < TOPMARGIN(vtw) ||
772 vtw->term.tpd->cursorRow > BOTTOMMARGIN(vtw) )/*outside scrolling region*/
774 context = GetParserContext(w) ;
775 KILLWRAP((DtTermWidget)w) ;
776 STORELASTARG(context) ;
777 cnt=context->parms[1];
779 lines = BOTTOMMARGIN(vtw) - vtw->term.tpd->cursorRow + 1;
780 if (cnt > lines) cnt=lines ;
781 _DtTermFuncInsertLine(w,cnt,fromParser) ;
785 _DtTermDeleteLines(Widget w) /* DL CSIpM */
787 DtTermWidget vtw = (DtTermWidget) w;
788 ParserContext context ;
790 Debug('P', fprintf(stderr,">>In func _DtTermDeleteLines\n")) ;
792 if ( vtw->term.tpd->cursorRow < TOPMARGIN(vtw) ||
793 vtw->term.tpd->cursorRow > BOTTOMMARGIN(vtw) ) /* outside scrolling region*/
795 KILLWRAP((DtTermWidget)w) ;
796 context = GetParserContext(w) ;
797 STORELASTARG(context) ;
798 cnt = context->parms[1];
800 _DtTermFuncDeleteLine(w,cnt,fromParser) ;
804 _DtTermDeleteChars(Widget w) /* DCH CSIpP */
806 ParserContext context ;
807 DtTermWidget vtw = (DtTermWidget) w;
809 Debug('P', fprintf(stderr,">>In func _DtTermDeleteChars\n")) ;
811 context = GetParserContext(w) ;
812 STORELASTARG(context) ;
813 cnt= context->parms[1];
815 else if (cnt>MAXSHORT) cnt=MAXSHORT-100;
816 _DtTermFuncDeleteChar(w,cnt,fromParser) ;
820 _DtTermNextLine(Widget w) /* NEL ESCE */
822 DtTermWidget vtw = (DtTermWidget) w;
824 Debug('P', fprintf(stderr,">>In func _DtTermNextLine\n")) ;
825 vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
826 _DtTermIndex(w) ; /* use IND */
830 _DtTermReverseIndex(Widget w) /* RI ESCM */
832 DtTermWidget vtw = (DtTermWidget) w;
833 int tmargin, trow, col;
834 Debug('P', fprintf(stderr,">>In func _DtTermReverseIndex\n")) ;
837 tmargin = TOPMARGIN(vtw) ;
838 col = vtw->term.tpd->cursorColumn ;
839 if ( vtw->term.tpd->cursorRow == tmargin) {
840 _DtTermFuncInsertLine(w,1,fromParser) ;
841 /* _DtTermFuncInsertLine sets column to first column */
842 vtw->term.tpd->cursorColumn = col ;
844 else if (vtw->term.tpd->cursorRow > trow){
845 vtw->term.tpd->cursorRow-- ;
850 _DtTermIndex(Widget w) /* IND ESCD */
852 DtTermWidget vtw = (DtTermWidget) w;
854 Debug('P', fprintf(stderr,">>In func _DtTermIndex\n")) ;
856 brow = BOTTOMROW(vtw) ;
857 bmargin = BOTTOMMARGIN(vtw) ;
858 if ( vtw->term.tpd->cursorRow == bmargin) {
859 (void) _DtTermPrimScrollText(w, 1);
861 else if (vtw->term.tpd->cursorRow < brow){
862 vtw->term.tpd->cursorRow++ ;
864 (void) _DtTermPrimFillScreenGap(w);
868 _DtTermScrollingRegion(Widget w) /* DECSTBM CSIp;pr */
870 DtTermWidget vtw = (DtTermWidget)w ;
871 ParserContext context ;
873 Debug('P', fprintf(stderr,">>In func _DtTermScrollingRegion\n")) ;
874 context = GetParserContext(w) ;
875 STORELASTARG(context) ;
876 row1 = context->parms[1] ;
877 row2 = context->parms[2] ;
878 if (!row1) row1 = 1 ;
879 if (!row2 || row2>vtw->term.rows) row2 = vtw->term.rows ;
883 if ( row1 == TOPROW(vtw) && row2 == BOTTOMROW(vtw))
884 vtw->term.tpd->memoryLockMode=SCROLL_LOCKoff ;
886 vtw->term.tpd->memoryLockMode=SCROLL_LOCKon ;
887 vtw->term.tpd->scrollLockTopRow = row1 ;
888 vtw->term.tpd->scrollLockBottomRow = row2 ;
889 if (vtw->vt.td->originMode) _DtTermPrimCursorMove(w,row1,0) ;
890 else _DtTermPrimCursorMove(w,0,0) ;
895 _DtTermCharAttributes(Widget w) /* SGR CSIpm */
897 ParserContext context ;
899 Debug('P', fprintf(stderr,">>In func _DtTermCharAttributes\n")) ;
900 context = GetParserContext(w) ;
901 STORELASTARG(context) ;
902 cnt = PCOUNT(context) ;
903 if(PCOUNT(context)) {
904 for (cnt=1; cnt <= PCOUNT(context); cnt++)
905 _DtTermVideoEnhancement(w,context->parms[cnt]) ;
908 _DtTermVideoEnhancement(w,0) ;
912 _DtTermDeviceAttributes(Widget w) /* DA CSIpc */
914 DtTermWidget vtw = (DtTermWidget) w;
915 ParserContext context ;
918 Debug('P', fprintf(stderr,">>In func _DtTermDeviceAttributes\n")) ;
919 context = GetParserContext(w) ;
920 STORELASTARG(context) ;
921 switch(context->parms[1]) {
923 switch(vtw->vt.td->terminalId ) {
925 sprintf(buf,"\033[?%d;%dc",1,2) ;
928 sprintf(buf,"\033[?%d;%dc",1,0) ;
931 sprintf(buf,"\033[?%dc",6) ;
934 /* class 2 terminal (62), 132 columns (1), printer port (2),
935 * selective erase (6), DRCS (7), UDK (8),
936 * national replacement char sets
938 sprintf(buf,"\033[?%d;%d;%d;%d;%d;%d;%dc",62,1,2,6,7,8,9) ;
941 sendEscSequence(w,buf) ;
947 _DtTermChangeTextParam(Widget w) /* xterm CSIp;pcCtrl-G */
949 ParserContext context ;
950 DtTermWidget tw = (DtTermWidget) w;
951 DtTermData vtd = tw->vt.td;
955 Debug('P', fprintf(stderr,">>In func _DtTermChangeTextParam\n")) ;
956 context = GetParserContext(w) ;
958 for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
960 * context->parms[1] is inited to 0, so if no numeric param was entered,
961 * we default appropriately to case 0.
963 switch(context->parms[1]) {
964 case 0: /* change Icon name and Window title */
965 XtSetArg(arg[i], XmNtitle, context->stringParms[0].str); i++;
966 XtSetArg(arg[i], XmNiconName, context->stringParms[0].str); i++;
967 XtSetValues(sw,arg,i) ;
969 case 1: /* change Icon name */
970 XtSetArg(arg[i], XmNiconName, context->stringParms[0].str); i++;
971 XtSetValues(sw,arg,i) ;
973 case 2: /* change Window title */
974 XtSetArg(arg[i], XmNtitle, context->stringParms[0].str); i++;
975 XtSetValues(sw,arg,i) ;
977 case 3: /* change current working directory */
978 tw->term.subprocessCWD = XtRealloc(tw->term.subprocessCWD,
979 strlen((char *) context->stringParms[0].str) + 1);
980 (void) strcpy(tw->term.subprocessCWD,
981 (char *) context->stringParms[0].str);
983 /* These are handled by xterm but not by us.
984 case 46: Change log file to context->stringParms[0]
986 case 50: ** change font to context->stringParms[0]
993 _DtTermTabClear(Widget w) /* TBC CSIpg */
995 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
996 TermBuffer tb = tw->term.tpd->termBuffer ;
997 ParserContext context ;
999 Debug('P', fprintf(stderr,">>In func _DtTermTabClear\n")) ;
1000 context = GetParserContext(w) ;
1001 STORELASTARG(context) ;
1002 type = context->parms[1] ;
1004 case 0:(void)_DtTermPrimBufferClearTab(tb,tw->term.tpd->cursorColumn) ;
1006 case 3: (void)_DtTermPrimBufferClearAllTabs(tb) ;
1012 _DtTermRequestParam(Widget w) /* DECREQTPARM CSIpx */
1014 ParserContext context ;
1017 Debug('P', fprintf(stderr,">>In func _DtTermRequestParam\n")) ;
1018 context = GetParserContext(w) ;
1019 STORELASTARG(context) ;
1020 row = context->parms[1] ;
1024 /* row (?), 1 no parity, 1 eight bits, 112 xmit 9600 baud,
1025 * 112, receive 9600 baud, 1 clock multiplier (?),
1026 * 0 STP flags (?) These are from xterm file 'charproc.c'.
1028 sprintf(buf,"\033[%d;%d;%d;%d;%d;%d;%dx",row,1,1,112,112,1,0) ;
1029 sendEscSequence(w,buf) ;
1035 _DtTermTabSet(Widget w) /* HTS ESCH */
1037 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1038 TermBuffer tb = tw->term.tpd->termBuffer ;
1039 Debug('P', fprintf(stderr,">>In func _DtTermTabSet\n")) ;
1040 (void)_DtTermPrimBufferSetTab(tb,tw->term.tpd->cursorColumn) ;
1044 _DtTermSaveCursor(Widget w) /* DECSC ESC7 */
1046 DtTermWidget vtw = (DtTermWidget) w;
1047 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1048 DtTermBuffer tb = (DtTermBuffer)tw->term.tpd->termBuffer ;
1049 DtTermData vtd = vtw->vt.td;
1051 Debug('P', fprintf(stderr,">>In func _DtTermSaveCursor\n")) ;
1052 vtd->saveCursor.cursorRow = vtw->term.tpd->cursorRow ;
1053 vtd->saveCursor.cursorColumn = vtw->term.tpd->cursorColumn ;
1054 vtd->saveCursor.originMode = vtw->vt.td->originMode ;
1055 /* The following is save at the TermPrim level */
1056 /* vtw->vt.td->saveCursor.wrapMode = */
1057 vtd->saveCursor.enhVideoState = vtd->enhVideoState ;
1058 vtd->saveCursor.enhFieldState = vtd->enhFieldState ;
1059 vtd->saveCursor.enhFgColorState = vtd->enhFgColorState;
1060 vtd->saveCursor.enhBgColorState = vtd->enhBgColorState;
1061 vtd->saveCursor.GL = vtd->GL;
1062 vtd->saveCursor.GR = vtd->GR;
1063 vtd->saveCursor.G0 = vtd->G0;
1064 vtd->saveCursor.G1 = vtd->G1;
1065 vtd->saveCursor.G2 = vtd->G2;
1066 vtd->saveCursor.G3 = vtd->G3;
1067 vtd->saveCursor.singleShiftFont = vtd->singleShiftFont;
1068 vtd->saveCursor.singleShiftPending = vtd->singleShiftPending;
1072 _DtTermRestoreCursor(Widget w) /* DECRC ESC8 */
1074 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1075 DtTermPrimData tpd = tw->term.tpd;
1076 DtTermWidget vtw = (DtTermWidget) w;
1077 DtTermData vtd = vtw->vt.td;
1079 Debug('P', fprintf(stderr,">>In func _DtTermRestoreCursor\n")) ;
1080 tpd->cursorRow = vtd->saveCursor.cursorRow ;
1081 tpd->cursorColumn = vtd->saveCursor.cursorColumn ;
1082 vtw->vt.td->originMode = vtd->saveCursor.originMode ;
1083 tpd->autoWrapRight = vtd->saveCursor.wrapMode ;
1084 vtd->enhVideoState = vtd->saveCursor.enhVideoState ;
1085 vtd->enhFieldState = vtd->saveCursor.enhFieldState ;
1086 vtd->enhFgColorState = vtd->saveCursor.enhFgColorState;
1087 vtd->enhBgColorState = vtd->saveCursor.enhBgColorState;
1088 vtd->GR = vtd->saveCursor.GR;
1089 vtd->GL = vtd->saveCursor.GL;
1090 vtd->G0 = vtd->saveCursor.G0;
1091 vtd->G1 = vtd->saveCursor.G1;
1092 vtd->G2 = vtd->saveCursor.G2;
1093 vtd->G3 = vtd->saveCursor.G3;
1094 vtd->singleShiftFont = vtd->saveCursor.singleShiftFont;
1095 vtd->singleShiftPending = vtd->saveCursor.singleShiftPending;
1096 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1097 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhVideo,
1098 vtd->enhVideoState);
1099 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1100 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhField,
1101 vtd->enhFieldState);
1102 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1103 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhFont,
1105 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1106 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhBgColor,
1107 vtd->saveCursor.enhBgColorState);
1108 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1109 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhFgColor,
1110 vtd->saveCursor.enhFgColorState);
1111 if ( vtd->originMode ) {
1112 if (tpd->cursorRow < tpd->scrollLockTopRow )
1113 tpd->cursorRow = tpd->scrollLockTopRow ;
1114 else if (tpd->cursorRow > tpd->scrollLockBottomRow )
1115 tpd->cursorRow = tpd->scrollLockBottomRow ;
1120 _DtTermAppKeypad(Widget w) /* DECPAM ESC= */
1122 DtTermWidget vtw = (DtTermWidget) w;
1123 Debug('P', fprintf(stderr,">>In func _DtTermAppKeypad\n")) ;
1124 vtw->vt.td->applicationKPMode=True;
1128 _DtTermNormalKeypad(Widget w) /* DECPNM ESC> */
1130 DtTermWidget vtw = (DtTermWidget) w;
1131 Debug('P', fprintf(stderr,">>In func _DtTermNormalKeypad\n")) ;
1132 vtw->vt.td->applicationKPMode=False;
1136 _DtTermS8C1T(Widget w) /* S8C1T ESCG */
1138 DtTermWidget vtw = (DtTermWidget) w;
1139 Debug('P', fprintf(stderr,">>In func _vt8CIT\n")) ;
1140 vtw->vt.td->S8C1TMode=True;
1144 _DtTermS7C1T(Widget w) /* S7C1T ESCF */
1146 DtTermWidget vtw = (DtTermWidget) w;
1147 Debug('P', fprintf(stderr,">>In func _vt8CIT\n")) ;
1148 vtw->vt.td->S8C1TMode=False;
1152 _DtTermSetCompatLevel(Widget w) /* DECSCL CSI p;p"p (last p literal) */
1154 ParserContext context ;
1155 DtTermWidget vtw = (DtTermWidget) w;
1156 Debug('P', fprintf(stderr,">>In func _DtTermSetCompatLevel\n")) ;
1157 context = GetParserContext(w) ;
1158 STORELASTARG(context) ;
1159 vtw->vt.td->compatLevel= 2; /* assume vt200 mode */
1160 switch ( PCOUNT(context) ) {
1161 case 1: switch (context->parms[1]) {
1162 case 61: vtw->vt.td->compatLevel= 1;
1163 vtw->vt.td->S8C1TMode=False;
1165 case 62: vtw->vt.td->S8C1TMode=True;
1169 case 2: switch (context->parms[2]) {
1171 case 2: vtw->vt.td->S8C1TMode=True;
1174 vtw->vt.td->S8C1TMode=False;
1181 _DtTermInvokeG3(Widget w) /* LS3R ESC| */
1183 ParserContext context ;
1185 Debug('P', fprintf(stderr,">>In func _DtTermInvokeG3\n")) ;
1186 context = GetParserContext(w) ;
1190 _DtTermInvokeG2(Widget w) /* LS3R ESC} */
1192 ParserContext context ;
1194 Debug('P', fprintf(stderr,">>In func _DtTermInvokeG2\n")) ;
1195 context = GetParserContext(w) ;
1199 _DtTermScrollUp(Widget w) /* SU CSIpS */
1201 ParserContext context ;
1202 DtTermWidget vtw = (DtTermWidget) w;
1205 Debug('P', fprintf(stderr,">>In func _DtTermScrollUp\n")) ;
1206 #define EXIT_IF_OUTSIDE_SR(w) if((w)->term.tpd->scrollLockTopRow > \
1207 (w)->term.tpd->cursorRow || \
1208 (w)->term.tpd->scrollLockBottomRow < \
1209 (w)->term.tpd->cursorRow) \
1211 EXIT_IF_OUTSIDE_SR(vtw)
1213 context = GetParserContext(w) ;
1214 row = vtw->term.tpd->cursorRow;
1215 col = vtw->term.tpd->cursorColumn;
1216 STORELASTARG(context) ;
1217 if (!context->parms[1])
1218 context->parms[1] = 1;
1219 else if (context->parms[1] > MAXSHORT)
1220 context->parms[1] = MAXSHORT - 100;
1222 /* clip the number of rows to the scroll region... */
1223 if (context->parms[1] > (vtw->term.tpd->scrollLockBottomRow -
1224 vtw->term.tpd->scrollLockTopRow + 1)) {
1225 context->parms[1] = vtw->term.tpd->scrollLockBottomRow -
1226 vtw->term.tpd->scrollLockTopRow + 1;
1229 vtw->term.tpd->cursorRow = TOPMARGIN(vtw) ;
1230 _DtTermFuncDeleteLine(w, context->parms[1], fromParser);
1231 vtw->term.tpd->cursorRow = row;
1232 vtw->term.tpd->cursorColumn = col;
1236 _DtTermScrollDown(Widget w) /* SD CSIpT */
1238 ParserContext context ;
1239 DtTermWidget vtw = (DtTermWidget) w;
1242 Debug('P', fprintf(stderr,">>In func _DtTermScrollDown\n")) ;
1243 EXIT_IF_OUTSIDE_SR(vtw)
1245 context = GetParserContext(w) ;
1246 row = vtw->term.tpd->cursorRow;
1247 col = vtw->term.tpd->cursorColumn ;
1248 STORELASTARG(context) ;
1249 if (!context->parms[1])
1250 context->parms[1] = 1;
1251 else if (context->parms[1] > MAXSHORT)
1252 context->parms[1] = MAXSHORT - 100;
1254 /* clip the number of rows to the scroll region... */
1255 if (context->parms[1] > (vtw->term.tpd->scrollLockBottomRow -
1256 vtw->term.tpd->scrollLockTopRow) + 1) {
1257 context->parms[1] = vtw->term.tpd->scrollLockBottomRow -
1258 vtw->term.tpd->scrollLockTopRow + 1;
1261 vtw->term.tpd->cursorRow = TOPMARGIN(vtw) ;
1262 _DtTermFuncInsertLine(w, context->parms[1], fromParser) ;
1263 vtw->term.tpd->cursorRow = row;
1264 vtw->term.tpd->cursorColumn = col;
1268 _DtTermRestoreModeValues(Widget w) /* xterm - Restore DEC mode values CSI?pr */
1270 ParserContext context ;
1271 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1272 DtTermWidget vtw = (DtTermWidget)w;
1273 DtTermData vtd = vtw->vt.td;
1275 Debug ('P', fprintf(stderr,">>In func _DtTermPModeReset\n")) ;
1276 context = GetParserContext(w) ;
1277 STORELASTARG(context) ;
1278 cnt = PCOUNT(context) ;
1279 for (i=1;i<=cnt;i++) {
1280 switch ( context->parms[i]) {
1282 case 1: /* Cursor key (Normal/Application) */
1283 vtd->applicationMode = vtd->saveDECMode.applicationMode ;
1285 #ifdef NOT_SUPPORTED
1286 case 2: /* set vt52 mode */
1288 #endif /* NOT_SUPPORTED */
1289 case 3: /* Columns (80/132) */
1290 vtd->col132Mode = vtd->saveDECMode.col132Mode ;
1292 case 4: /* Scroll Mode ( jump/smooth ) */
1293 _DtTermPrimScrollComplete(w, True) ;
1294 vtw->term.jumpScroll = vtd->saveDECMode.jumpScrollMode ;
1296 case 5: /* Screen mode */
1297 vtw->term.reverseVideo = vtd->saveDECMode.inverseVideoMode ;
1299 case 6: /* Origin mode (on/off)*/
1300 vtd->originMode = vtd->saveDECMode.originMode ;
1302 case 7: /* Auto wrap (On/Off) */
1303 vtw->term.tpd->autoWrapRight = vtd->saveDECMode.wrapMode ;
1305 case 8: /* Auto repeat (Off) */
1306 /* implemented in the server */
1308 #ifdef NOT_SUPPORTED
1309 case 18: /* Print form feed (Off) */
1311 case 19: /* Print extent (scrolling region) */
1313 #endif /* NOT_SUPPORTED */
1314 case 25: /* Text cursor enable (Off) */
1315 _DtTermPrimSetCursorVisible(w,
1316 vtd->saveDECMode.cursorVisible);
1320 case 40: /* 80/132 mode (disallow/allow) */
1321 vtw->vt.c132 = vtd->saveDECMode.allow80_132ColMode;
1323 case 41: /* curses fix (off/on) */
1324 vtd->fixCursesMode = vtd->saveDECMode.fixCursesMode;
1326 case 44: /* margin bell (off/on) */
1327 vtw->term.marginBell = vtd->saveDECMode.marginBellMode;
1329 case 45: /* Reverse-wraparound mode */
1330 vtd->reverseWrapMode = vtd->saveDECMode.reverseWrapMode ;
1332 case 46: /* logging (stop/start ) */
1333 if (vtd->saveDECMode.logging) {
1334 vtw->term.logging = True ;
1335 _DtTermPrimStartLog(w);
1337 vtw->term.logging = False ;
1338 _DtTermPrimCloseLog(w) ;
1341 #ifdef NOT_SUPPORTED
1342 case 47: /* screen buffer (normal) */
1344 case 1000: /* don't send mouse x and y */
1346 case 1001: /* don't use hilite mouse tracking */
1348 #endif /* NOT_SUPPORTED */
1354 _DtTermSaveModeValues(Widget w) /* xterm - Save DEC mode values CSI?ps */
1356 ParserContext context ;
1357 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1358 DtTermWidget vtw = (DtTermWidget)w;
1359 DtTermData vtd = vtw->vt.td;
1361 Debug ('P', fprintf(stderr,">>In func _DtTermPModeReset\n")) ;
1362 context = GetParserContext(w) ;
1363 STORELASTARG(context) ;
1364 cnt = PCOUNT(context) ;
1365 for (i=1;i<=cnt;i++) {
1366 switch ( context->parms[i]) {
1368 case 1: /* Cursor key (Normal/Application) */
1369 vtd->saveDECMode.applicationMode = vtd->applicationMode ;
1371 #ifdef NOT_SUPPORTED
1372 case 2: /* set vt52 mode */
1374 #endif /* NOT_SUPPORTED */
1375 case 3: /* Columns (80/132) */
1376 vtd->saveDECMode.col132Mode = vtd->col132Mode ;
1378 case 4: /* Scroll Mode ( jump/smooth ) */
1379 vtd->saveDECMode.jumpScrollMode = vtw->term.jumpScroll ;
1381 case 5: /* Screen mode */
1382 vtd->saveDECMode.inverseVideoMode = vtw->term.reverseVideo ;
1384 case 6: /* Origin mode (on/off)*/
1385 vtd->saveDECMode.originMode = vtd->originMode ;
1387 case 7: /* Auto wrap (On/Off) */
1388 vtd->saveDECMode.wrapMode = vtw->term.tpd->autoWrapRight ;
1390 case 8: /* Auto repeat (Off) */
1391 /* implemented in the server */
1393 #ifdef NOT_SUPPORTED
1394 case 18: /* Print form feed (Off) */
1396 case 19: /* Print extent (scrolling region) */
1398 #endif /* NOT_SUPPORTED */
1399 case 25: /* Text cursor enable (Off) */
1400 vtd->saveDECMode.cursorVisible =
1401 _DtTermPrimGetCursorVisible(w);
1404 case 40: /* 80/132 mode (disallow/allow) */
1405 vtd->saveDECMode.allow80_132ColMode = vtw->vt.c132;
1407 case 41: /* curses fix (off/on) */
1408 vtd->saveDECMode.fixCursesMode = vtd->fixCursesMode ;
1410 case 44: /* margin bell (off/on) */
1411 vtd->saveDECMode.marginBellMode = vtw->term.marginBell ;
1413 case 45: /* Reverse-wraparound mode */
1414 vtd->saveDECMode.reverseWrapMode = vtd->reverseWrapMode ;
1416 case 46: /* logging (stop/start ) */
1417 vtd->saveDECMode.logging = vtw->term.logging;
1419 #ifdef NOT_SUPPORTED
1420 case 47: /* screen buffer (normal) */
1422 case 1000: /* don't send mouse x and y */
1424 case 1001: /* don't use hilite mouse tracking */
1426 #endif /* NOT_SUPPORTED */
1433 _DtTermAlignTest(Widget w) /* DECALN ESC#8 */
1435 DtTermWidget vtw = (DtTermWidget) w;
1436 int tlrow, blrow, cnt ;
1437 Debug('P', fprintf(stderr,">>In func _DtTermAlignTest\n")) ;
1438 vtw->term.tpd->parserNotInStartState = False ;
1439 tlrow = vtw->term.tpd->scrollLockTopRow ;
1440 blrow = vtw->term.tpd->scrollLockBottomRow ;
1441 vtw->term.tpd->scrollLockTopRow = TOPROW(w) ; ;
1442 vtw->term.tpd->scrollLockBottomRow = BOTTOMROW(vtw) ;
1443 cnt = (BOTTOMROW(vtw)+BASE)*(LASTCOLUMN(vtw)+BASE);
1444 vtw->term.tpd->cursorColumn = FIRSTCOLUMN(w) ;
1445 vtw->term.tpd->cursorRow = TOPROW(w) ;
1446 while(cnt--) _DtTermPrimInsertText(w,(unsigned char *) "E", 1) ;
1447 vtw->term.tpd->scrollLockTopRow = tlrow ;
1448 vtw->term.tpd->scrollLockBottomRow = blrow ;
1449 vtw->term.tpd->cursorRow = CEILING(vtw) ;
1450 vtw->term.tpd->cursorColumn = FIRSTCOLUMN(w) ;
1454 _DtTermInvokeG1(Widget w) /* ESC~ESC */
1456 ParserContext context ;
1458 Debug('P', fprintf(stderr,">>In func _DtTermInvokeG1\n")) ;
1459 context = GetParserContext(w) ;
1463 _DtTermSelEraseInLine(Widget w) /* DECSEL ESC?pK */
1465 DtTermWidget vtw = (DtTermWidget) w;
1466 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1467 TermBuffer tb = tw->term.tpd->termBuffer ;
1468 DtTermPrimData tpd = tw->term.tpd;
1469 DtTermData td = vtw->vt.td;
1470 ParserContext context ;
1472 int c,col1,col2,col,row ;
1474 DtTermInsertCharMode saveInsertCharMode;
1476 Debug('P', fprintf(stderr,">>In func _DtTermSelEraseInLine\n")) ;
1478 context = GetParserContext(w) ;
1479 STORELASTARG(context) ;
1480 col1 = FIRSTCOLUMN(vtw) ;
1481 col2 = LASTCOLUMN(vtw) ;
1482 switch ( context->parms[1] ) {
1484 col1= tpd->cursorColumn;
1487 col2 = tpd->cursorColumn;
1494 /* save away the current cursor position... */
1495 col = tpd->cursorColumn ;
1496 row = tpd->cursorRow ;
1498 /* save away the current insert mode... */
1499 saveInsertCharMode = vtw->term.tpd->insertCharMode;
1501 /* insert char needs to be off... */
1502 tpd->insertCharMode = DtTERM_INSERT_CHAR_OFF;
1504 tpd->parserNotInStartState = False ;
1508 (void)_DtTermPrimBufferGetEnhancement(tb, tpd->cursorRow,
1509 c, &evalues, &cnt, countAll);
1512 if (evalues[(int)enhField] == FIELD_UNPROTECT) {
1513 (void) _DtTermPrimBufferSetEnhancement(tb, tpd->cursorRow,
1514 c, enhVideo, evalues[(int)enhVideo]);
1515 (void) _DtTermPrimBufferSetEnhancement(tb, tpd->cursorRow,
1516 c, enhFgColor, evalues[(int)enhFgColor]);
1517 (void) _DtTermPrimBufferSetEnhancement(tb, tpd->cursorRow,
1518 c, enhBgColor, evalues[(int)enhBgColor]);
1519 while ((c <= col2) && cnt--) {
1520 tpd->cursorColumn = c;
1521 (void) _DtTermPrimInsertText(w, (unsigned char *) " ", 1);
1529 /* restore the insert char mode... */
1530 tpd->insertCharMode = saveInsertCharMode;
1532 /* restore the cursor position... */
1533 tpd->cursorColumn = col;
1534 tpd->cursorRow = row;
1536 /* restore the current enhancement state... */
1537 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1538 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhVideo,
1540 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1541 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhFgColor,
1542 td->enhFgColorState);
1543 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1544 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhBgColor,
1545 td->enhBgColorState);
1549 _DtTermSelEraseInDisplay(Widget w) /* DECSED ESC?pJ */
1551 DtTermWidget vtw = (DtTermWidget) w;
1552 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1553 TermBuffer tb = tw->term.tpd->termBuffer ;
1554 ParserContext context ;
1556 int r,col1,col2,row1,row2,col,row ;
1558 Debug('P', fprintf(stderr,">>In func _DtTermSelEraseInDisplay\n")) ;
1560 context = GetParserContext(w) ;
1561 STORELASTARG(context) ;
1562 col1 = FIRSTCOLUMN(vtw) ;
1563 row1 = TOPROW(vtw) ;
1564 col2 = LASTCOLUMN(vtw) ;
1565 row2 = BOTTOMROW(vtw) ;
1566 switch ( context->parms[1] ) {
1567 case 0: col1= vtw->term.tpd->cursorColumn;
1568 row1 = vtw->term.tpd->cursorRow;
1570 case 1: col2 = vtw->term.tpd->cursorColumn;
1571 row2 = vtw->term.tpd->cursorRow;
1576 col = vtw->term.tpd->cursorColumn;
1577 row = vtw->term.tpd->cursorRow;
1578 vtw->term.tpd->cursorColumn = col1 ;
1579 vtw->term.tpd->cursorRow = row1;
1580 context->workingNum = 0 ; /* erase to the end of line */
1581 _DtTermSelEraseInLine(w) ;
1582 context->workingNum = 2 ; /* erase the whole row */
1583 for ( r=row1+1; r<row2; r++) {
1584 vtw->term.tpd->cursorRow = r;
1585 _DtTermSelEraseInLine(w) ;
1587 vtw->term.tpd->cursorColumn = col2 ;
1588 vtw->term.tpd->cursorRow = row2;
1589 context->workingNum = 2 ; /* erase the beginning of the line */
1590 _DtTermSelEraseInLine(w) ;
1591 vtw->term.tpd->cursorColumn = col ;
1592 vtw->term.tpd->cursorRow = row;
1597 _DtTermSingleShiftG2(Widget w) /* SS2 ESCN */
1599 DtTermWidget vtw = (DtTermWidget) w;
1600 DtTermData vtd = vtw->vt.td;
1602 Debug('P', fprintf(stderr,">>In func _DtTermSingleShiftG2\n")) ;
1603 vtd->singleShiftPending = True;
1604 vtd->singleShiftFont = vtd->G2;
1608 _DtTermSingleShiftG3(Widget w) /* SS3 ESCO */
1610 DtTermWidget vtw = (DtTermWidget) w;
1611 DtTermData vtd = vtw->vt.td;
1613 Debug('P', fprintf(stderr,">>In func _DtTermSingleShiftG3\n")) ;
1614 vtd->singleShiftPending = True;
1615 vtd->singleShiftFont = vtd->G3;
1619 _DtTermLoadCharSet(Widget w) /* vt220 DCS - download char set ESCPpST */
1621 /* we're not implementing this */
1624 /*********************************************************************
1625 * The next 3 functions handle the user key string loading
1626 * DCS Pc;Pl | Ky1/st1;ky2/st2;...kyn/stn ST
1629 _DtTermParseUserKeyClear(Widget w) /* vt220 DECUDK clear function keys*/
1631 DtTermWidget vtw = (DtTermWidget) w;
1632 DtTermData vtd = vtw->vt.td;
1633 ParserContext context ;
1634 Debug('P', fprintf(stderr,">>In func _DtTermLoadSoftKey\n")) ;
1635 context = GetParserContext(w) ;
1636 STORELASTARG(context) ;
1637 if ( !vtd->userKeysLocked )
1639 vtd->needToLockUserKeys = False ;
1640 if (context->parms[1] == 0)
1641 _DtTermFunctionKeyClear(w) ;
1642 if (context->parms[0] == 2 && context->parms[2] == 0)
1643 vtd->needToLockUserKeys = True ;
1645 _DtTermClearParam(w) ;
1648 _DtTermParseUserKeyLoad(Widget w) /* vt220 DECUDK load function string */
1650 DtTermWidget vtw = (DtTermWidget) w;
1651 DtTermData vtd = vtw->vt.td;
1652 ParserContext context ;
1653 Debug('P', fprintf(stderr,">>In func _DtTermLoadSoftKey\n")) ;
1654 context = GetParserContext(w) ;
1655 STORELASTARG(context) ;
1656 if ( !vtd->userKeysLocked)
1658 context->stringParms[0].str[context->stringParms[0].length/2] =
1659 (unsigned char)0 ; /* Null terminate */
1660 _DtTermFunctionKeyStringStore(w,context->parms[1],
1661 (char *)context->stringParms[0].str);
1663 _DtTermClearParam(w) ;
1667 _DtTermParseUserKeyLoadLast(Widget w) /* vt220 DECUDK load function string */
1669 DtTermWidget vtw = (DtTermWidget) w;
1670 DtTermData vtd = vtw->vt.td;
1671 _DtTermParseUserKeyLoad(w);
1672 if (vtd->needToLockUserKeys) vtd->userKeysLocked = True ;
1673 vtd->needToLockUserKeys = False ;
1677 _DtTermParseHexDigit(Widget w) /* vt220 DECUDK store hex digit*/
1679 ParserContext context ;
1680 int ci, left_byte, i;
1682 Debug('P', fprintf(stderr,">>In func _DtTermLoadSoftKey\n")) ;
1683 context = GetParserContext(w) ;
1684 if ( (int)context->stringParms[0].length < 2*STR_SIZE-1 ) {
1685 /* fold the hex digits into characters */
1686 i = context->stringParms[0].length ;
1687 cbuf[0] = *context->inputChar ;
1689 sscanf(cbuf,"%x",&ci) ;
1691 left_byte = (i+1)%2 ;
1694 context->stringParms[0].str[i] = c<<4 ;
1696 context->stringParms[0].str[i] |= c & 0x0F ;
1697 context->stringParms[0].length++ ;
1702 _DtTermReset(Widget w) /* RIS ESCc */
1704 ParserContext context ;
1706 Debug('P', fprintf(stderr,">>In func _DtTermReset\n")) ;
1707 context = GetParserContext(w) ;
1708 _DtTermFuncHardReset(w,0 ,fromParser) ;
1712 _DtTermSelectG2(Widget w) /* LS2 ESCn */
1714 DtTermWidget vtw = (DtTermWidget)w ;
1715 DtTermData vtd = vtw->vt.td;
1716 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1717 DtTermPrimData tpd = tw->term.tpd;
1719 Debug('P', fprintf(stderr,">>In func _DtTermSelectG2\n")) ;
1722 vtd->enhFontState = *vtd->GL;
1723 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1724 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1725 enhFont, vtd->enhFontState);
1729 _DtTermSelectG3(Widget w) /* LS3 ESCo */
1731 DtTermWidget vtw = (DtTermWidget)w ;
1732 DtTermData vtd = vtw->vt.td;
1733 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1734 DtTermPrimData tpd = tw->term.tpd;
1736 Debug('P', fprintf(stderr,">>In func _DtTermSelectG3\n")) ;
1738 vtd->enhFontState = *vtd->GL;
1739 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1740 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1741 enhFont, vtd->enhFontState);
1745 _DtTermParseStatus(Widget w) /* DECID (same as DA) ESCZ */
1747 _DtTermDeviceAttributes(w) ;
1751 _DtTermSetCharEraseMode(Widget w) /* DECSCA ESCp"q */
1753 DtTermWidget vtw = (DtTermWidget) w;
1754 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1755 DtTermPrimData tpd = tw->term.tpd;
1756 ParserContext context ;
1757 Debug('P', fprintf(stderr,">>In func _DtTermSetCharEraseMode\n")) ;
1758 context = GetParserContext(w) ;
1759 STORELASTARG(context) ;
1760 switch ( context->parms[1] ) {
1761 case 0: /* set back to default which is unprotect */
1764 vtw->vt.td->enhFieldState = FIELD_UNPROTECT;
1765 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1766 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1767 enhField, vtw->vt.td->enhFieldState);
1770 vtw->vt.td->enhFieldState = FIELD_PROTECT;
1771 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1772 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1773 enhField, vtw->vt.td->enhFieldState);
1779 _DtTermSingleWide(Widget w) /* DECSWL ESC#5 */
1781 ParserContext context ;
1783 Debug('P', fprintf(stderr,">>In func _DtTermSingleWide\n")) ;
1784 context = GetParserContext(w) ;
1788 _DtTermDoubleWide(Widget w) /* DECDWL ESC#6 */
1790 ParserContext context ;
1792 Debug('P', fprintf(stderr,">>In func _DtTermDoubleWide\n")) ;
1793 context = GetParserContext(w) ;
1797 _DtTermDoubleHigh(Widget w) /* DECWHL ESC#4 */
1799 ParserContext context ;
1801 Debug('P', fprintf(stderr,">>In func _DtTermDoubleHigh\n")) ;
1802 context = GetParserContext(w) ;
1806 _DtTermParseFontG0(Widget w)
1808 DtTermWidget vtw = (DtTermWidget)w ;
1809 DtTermData vtd = vtw->vt.td;
1810 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1811 DtTermPrimData tpd = tw->term.tpd;
1812 ParserContext context ;
1813 context = GetParserContext(w) ;
1815 Debug('P', fprintf(stderr,">>In func _DtTermParseFontG0\n")) ;
1816 switch (*context->inputChar) {
1818 vtd->G0 = FONT_NORMAL;
1822 vtd->G0 = FONT_LINEDRAW;
1826 vtd->enhFontState = *vtd->GL;
1827 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1828 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1829 enhFont, vtd->enhFontState);
1833 _DtTermParseFontG1(Widget w)
1835 DtTermWidget vtw = (DtTermWidget)w ;
1836 DtTermData vtd = vtw->vt.td;
1837 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1838 DtTermPrimData tpd = tw->term.tpd;
1839 ParserContext context ;
1840 context = GetParserContext(w) ;
1842 Debug('P', fprintf(stderr,">>In func _DtTermParseFontG1\n")) ;
1843 switch (*context->inputChar) {
1845 vtd->G1 = FONT_NORMAL;
1849 vtd->G1 = FONT_LINEDRAW;
1853 vtd->enhFontState = *vtd->GL;
1854 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1855 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1856 enhFont, vtd->enhFontState);
1860 _DtTermParseFontG2(Widget w)
1862 DtTermWidget vtw = (DtTermWidget)w ;
1863 DtTermData vtd = vtw->vt.td;
1864 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1865 DtTermPrimData tpd = tw->term.tpd;
1866 ParserContext context ;
1867 context = GetParserContext(w) ;
1869 Debug('P', fprintf(stderr,">>In func _DtTermParseFontG1\n")) ;
1870 switch (*context->inputChar) {
1872 vtd->G2 = FONT_NORMAL;
1876 vtd->G2 = FONT_LINEDRAW;
1880 vtd->enhFontState = *vtd->GL;
1881 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1882 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1883 enhFont, vtd->enhFontState);
1887 _DtTermParseFontG3(Widget w)
1889 DtTermWidget vtw = (DtTermWidget)w ;
1890 DtTermData vtd = vtw->vt.td;
1891 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1892 DtTermPrimData tpd = tw->term.tpd;
1893 ParserContext context ;
1894 context = GetParserContext(w) ;
1896 Debug('P', fprintf(stderr,">>In func _DtTermParseFontG1\n")) ;
1897 switch (*context->inputChar) {
1899 vtd->G3 = FONT_NORMAL;
1903 vtd->G3 = FONT_LINEDRAW;
1907 vtd->enhFontState = *vtd->GL;
1908 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1909 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1910 enhFont, vtd->enhFontState);
1914 _DtTermParseFontShift(Widget w) /* Ctrl-E Ctrl-F */
1916 DtTermWidget vtw = (DtTermWidget)w ;
1917 DtTermData vtd = vtw->vt.td;
1918 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1919 DtTermPrimData tpd = tw->term.tpd;
1920 ParserContext context ;
1921 context = GetParserContext(w) ;
1923 Debug('P', fprintf(stderr,">>In func _DtTermParseFontShift\n")) ;
1924 switch (*context->inputChar) {
1936 vtd->enhFontState = *vtd->GL;
1937 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1938 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1939 enhFont, vtd->enhFontState);
1943 _DtTermParseTab(Widget w) /* Crtl-I */
1945 DtTermWidget vtw = (DtTermWidget)w ;
1946 Debug('P', fprintf(stderr,">>In func _DtTermParseTab\n")) ;
1947 if (vtw->term.tpd->cursorColumn > LASTCOLUMN(vtw)) {
1948 if (vtw->vt.td->fixCursesMode) {
1949 (void) _DtTermNextLine(w);
1950 (void) _DtTermFuncTab(w, 1, fromParser);
1952 /* we already tabbed to the end of the line, so do nothing... */
1955 (void) _DtTermFuncTab(w, 1, fromParser);
1961 _DtTermParseLF /* LineFeed (LF) or newline (NL) Ctrl-J,
1962 Vertical Tab Ctrl-K, Form Feed (NP) Ctrl-L */
1967 DtTermWidget vtw = (DtTermWidget)w ;
1968 Debug('P', fprintf(stderr,">>In func _vtParseLR\n")) ;
1970 if (vtw->term.tpd->cursorRow == BOTTOMMARGIN(vtw))
1973 ** scroll one line...
1975 (void) _DtTermPrimScrollText(w, 1);
1976 vtw->term.tpd->cursorRow = BOTTOMMARGIN(vtw);
1979 if (!(vtw->term.tpd->cursorRow == BOTTOMROW(vtw))) {
1980 vtw->term.tpd->cursorRow++ ;
1983 (void) _DtTermPrimFillScreenGap(w);
1985 if (vtw->term.tpd->autoLineFeed )
1986 _DtTermPrimParseCR(w);
1990 _DtTermSoftReset /* DECSTR ESC!p */
1995 Debug('P', fprintf(stderr,">>In func _DtTermSoftReset\n")) ;
1996 _DtTermFuncSoftReset(w,0 ,fromParser) ;
2000 _DtTermParseBackspace /* Ctrl-H */
2005 ParserContext context ;
2006 DtTermWidget vtw = (DtTermWidget) w;
2007 int row,col,fcol,cnt ;
2008 Debug('P', fprintf(stderr,">>In func _DtTermParseBackspace\n")) ;
2009 context = GetParserContext(w) ;
2010 fcol = FIRSTCOLUMN(vtw) ;
2011 row = vtw->term.tpd->cursorRow;
2012 col = vtw->term.tpd->cursorColumn;
2015 if (vtw->vt.td->reverseWrapMode) {
2016 if ( --row < TOPROW(vtw)) row = BOTTOMROW(vtw);
2017 if (vtw->vt.td->originMode && row < TOPMARGIN(vtw))
2018 row =BOTTOMMARGIN(vtw);
2019 col = LASTCOLUMN(vtw) ;
2025 vtw->term.tpd->cursorRow = row;
2026 vtw->term.tpd->cursorColumn = col;
2040 Window parentReturn;
2041 Window *childrenReturn;
2042 unsigned int nChildrenReturn;
2048 unsigned int widthReturn;
2049 unsigned int heightReturn;
2050 unsigned int topWidthReturn;
2051 unsigned int topHeightReturn;
2052 unsigned int borderWidthReturn;
2053 unsigned int depthReturn;
2060 if (XmIsMotifWMRunning(w)) {
2061 /* get the window we want to figure the offsets for... */
2062 topWindow = XtWindow(w);
2064 /* and the display involved... */
2065 display = XtDisplay(w);
2067 (void) XQueryTree(display, topWindow, &rootWindow, &parentReturn,
2068 &childrenReturn, &nChildrenReturn);
2069 (void) XFree(childrenReturn);
2071 /* walk up the tree until the parent window is root... */
2072 while (parentReturn != rootWindow) {
2073 topWindow = parentReturn;
2074 (void) XQueryTree(display, topWindow, &rootWindow,
2075 &parentReturn, &childrenReturn, &nChildrenReturn);
2076 (void) XFree(childrenReturn);
2079 /* we now know what our top window is. translate our upper
2080 * left corner relative to its upper left corner...
2082 (void) XTranslateCoordinates(display, XtWindow(w), topWindow,
2083 0, 0, &destXReturn, &destYReturn, &childReturn);
2084 *xOffset = destXReturn;
2085 *yOffset = destYReturn;
2087 /* now that we know the top window, we can figure out the size
2088 * difference between the two windows...
2090 (void) XGetGeometry(display, topWindow, &rootWindow,
2091 &destXReturn, &destYReturn, &topWidthReturn,
2092 &topHeightReturn, &borderWidthReturn, &depthReturn);
2094 (void) XGetGeometry(display, XtWindow(w), &rootWindow,
2095 &destXReturn, &destYReturn, &widthReturn, &heightReturn,
2096 &borderWidthReturn, &depthReturn);
2098 *widthOffset = topWidthReturn - widthReturn;
2099 *heightOffset = topHeightReturn - heightReturn;
2104 _DtTermParseSunMisc /* Misc sun esc seqs */
2109 ParserContext context ;
2110 DtTermWidget vtw = (DtTermWidget) w;
2111 Display *display = XtDisplay(w);
2112 int i, scr_num = XScreenNumberOfScreen(XtScreen(w));
2113 Window win = XtWindow(w);
2116 XWindowChanges values;
2121 Dimension height,width;
2122 char *fmt,*s,*title,*icon;
2128 context = GetParserContext(w) ;
2129 STORELASTARG(context) ;
2131 for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2132 sh_win = XtWindow(sw) ;
2133 switch (context->parms[1])
2136 XMapWindow(display,sh_win);
2139 XIconifyWindow(display,sh_win,scr_num);
2142 (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2145 (void) XMoveWindow(display, sh_win,
2146 context->parms[2] + xOffset, context->parms[3] + yOffset);
2148 (void) XtVaSetValues(sw, XmNx, context->parms[2] + xOffset,
2149 XmNy, context->parms[3] + yOffset, NULL);
2152 (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2154 (void) XtVaSetValues(sw, XmNwidth, context->parms[3] - widthOffset,
2155 XmNheight,context->parms[2] - heightOffset, NULL);
2158 XRaiseWindow(display,sh_win);
2161 XLowerWindow(display,sh_win);
2164 _DtTermPrimFuncRedrawDisplay(w, 1, fromParser);
2167 rows = context->parms[2];
2168 columns = context->parms[3];
2169 (void) XtVaSetValues(w, DtNrows, rows, DtNcolumns, columns, NULL);
2172 if (vtw->term.tpd->windowMapped)
2173 sendEscSequence(w,"\033[1t") ;
2175 sendEscSequence(w,"\033[2t") ;
2178 (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2180 (void) XtVaGetValues(sw, XtNx, &x, XtNy, &y, NULL);
2181 (void) sprintf(buf, "\033[3;%d;%dt", x - xOffset, y - yOffset);
2182 (void) sendEscSequence(w, buf);
2185 (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2187 (void) XtVaGetValues(sw, XtNheight, &height, XtNwidth, &width, NULL);
2188 (void) sprintf(buf,"\033[4;%d;%dt", height + heightOffset,
2189 width + widthOffset);
2190 (void) sendEscSequence(w, buf);
2193 (void) XtVaGetValues(w, DtNrows, &rows, DtNcolumns, &columns, NULL);
2194 (void) sprintf(buf, "\033[8;%hd;%hdt", rows, columns);
2195 (void) sendEscSequence(w, buf);
2198 XtVaGetValues(sw,XmNiconName, &icon, NULL);
2199 fmt = "\033]L%s\033\\";
2200 if (strlen(icon) + strlen(fmt) + 1 >= sizeof(buf))
2201 s = XtMalloc(strlen(icon) + strlen(fmt) + 1);
2204 sprintf(s, "%s", fmt);
2205 sendEscSequence(w,s) ;
2206 if (s != buf) XtFree(s);
2209 XtVaGetValues(sw,XmNtitle, &title, NULL);
2210 fmt = "\033]l%s\033\\";
2211 if (strlen(icon) + strlen(fmt) + 1 >= sizeof(buf))
2212 s = XtMalloc(strlen(icon) + strlen(fmt) + 1);
2215 sprintf(s, "%s", fmt);
2216 sendEscSequence(w,s) ;
2217 if (s != buf) XtFree(s);
2223 _DtTermParserSunWindowIcon( Widget w) /* sun set icon label */
2225 ParserContext context ;
2227 context = GetParserContext(w) ;
2228 for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2229 XtVaSetValues(sw, XmNiconName, context->stringParms[0].str, NULL) ;
2233 _DtTermParserSunWindowTitle /* Sun set title name */
2238 ParserContext context ;
2240 context = GetParserContext(w) ;
2241 for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2242 XtVaSetValues(sw,XmNtitle, context->stringParms[0].str, NULL) ;
2246 _DtTermParserSunIconFile(Widget w) /* Sun set icon to pixmap in file */
2249 (DtTermBuffer)((DtTermPrimitiveWidget)w)->term.tpd->termBuffer ;
2250 ParserContext context ;
2255 context = GetParserContext(w) ;
2256 for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2257 XtVaGetValues(sw, XtNforeground, &fg, XtNbackground, &bg, NULL);
2258 icon = XmGetPixmap(XtScreen(sw),(char *)context->stringParms[0].str,fg,bg);
2259 if (icon != XmUNSPECIFIED_PIXMAP)
2260 XtVaSetValues(sw, XmNiconPixmap, icon, NULL);