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 libraries 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 /*****************************************************************************/
73 #define PCOUNT(c) ((c)->parms[0])
74 #define BASE 1 /* row and column count base 0 or 1 */
76 /*********************************************************************
77 * Macros for handling cursor constraints - return values in coordinate
78 * system for Term widget (base 0) BASE which is 1 reflects the Vt base
80 * These defines need to account of for Origin mode eventually TMH */
82 #define TOPROW(w) (1-BASE)
83 #define TOPMARGIN(w) ((w)->term.tpd->scrollLockTopRow-(1-BASE))
84 #define BOTTOMMARGIN(w) ((w)->term.tpd->scrollLockBottomRow-(1-BASE))
85 #define BOTTOMROW(w) ((w)->term.rows-BASE)
86 /* FIRSTCOLUMN(w) ABS(BASE-1) */
87 #define FIRSTCOLUMN(w) 0
88 #define LASTCOLUMN(w) ((w)->term.columns-BASE)
89 #define FLOOR(w) ((w)->vt.td->originMode?(w)->term.tpd->scrollLockBottomRow:\
91 #define CEILING(w) ((w)->vt.td->originMode?(w)->term.tpd->scrollLockTopRow:\
93 #define KILLWRAP(w) if((w)->term.tpd->cursorColumn>LASTCOLUMN(w)) \
94 (w)->term.tpd->cursorColumn=LASTCOLUMN(w)
95 #define STORELASTARG(c) (c)->parms[PCOUNT(c)]=(c)->workingNum
97 /******************************************************************
98 * Upon entering a parse routine the parameter count is contained
99 * in context->parms[0].
101 * The last parmameter parsed is in context->workingNum
102 * Next to last parmameter is in {context->parms[0]==1?context->workingNum:
103 * context->parms[context->param[0]-1]}
107 * First parameter is in context->parms[1]
109 * In some of the parse routines, the default case of too many parameters
110 * needs to be handled like Vt (silently use the first n parameters)
111 * Vt has a max of 16 numeric parameters; The rest fall off the end
113 *******************************************************************/
116 _DtTermClearParam(Widget w)
118 ParserContext context ;
119 context = GetParserContext(w) ;
122 _DtTermPrimParserClearParm(w) ;
123 _DtTermPrimParserClrStrParm(w) ;
127 _DtTermEnterNum(Widget w)
129 ParserContext context ;
130 context = GetParserContext(w) ;
131 _DtTermPrimParserEnterNum(w) ;
132 if (!PCOUNT(context)) PCOUNT(context)++ ; /* increment for first number ONLY*/
136 _DtTermParsePushNum(Widget w)
138 ParserContext context ;
139 context = GetParserContext(w) ;
140 /* parmN(w,PCOUNT(c)) ; Should use this but not global */
141 if ( context->workingNumIsDefault != True) { /* did we actually parse a num*/
142 _DtTermPrimParserNumParmPush(w,PCOUNT(context)) ;
145 if (!PCOUNT(context)) PCOUNT(context)++ ;/* increment for first number ONLY*/
148 if ( ++PCOUNT(context)>NPARAM ) {
149 Debug('P',fprintf(stderr,">>Too many parameters\n")) ;
155 _DtTermSaveChar(Widget w)
157 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
158 ParserContext context ;
160 context = GetParserContext(w) ;
162 mbtowc(&c,(char *)context->inputChar,MB_CUR_MAX);
163 if ( context->stringParms[0].length < STR_SIZE && iswprint(c) ) {
165 (char *)&context->stringParms[0].str[context->stringParms[0].length]),
166 (char *)context->inputChar, context->inputCharLen) ;
167 context->stringParms[0].length += context->inputCharLen ;
172 _DtTermPrintState(Widget w)
174 ParserContext context ;
175 context = GetParserContext(w) ;
176 /* fprintf(stderr,"Warning: Not a valid escape sequence\n") ;*/
177 context->stateTable = _DtTermStateStart ;
178 _DtTermClearParam(w) ;
181 /* a utility for checking for S8C1TMode */
183 sendEscSequence(Widget w, char *transmitString)
185 DtTermWidget tw = (DtTermWidget)w;
186 DtTermData td = tw->vt.td;
188 if ( td->S8C1TMode ) {
189 char *cbuf =malloc(strlen(transmitString)+1);
190 strcpy(cbuf,transmitString) ;
192 (void) _DtTermPrimSendInput(w, (unsigned char *) (cbuf+1),
197 (void) _DtTermPrimSendInput(w, (unsigned char *) transmitString,
198 strlen(transmitString));
203 _DtTermDeviceStatus(Widget w) /* DSR CSI?pn */
205 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
206 DtTermData vtd = ((DtTermWidget)w)->vt.td;
207 ParserContext context ;
210 Debug('P', fprintf(stderr,">>In func _DtTermDeviceStatus\n")) ;
211 context = GetParserContext(w) ;
212 STORELASTARG(context) ;
213 switch ( context->parms[1] ) {
214 case 15: /* printer status - we don't have one */
215 sendEscSequence(w,"\033[?13n") ;
217 case 25: /* User defined keys locked? */
218 if ( vtd->userKeysLocked )
219 sendEscSequence(w,"\033[?21n") ;
221 sendEscSequence(w,"\033[?20n") ;
223 case 26: /* keyboard status - always send North American */
224 sendEscSequence(w,"\033[?27;1n") ;
230 _DtTermDeviceStatusAnsi(Widget w) /* DSR CSIpn */
232 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
233 DtTermData vtd = ((DtTermWidget)w)->vt.td;
234 ParserContext context ;
237 Debug('P', fprintf(stderr,">>In func _DtTermDeviceStatus\n")) ;
238 context = GetParserContext(w) ;
239 STORELASTARG(context) ;
240 switch ( context->parms[1] ) {
241 case 5: /* as far as I know, all's well... So send OK */
242 sendEscSequence(w,"\033[0n") ;
245 /* cursor could be past last row (for autowrap) */
246 if ((col=tw->term.tpd->cursorColumn)>LASTCOLUMN(tw))
248 row = tw->term.tpd->cursorRow+BASE ;
249 if (vtd->originMode==True) row -= TOPMARGIN(tw) ;
250 sprintf(buf,"\033[%d;%dR",row , col+BASE) ;
251 sendEscSequence(w,buf) ;
257 _DtTermPModeSet(Widget w) /* DECSET CSI?ph */
259 ParserContext context ;
260 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
261 DtTermWidget vtw = (DtTermWidget)w;
263 Debug('P', fprintf(stderr,">>In func _DtTermPModeSet\n")) ;
264 context = GetParserContext(w) ;
265 STORELASTARG(context) ;
266 cnt = PCOUNT(context) ;
267 for (i=1;i<=cnt;i++) {
268 switch ( context->parms[i]) {
270 case 1: /* Cursor key (Application) */
271 vtw->vt.td->applicationMode=True;
273 /* case 2: can't return from vt52 mode */
274 case 3: /* Column (132) */
275 if ( vtw->vt.c132 ) { /* xterm allow 132 mode */
276 (void) _DtTermFuncClearBuffer(w, 0, fromParser);
277 vtw->term.tpd->cursorRow = TOPROW(vtw) ;
278 vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
279 vtw->term.tpd->scrollLockTopRow = TOPROW(vtw);
280 vtw->term.tpd->scrollLockBottomRow = BOTTOMROW(vtw) ;
281 XtVaSetValues(w, DtNcolumns, 132, NULL) ;
282 vtw->vt.td->col132Mode = True ;
285 case 4: /* Scroll (smooth) */
286 _DtTermPrimScrollComplete(w, True) ;
287 vtw->term.jumpScroll = False ;
289 case 5: /* Screen (Reverse) */
290 /*DKS: this is just to test out the functionality... */
291 vtw->term.reverseVideo = True;
292 /* clear the window to force refresh... */
293 (void) XClearArea(XtDisplay(w), XtWindow(w),
296 case 6: /* Origin mode (On) */
297 vtw->vt.td->originMode=True;
298 _DtTermPrimCursorMove(w, TOPMARGIN(vtw), 0);
300 case 7: /* Auto wrap (On) */
301 vtw->term.tpd->autoWrapRight=True ;
303 /* case 8: ** Auto repeat (On)
304 * ** This is handled by the X server
307 * case 18: ** Print form feed (On)
309 * case 19: ** Print extent (full screen)
312 case 25: /* Text cursor enable (On) */
313 (void) _DtTermPrimSetCursorVisible(w, True);
316 case 40: /* 80/132 mode (allow) */
317 vtw->vt.c132 = True ;
319 case 41: /* curses fix */
320 vtw->vt.td->fixCursesMode = True ;
322 case 44: /* margin bell (on) */
323 vtw->term.marginBell = True ;
325 case 45: /* Reverse-wraparound mode */
326 vtw->vt.td->reverseWrapMode=True;
328 case 46: /* logging (start) */
329 vtw->term.logging = True ;
330 _DtTermPrimStartLog(w);
332 /* case 47: ** screen buffer (alternate)
334 * case 1000: ** Send mouse x and y
336 * case 1001: ** Use hilite mouse tracking
345 _DtTermPModeReset(Widget w) /* DECRST CSI?pl */
347 ParserContext context ;
348 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
349 DtTermWidget vtw = (DtTermWidget)w;
351 Debug ('P', fprintf(stderr,">>In func _DtTermPModeReset\n")) ;
352 context = GetParserContext(w) ;
353 STORELASTARG(context) ;
354 cnt = PCOUNT(context) ;
355 for (i=1;i<=cnt;i++) {
356 switch ( context->parms[i]) {
358 case 1: /* Cursor key (Normal) */
359 vtw->vt.td->applicationMode=False;
361 /* case 2: ** set vt52 mode */
362 case 3: /* Column (80) */
363 if (vtw->vt.c132) { /* allow 132 mode */
364 (void) _DtTermFuncClearBuffer(w, 0, fromParser);
365 vtw->term.tpd->cursorRow = TOPROW(vtw) ;
366 vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
367 vtw->term.tpd->scrollLockTopRow = TOPROW(vtw);
368 vtw->term.tpd->scrollLockBottomRow = BOTTOMROW(vtw) ;
369 XtVaSetValues(w, DtNcolumns, 80, NULL) ;
370 vtw->vt.td->col132Mode = False ;
373 case 4: /* Scroll (jump) */
374 _DtTermPrimScrollComplete(w, True) ;
375 vtw->term.jumpScroll = True ;
377 case 5: /* Screen (normal ) */
378 /*DKS: this is just to test out the functionality... */
379 vtw->term.reverseVideo = False;
380 /* clear the window to force refresh... */
381 (void) XClearArea(XtDisplay(w), XtWindow(w),
384 case 6: /* Normal cursor (not Origin mode) */
385 vtw->vt.td->originMode=False;
386 _DtTermPrimCursorMove(w, 0, 0);
388 case 7: /* Auto wrap (Off) */
389 vtw->term.tpd->autoWrapRight=False;
391 /* case 8: ** Auto repeat (Off)
392 * ** implemented in the server
394 * case 18: ** Print form feed (Off)
396 * case 19: ** Print extent (scrolling region)
399 case 25: /* Text cursor enable (Off) */
400 (void) _DtTermPrimSetCursorVisible(w, False);
403 case 40: /* 80/132 mode (disallow) */
404 vtw->vt.c132 = False;
406 case 41: /* curses fix */
407 vtw->vt.td->fixCursesMode = False;
409 case 44: /* margin bell (off) */
410 vtw->term.marginBell = False ;
412 case 45: /* Reverse-wraparound mode */
413 vtw->vt.td->reverseWrapMode=False;
415 case 46: /* logging (stop ) */
416 vtw->term.logging = False ;
417 _DtTermPrimCloseLog(w) ;
419 /* case 47: ** screen buffer (normal)
421 * case 1000: ** don't send mouse x and y
423 * case 1001: ** don't use hilite mouse tracking
431 _DtTermSetMode(Widget w) /* SM CSIph */
433 ParserContext context ;
434 DtTermWidget vtw = (DtTermWidget)w ;
436 Debug('P', fprintf(stderr,">>In func _DtTermSetMode\n")) ;
437 context = GetParserContext(w) ;
438 STORELASTARG(context) ;
439 cnt = PCOUNT(context) ;
440 for (i=1;i<=cnt;i++) {
441 switch ( context->parms[i]) {
442 case 2: /* KAM Keyboard Action (locked) */
443 vtw->term.tpd->keyboardLocked.escape=True ;
444 (void) _DtTermPrimInvokeStatusChangeCallback(w);
446 case 4: /* Insert mode */
447 _DtTermPrimInsertCharUpdate(w, DtTERM_INSERT_CHAR_ON) ;
449 case 12: /* SRM Send/Receive (Off) */
450 vtw->term.tpd->halfDuplex = False;
452 case 20: /* Line feed/newline (new line) */
453 vtw->term.tpd->autoLineFeed=True ;
460 _DtTermResetMode(Widget w) /* RM CSIpl */
462 ParserContext context ;
463 DtTermWidget vtw = (DtTermWidget)w ;
465 Debug('P', fprintf(stderr,">>In func _DtTermResetMode\n")) ;
466 context = GetParserContext(w) ;
467 STORELASTARG(context) ;
468 cnt = PCOUNT(context) ;
469 for (i=1;i<=cnt;i++) {
470 switch ( context->parms[i]) {
471 case 2: /* KAM Keyboard Action (unlocked) */
472 vtw->term.tpd->keyboardLocked.escape=False;
473 (void) _DtTermPrimInvokeStatusChangeCallback(w);
475 case 4: /* Replace mode */
476 _DtTermPrimInsertCharUpdate(w, DtTERM_INSERT_CHAR_OFF) ;
478 case 12: /* SRM Send/Receive (On) */
479 vtw->term.tpd->halfDuplex = True;
481 case 20: /* Line feed/newline (line feed) */
482 vtw->term.tpd->autoLineFeed=False ;
489 _DtTermCursorPos(Widget w) /* CUP CSIp;pH */
491 ParserContext context ;
492 DtTermWidget vtw = (DtTermWidget) w;
494 Debug( 'P', fprintf(stderr,">>In func _DtTermCursorPos\n")) ;
495 context = GetParserContext(w) ;
496 STORELASTARG(context) ;
497 row = context->parms[1] ;
498 col = context->parms[2] ;
501 if (vtw->vt.td->originMode) row += vtw->term.tpd->scrollLockTopRow ;
502 if (row > FLOOR(vtw)) row = FLOOR(vtw) ;
503 if (col > LASTCOLUMN(vtw)) col = LASTCOLUMN(vtw) ;
504 vtw->term.tpd->cursorRow = row ;
505 vtw->term.tpd->cursorColumn = col ;
509 _DtTermEraseDisplay(Widget w) /* ED CSIpJ */
512 DtTermWidget vtw = (DtTermWidget) w;
513 ParserContext context ;
514 DtEraseMode eraseMode;
517 Debug('P', fprintf(stderr,">>In func _DtTermEraseDisplay\n")) ;
518 context = GetParserContext(w) ;
520 STORELASTARG(context) ;
521 row = vtw->term.tpd->cursorRow;
522 col = vtw->term.tpd->cursorColumn ;
525 ** pick the correct erase mode...
527 switch (context->parms[1])
530 eraseMode = eraseToEOB;
533 eraseMode = eraseFromRow0Col0;
536 eraseMode = eraseBuffer;
539 _DtTermFuncEraseInDisplay(w, (int)eraseMode, fromParser);
540 vtw->term.tpd->cursorRow = row;
541 vtw->term.tpd->cursorColumn = col;
545 _DtTermEraseChars(Widget w) /* ECH CSIpX */
547 ParserContext context ;
548 DtTermWidget vtw = (DtTermWidget) w;
550 Debug('P', fprintf(stderr,">>In func _DtTermEraseChars\n")) ;
552 context = GetParserContext(w) ;
553 row = vtw->term.tpd->cursorRow ;
554 col = vtw->term.tpd->cursorColumn ;
555 STORELASTARG(context) ;
556 cnt = context->parms[1] ;
559 if ( cnt > LASTCOLUMN(vtw)-col+1 ) cnt = LASTCOLUMN(vtw)-col+1 ;
561 _DtTermFuncEraseCharacter(w, cnt, fromParser);
565 _DtTermInsertChars(Widget w) /* ICH CSIp@ */
567 DtTermWidget vtw = (DtTermWidget) w;
568 ParserContext context ;
570 DtTermInsertCharMode saveInsertCharMode;
572 Debug('P', fprintf(stderr,">>In func _DtTermInsertChars\n")) ;
574 context = GetParserContext(w) ;
575 vtw->term.tpd->parserNotInStartState = False ;
576 row = vtw->term.tpd->cursorRow ;
577 col = vtw->term.tpd->cursorColumn ;
578 STORELASTARG(context) ;
579 cnt = context->parms[1] ;
583 if (cnt > LASTCOLUMN(vtw) - col + 1)
584 cnt = LASTCOLUMN(vtw) - col + 1;
586 /* save away the insert char mode... */
587 saveInsertCharMode = vtw->term.tpd->insertCharMode;
589 /* turn on insert char mode. We don't want to invoke any status
590 * change callbacks, so we will justs set it directly...
592 vtw->term.tpd->insertCharMode = DtTERM_INSERT_CHAR_ON;
594 /* insert blanks... */
596 (void) _DtTermPrimInsertText(w,(unsigned char *) " ", 1) ;
598 /* restore the insert char mode... */
599 vtw->term.tpd->insertCharMode = saveInsertCharMode;
601 _DtTermPrimCursorMove(w,row,col) ;
605 _DtTermCursorUp(Widget w) /* CUU CISpA */
607 ParserContext context ;
608 DtTermWidget vtw = (DtTermWidget) w;
609 int trow, row, tmargin, cnt;
610 Debug('P', fprintf(stderr,">>In func _DtTermCursorUp\n")) ;
611 context = GetParserContext(w) ;
613 tmargin = TOPMARGIN(vtw) ;
615 STORELASTARG(context) ;
616 cnt = context->parms[1] ;
618 else if (cnt>MAXSHORT) cnt=MAXSHORT-100;
619 row = vtw->term.tpd->cursorRow-cnt;
620 /* are we about the top margin and did we actually cross it? */
621 /* This handles the case top margin == top row */
622 if (row < tmargin && row+cnt >= tmargin) row = tmargin;
623 _DtTermPrimCursorMove(w, row, vtw->term.tpd->cursorColumn) ;
627 _DtTermCursorDown(Widget w) /* CUD CISpB */
629 ParserContext context ;
630 DtTermWidget vtw = (DtTermWidget) w;
631 int bmargin, row, cnt, brow ;
632 Debug('P', fprintf(stderr,">>In func _DtTermCursorDown\n")) ;
633 context = GetParserContext(w) ;
635 bmargin = BOTTOMMARGIN(vtw) ;
636 brow = BOTTOMROW(vtw) ;
637 STORELASTARG(context) ;
638 cnt = context->parms[1] ;
640 row = vtw->term.tpd->cursorRow+cnt;
641 /* are we below bottom margin and did we actually cross it? */
642 /* NOTE that this also handles the case when bmargin == brow */
643 if (row > bmargin && row-cnt <= bmargin) row = bmargin;
644 /* did we start below bottom margin and cross bottom row? */
645 if (row > brow && bmargin < brow ) row = brow;
646 _DtTermPrimCursorMove(w, row, vtw->term.tpd->cursorColumn) ;
650 _DtTermCursorForward(Widget w) /* CUF CISpC */
652 ParserContext context ;
653 DtTermWidget vtw = (DtTermWidget) w;
655 Debug('P', fprintf(stderr,">>In func _DtTermCursorForward\n")) ;
656 context = GetParserContext(w) ;
658 lcol = LASTCOLUMN(vtw) ;
659 STORELASTARG(context) ;
660 cnt = context->parms[1] ;
662 col = vtw->term.tpd->cursorColumn+cnt;
663 if (col>lcol) col=lcol;
664 _DtTermPrimCursorMove(w,vtw->term.tpd->cursorRow,col);
668 _DtTermCursorBack(Widget w) /* CUB CISpD */
670 ParserContext context ;
671 DtTermWidget vtw = (DtTermWidget) w;
672 int i,k,j,row,col,fcol,cnt ;
673 Debug('P', fprintf(stderr,">>In func _DtTermCursorBack\n")) ;
675 context = GetParserContext(w) ;
676 STORELASTARG(context) ;
677 cnt = context->parms[1] ;
678 fcol = FIRSTCOLUMN(vtw) ;
679 row = vtw->term.tpd->cursorRow;
680 col = vtw->term.tpd->cursorColumn;
682 if ((col -= cnt) < 0) {
683 if(vtw->vt.td->reverseWrapMode && vtw->term.tpd->autoWrapRight) {
684 int lastrow = BOTTOMROW(vtw);
685 if (vtw->vt.td->originMode) {
686 row-=TOPMARGIN(vtw) ;
687 lastrow = BOTTOMMARGIN(vtw)-TOPMARGIN(vtw);
689 if((i = (j = LASTCOLUMN(vtw) + 1) * row + col) < 0) {
690 k = j * (lastrow + 1);
691 i += ((-i) / k + 1) * k;
694 if (vtw->vt.td->originMode) row+=TOPMARGIN(vtw);
699 _DtTermPrimCursorMove(w,row,col);
703 _DtTermCursorToLineUp(Widget w) /* CPL CSIpF */
705 DtTermWidget vtw = (DtTermWidget) w;
706 ParserContext context ;
707 Debug('P', fprintf(stderr,">>In func _DtTermCursorToLineUp\n")) ;
709 context = GetParserContext(w) ;
710 vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
715 _DtTermCursorToCol(Widget w) /* CHA CSIpG */
717 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
718 ParserContext context ;
719 context = GetParserContext(w) ;
720 STORELASTARG(context) ;
721 if (!context->parms[1] ) context->parms[1]=1;
722 if (context->parms[1]>tw->term.columns) context->parms[1]=tw->term.columns;
723 tw->term.tpd->cursorColumn = context->parms[1] - BASE ;
727 _DtTermEraseInLine(Widget w) /* EL ESC[pK */
729 DtTermWidget vtw = (DtTermWidget) w;
730 ParserContext context ;
731 DtEraseMode eraseMode;
734 Debug('P', fprintf(stderr,">>In func _DtTermEraseInLine\n")) ;
736 context = GetParserContext(w) ;
737 STORELASTARG(context) ;
739 ** pick the correct erase mode...
741 switch ( context->parms[1] )
744 eraseMode = eraseToEOL;
748 eraseMode = eraseFromCol0;
752 eraseMode = eraseLine;
756 _DtTermFuncEraseInLine(w, (int)eraseMode, fromParser);
760 _DtTermInsertLines(Widget w) /* IL CSIpL */
762 DtTermWidget vtw = (DtTermWidget) w;
763 ParserContext context ;
765 Debug('P', fprintf(stderr,">>In func _DtTermInsertLines\n")) ;
766 if ( vtw->term.tpd->cursorRow < TOPMARGIN(vtw) ||
767 vtw->term.tpd->cursorRow > BOTTOMMARGIN(vtw) )/*outside scrolling region*/
769 context = GetParserContext(w) ;
770 KILLWRAP((DtTermWidget)w) ;
771 STORELASTARG(context) ;
772 cnt=context->parms[1];
774 lines = BOTTOMMARGIN(vtw) - vtw->term.tpd->cursorRow + 1;
775 if (cnt > lines) cnt=lines ;
776 _DtTermFuncInsertLine(w,cnt,fromParser) ;
780 _DtTermDeleteLines(Widget w) /* DL CSIpM */
782 DtTermWidget vtw = (DtTermWidget) w;
783 ParserContext context ;
785 Debug('P', fprintf(stderr,">>In func _DtTermDeleteLines\n")) ;
787 if ( vtw->term.tpd->cursorRow < TOPMARGIN(vtw) ||
788 vtw->term.tpd->cursorRow > BOTTOMMARGIN(vtw) ) /* outside scrolling region*/
790 KILLWRAP((DtTermWidget)w) ;
791 context = GetParserContext(w) ;
792 STORELASTARG(context) ;
793 cnt = context->parms[1];
795 _DtTermFuncDeleteLine(w,cnt,fromParser) ;
799 _DtTermDeleteChars(Widget w) /* DCH CSIpP */
801 ParserContext context ;
802 DtTermWidget vtw = (DtTermWidget) w;
804 Debug('P', fprintf(stderr,">>In func _DtTermDeleteChars\n")) ;
806 context = GetParserContext(w) ;
807 STORELASTARG(context) ;
808 cnt= context->parms[1];
810 else if (cnt>MAXSHORT) cnt=MAXSHORT-100;
811 _DtTermFuncDeleteChar(w,cnt,fromParser) ;
815 _DtTermNextLine(Widget w) /* NEL ESCE */
817 DtTermWidget vtw = (DtTermWidget) w;
819 Debug('P', fprintf(stderr,">>In func _DtTermNextLine\n")) ;
820 vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
821 _DtTermIndex(w) ; /* use IND */
825 _DtTermReverseIndex(Widget w) /* RI ESCM */
827 DtTermWidget vtw = (DtTermWidget) w;
828 int tmargin, trow, col;
829 Debug('P', fprintf(stderr,">>In func _DtTermReverseIndex\n")) ;
832 tmargin = TOPMARGIN(vtw) ;
833 col = vtw->term.tpd->cursorColumn ;
834 if ( vtw->term.tpd->cursorRow == tmargin) {
835 _DtTermFuncInsertLine(w,1,fromParser) ;
836 /* _DtTermFuncInsertLine sets column to first column */
837 vtw->term.tpd->cursorColumn = col ;
839 else if (vtw->term.tpd->cursorRow > trow){
840 vtw->term.tpd->cursorRow-- ;
845 _DtTermIndex(Widget w) /* IND ESCD */
847 DtTermWidget vtw = (DtTermWidget) w;
849 Debug('P', fprintf(stderr,">>In func _DtTermIndex\n")) ;
851 brow = BOTTOMROW(vtw) ;
852 bmargin = BOTTOMMARGIN(vtw) ;
853 if ( vtw->term.tpd->cursorRow == bmargin) {
854 (void) _DtTermPrimScrollText(w, 1);
856 else if (vtw->term.tpd->cursorRow < brow){
857 vtw->term.tpd->cursorRow++ ;
859 (void) _DtTermPrimFillScreenGap(w);
863 _DtTermScrollingRegion(Widget w) /* DECSTBM CSIp;pr */
865 DtTermWidget vtw = (DtTermWidget)w ;
866 ParserContext context ;
868 Debug('P', fprintf(stderr,">>In func _DtTermScrollingRegion\n")) ;
869 context = GetParserContext(w) ;
870 STORELASTARG(context) ;
871 row1 = context->parms[1] ;
872 row2 = context->parms[2] ;
873 if (!row1) row1 = 1 ;
874 if (!row2 || row2>vtw->term.rows) row2 = vtw->term.rows ;
878 if ( row1 == TOPROW(vtw) && row2 == BOTTOMROW(vtw))
879 vtw->term.tpd->memoryLockMode=SCROLL_LOCKoff ;
881 vtw->term.tpd->memoryLockMode=SCROLL_LOCKon ;
882 vtw->term.tpd->scrollLockTopRow = row1 ;
883 vtw->term.tpd->scrollLockBottomRow = row2 ;
884 if (vtw->vt.td->originMode) _DtTermPrimCursorMove(w,row1,0) ;
885 else _DtTermPrimCursorMove(w,0,0) ;
890 _DtTermCharAttributes(Widget w) /* SGR CSIpm */
892 ParserContext context ;
894 Debug('P', fprintf(stderr,">>In func _DtTermCharAttributes\n")) ;
895 context = GetParserContext(w) ;
896 STORELASTARG(context) ;
897 cnt = PCOUNT(context) ;
898 if(PCOUNT(context)) {
899 for (cnt=1; cnt <= PCOUNT(context); cnt++)
900 _DtTermVideoEnhancement(w,context->parms[cnt]) ;
903 _DtTermVideoEnhancement(w,0) ;
907 _DtTermDeviceAttributes(Widget w) /* DA CSIpc */
909 DtTermWidget vtw = (DtTermWidget) w;
910 ParserContext context ;
913 Debug('P', fprintf(stderr,">>In func _DtTermDeviceAttributes\n")) ;
914 context = GetParserContext(w) ;
915 STORELASTARG(context) ;
916 switch(context->parms[1]) {
918 switch(vtw->vt.td->terminalId ) {
920 sprintf(buf,"\033[?%d;%dc",1,2) ;
923 sprintf(buf,"\033[?%d;%dc",1,0) ;
926 sprintf(buf,"\033[?%dc",6) ;
929 /* class 2 terminal (62), 132 columns (1), printer port (2),
930 * selective erase (6), DRCS (7), UDK (8),
931 * national replacement char sets
933 sprintf(buf,"\033[?%d;%d;%d;%d;%d;%d;%dc",62,1,2,6,7,8,9) ;
936 sendEscSequence(w,buf) ;
942 _DtTermChangeTextParam(Widget w) /* xterm CSIp;pcCtrl-G */
944 ParserContext context ;
945 DtTermWidget tw = (DtTermWidget) w;
946 DtTermData vtd = tw->vt.td;
950 Debug('P', fprintf(stderr,">>In func _DtTermChangeTextParam\n")) ;
951 context = GetParserContext(w) ;
953 for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
955 * context->parms[1] is inited to 0, so if no numeric param was entered,
956 * we default appropriately to case 0.
958 switch(context->parms[1]) {
959 case 0: /* change Icon name and Window title */
960 XtSetArg(arg[i], XmNtitle, context->stringParms[0].str); i++;
961 XtSetArg(arg[i], XmNiconName, context->stringParms[0].str); i++;
962 XtSetValues(sw,arg,i) ;
964 case 1: /* change Icon name */
965 XtSetArg(arg[i], XmNiconName, context->stringParms[0].str); i++;
966 XtSetValues(sw,arg,i) ;
968 case 2: /* change Window title */
969 XtSetArg(arg[i], XmNtitle, context->stringParms[0].str); i++;
970 XtSetValues(sw,arg,i) ;
972 case 3: /* change current working directory */
973 tw->term.subprocessCWD = XtRealloc(tw->term.subprocessCWD,
974 strlen((char *) context->stringParms[0].str) + 1);
975 (void) strcpy(tw->term.subprocessCWD,
976 (char *) context->stringParms[0].str);
978 /* These are handled by xterm but not by us.
979 case 46: Change log file to context->stringParms[0]
981 case 50: ** change font to context->stringParms[0]
988 _DtTermTabClear(Widget w) /* TBC CSIpg */
990 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
991 TermBuffer tb = tw->term.tpd->termBuffer ;
992 ParserContext context ;
994 Debug('P', fprintf(stderr,">>In func _DtTermTabClear\n")) ;
995 context = GetParserContext(w) ;
996 STORELASTARG(context) ;
997 type = context->parms[1] ;
999 case 0:(void)_DtTermPrimBufferClearTab(tb,tw->term.tpd->cursorColumn) ;
1001 case 3: (void)_DtTermPrimBufferClearAllTabs(tb) ;
1007 _DtTermRequestParam(Widget w) /* DECREQTPARM CSIpx */
1009 ParserContext context ;
1012 Debug('P', fprintf(stderr,">>In func _DtTermRequestParam\n")) ;
1013 context = GetParserContext(w) ;
1014 STORELASTARG(context) ;
1015 row = context->parms[1] ;
1019 /* row (?), 1 no parity, 1 eight bits, 112 xmit 9600 baud,
1020 * 112, receive 9600 baud, 1 clock multiplier (?),
1021 * 0 STP flags (?) These are from xterm file 'charproc.c'.
1023 sprintf(buf,"\033[%d;%d;%d;%d;%d;%d;%dx",row,1,1,112,112,1,0) ;
1024 sendEscSequence(w,buf) ;
1030 _DtTermTabSet(Widget w) /* HTS ESCH */
1032 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1033 TermBuffer tb = tw->term.tpd->termBuffer ;
1034 Debug('P', fprintf(stderr,">>In func _DtTermTabSet\n")) ;
1035 (void)_DtTermPrimBufferSetTab(tb,tw->term.tpd->cursorColumn) ;
1039 _DtTermSaveCursor(Widget w) /* DECSC ESC7 */
1041 DtTermWidget vtw = (DtTermWidget) w;
1042 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1043 DtTermBuffer tb = (DtTermBuffer)tw->term.tpd->termBuffer ;
1044 DtTermData vtd = vtw->vt.td;
1046 Debug('P', fprintf(stderr,">>In func _DtTermSaveCursor\n")) ;
1047 vtd->saveCursor.cursorRow = vtw->term.tpd->cursorRow ;
1048 vtd->saveCursor.cursorColumn = vtw->term.tpd->cursorColumn ;
1049 vtd->saveCursor.originMode = vtw->vt.td->originMode ;
1050 /* The following is save at the TermPrim level */
1051 /* vtw->vt.td->saveCursor.wrapMode = */
1052 vtd->saveCursor.enhVideoState = vtd->enhVideoState ;
1053 vtd->saveCursor.enhFieldState = vtd->enhFieldState ;
1054 vtd->saveCursor.enhFgColorState = vtd->enhFgColorState;
1055 vtd->saveCursor.enhBgColorState = vtd->enhBgColorState;
1056 vtd->saveCursor.GL = vtd->GL;
1057 vtd->saveCursor.GR = vtd->GR;
1058 vtd->saveCursor.G0 = vtd->G0;
1059 vtd->saveCursor.G1 = vtd->G1;
1060 vtd->saveCursor.G2 = vtd->G2;
1061 vtd->saveCursor.G3 = vtd->G3;
1062 vtd->saveCursor.singleShiftFont = vtd->singleShiftFont;
1063 vtd->saveCursor.singleShiftPending = vtd->singleShiftPending;
1067 _DtTermRestoreCursor(Widget w) /* DECRC ESC8 */
1069 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1070 DtTermPrimData tpd = tw->term.tpd;
1071 DtTermWidget vtw = (DtTermWidget) w;
1072 DtTermData vtd = vtw->vt.td;
1074 Debug('P', fprintf(stderr,">>In func _DtTermRestoreCursor\n")) ;
1075 tpd->cursorRow = vtd->saveCursor.cursorRow ;
1076 tpd->cursorColumn = vtd->saveCursor.cursorColumn ;
1077 vtw->vt.td->originMode = vtd->saveCursor.originMode ;
1078 tpd->autoWrapRight = vtd->saveCursor.wrapMode ;
1079 vtd->enhVideoState = vtd->saveCursor.enhVideoState ;
1080 vtd->enhFieldState = vtd->saveCursor.enhFieldState ;
1081 vtd->enhFgColorState = vtd->saveCursor.enhFgColorState;
1082 vtd->enhBgColorState = vtd->saveCursor.enhBgColorState;
1083 vtd->GR = vtd->saveCursor.GR;
1084 vtd->GL = vtd->saveCursor.GL;
1085 vtd->G0 = vtd->saveCursor.G0;
1086 vtd->G1 = vtd->saveCursor.G1;
1087 vtd->G2 = vtd->saveCursor.G2;
1088 vtd->G3 = vtd->saveCursor.G3;
1089 vtd->singleShiftFont = vtd->saveCursor.singleShiftFont;
1090 vtd->singleShiftPending = vtd->saveCursor.singleShiftPending;
1091 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1092 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhVideo,
1093 vtd->enhVideoState);
1094 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1095 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhField,
1096 vtd->enhFieldState);
1097 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1098 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhFont,
1100 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1101 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhBgColor,
1102 vtd->saveCursor.enhBgColorState);
1103 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1104 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhFgColor,
1105 vtd->saveCursor.enhFgColorState);
1106 if ( vtd->originMode ) {
1107 if (tpd->cursorRow < tpd->scrollLockTopRow )
1108 tpd->cursorRow = tpd->scrollLockTopRow ;
1109 else if (tpd->cursorRow > tpd->scrollLockBottomRow )
1110 tpd->cursorRow = tpd->scrollLockBottomRow ;
1115 _DtTermAppKeypad(Widget w) /* DECPAM ESC= */
1117 DtTermWidget vtw = (DtTermWidget) w;
1118 Debug('P', fprintf(stderr,">>In func _DtTermAppKeypad\n")) ;
1119 vtw->vt.td->applicationKPMode=True;
1123 _DtTermNormalKeypad(Widget w) /* DECPNM ESC> */
1125 DtTermWidget vtw = (DtTermWidget) w;
1126 Debug('P', fprintf(stderr,">>In func _DtTermNormalKeypad\n")) ;
1127 vtw->vt.td->applicationKPMode=False;
1131 _DtTermS8C1T(Widget w) /* S8C1T ESCG */
1133 DtTermWidget vtw = (DtTermWidget) w;
1134 Debug('P', fprintf(stderr,">>In func _vt8CIT\n")) ;
1135 vtw->vt.td->S8C1TMode=True;
1139 _DtTermS7C1T(Widget w) /* S7C1T ESCF */
1141 DtTermWidget vtw = (DtTermWidget) w;
1142 Debug('P', fprintf(stderr,">>In func _vt8CIT\n")) ;
1143 vtw->vt.td->S8C1TMode=False;
1147 _DtTermSetCompatLevel(Widget w) /* DECSCL CSI p;p"p (last p literal) */
1149 ParserContext context ;
1150 DtTermWidget vtw = (DtTermWidget) w;
1151 Debug('P', fprintf(stderr,">>In func _DtTermSetCompatLevel\n")) ;
1152 context = GetParserContext(w) ;
1153 STORELASTARG(context) ;
1154 vtw->vt.td->compatLevel= 2; /* assume vt200 mode */
1155 switch ( PCOUNT(context) ) {
1156 case 1: switch (context->parms[1]) {
1157 case 61: vtw->vt.td->compatLevel= 1;
1158 vtw->vt.td->S8C1TMode=False;
1160 case 62: vtw->vt.td->S8C1TMode=True;
1164 case 2: switch (context->parms[2]) {
1166 case 2: vtw->vt.td->S8C1TMode=True;
1169 vtw->vt.td->S8C1TMode=False;
1176 _DtTermInvokeG3(Widget w) /* LS3R ESC| */
1178 ParserContext context ;
1180 Debug('P', fprintf(stderr,">>In func _DtTermInvokeG3\n")) ;
1181 context = GetParserContext(w) ;
1185 _DtTermInvokeG2(Widget w) /* LS3R ESC} */
1187 ParserContext context ;
1189 Debug('P', fprintf(stderr,">>In func _DtTermInvokeG2\n")) ;
1190 context = GetParserContext(w) ;
1194 _DtTermScrollUp(Widget w) /* SU CSIpS */
1196 ParserContext context ;
1197 DtTermWidget vtw = (DtTermWidget) w;
1200 Debug('P', fprintf(stderr,">>In func _DtTermScrollUp\n")) ;
1201 #define EXIT_IF_OUTSIDE_SR(w) if((w)->term.tpd->scrollLockTopRow > \
1202 (w)->term.tpd->cursorRow || \
1203 (w)->term.tpd->scrollLockBottomRow < \
1204 (w)->term.tpd->cursorRow) \
1206 EXIT_IF_OUTSIDE_SR(vtw)
1208 context = GetParserContext(w) ;
1209 row = vtw->term.tpd->cursorRow;
1210 col = vtw->term.tpd->cursorColumn;
1211 STORELASTARG(context) ;
1212 if (!context->parms[1])
1213 context->parms[1] = 1;
1214 else if (context->parms[1] > MAXSHORT)
1215 context->parms[1] = MAXSHORT - 100;
1217 /* clip the number of rows to the scroll region... */
1218 if (context->parms[1] > (vtw->term.tpd->scrollLockBottomRow -
1219 vtw->term.tpd->scrollLockTopRow + 1)) {
1220 context->parms[1] = vtw->term.tpd->scrollLockBottomRow -
1221 vtw->term.tpd->scrollLockTopRow + 1;
1224 vtw->term.tpd->cursorRow = TOPMARGIN(vtw) ;
1225 _DtTermFuncDeleteLine(w, context->parms[1], fromParser);
1226 vtw->term.tpd->cursorRow = row;
1227 vtw->term.tpd->cursorColumn = col;
1231 _DtTermScrollDown(Widget w) /* SD CSIpT */
1233 ParserContext context ;
1234 DtTermWidget vtw = (DtTermWidget) w;
1237 Debug('P', fprintf(stderr,">>In func _DtTermScrollDown\n")) ;
1238 EXIT_IF_OUTSIDE_SR(vtw)
1240 context = GetParserContext(w) ;
1241 row = vtw->term.tpd->cursorRow;
1242 col = vtw->term.tpd->cursorColumn ;
1243 STORELASTARG(context) ;
1244 if (!context->parms[1])
1245 context->parms[1] = 1;
1246 else if (context->parms[1] > MAXSHORT)
1247 context->parms[1] = MAXSHORT - 100;
1249 /* clip the number of rows to the scroll region... */
1250 if (context->parms[1] > (vtw->term.tpd->scrollLockBottomRow -
1251 vtw->term.tpd->scrollLockTopRow) + 1) {
1252 context->parms[1] = vtw->term.tpd->scrollLockBottomRow -
1253 vtw->term.tpd->scrollLockTopRow + 1;
1256 vtw->term.tpd->cursorRow = TOPMARGIN(vtw) ;
1257 _DtTermFuncInsertLine(w, context->parms[1], fromParser) ;
1258 vtw->term.tpd->cursorRow = row;
1259 vtw->term.tpd->cursorColumn = col;
1263 _DtTermRestoreModeValues(Widget w) /* xterm - Restore DEC mode values CSI?pr */
1265 ParserContext context ;
1266 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1267 DtTermWidget vtw = (DtTermWidget)w;
1268 DtTermData vtd = vtw->vt.td;
1270 Debug ('P', fprintf(stderr,">>In func _DtTermPModeReset\n")) ;
1271 context = GetParserContext(w) ;
1272 STORELASTARG(context) ;
1273 cnt = PCOUNT(context) ;
1274 for (i=1;i<=cnt;i++) {
1275 switch ( context->parms[i]) {
1277 case 1: /* Cursor key (Normal/Application) */
1278 vtd->applicationMode = vtd->saveDECMode.applicationMode ;
1280 #ifdef NOT_SUPPORTED
1281 case 2: /* set vt52 mode */
1283 #endif /* NOT_SUPPORTED */
1284 case 3: /* Columns (80/132) */
1285 vtd->col132Mode = vtd->saveDECMode.col132Mode ;
1287 case 4: /* Scroll Mode ( jump/smooth ) */
1288 _DtTermPrimScrollComplete(w, True) ;
1289 vtw->term.jumpScroll = vtd->saveDECMode.jumpScrollMode ;
1291 case 5: /* Screen mode */
1292 vtw->term.reverseVideo = vtd->saveDECMode.inverseVideoMode ;
1294 case 6: /* Origin mode (on/off)*/
1295 vtd->originMode = vtd->saveDECMode.originMode ;
1297 case 7: /* Auto wrap (On/Off) */
1298 vtw->term.tpd->autoWrapRight = vtd->saveDECMode.wrapMode ;
1300 case 8: /* Auto repeat (Off) */
1301 /* implemented in the server */
1303 #ifdef NOT_SUPPORTED
1304 case 18: /* Print form feed (Off) */
1306 case 19: /* Print extent (scrolling region) */
1308 #endif /* NOT_SUPPORTED */
1309 case 25: /* Text cursor enable (Off) */
1310 _DtTermPrimSetCursorVisible(w,
1311 vtd->saveDECMode.cursorVisible);
1315 case 40: /* 80/132 mode (disallow/allow) */
1316 vtw->vt.c132 = vtd->saveDECMode.allow80_132ColMode;
1318 case 41: /* curses fix (off/on) */
1319 vtd->fixCursesMode = vtd->saveDECMode.fixCursesMode;
1321 case 44: /* margin bell (off/on) */
1322 vtw->term.marginBell = vtd->saveDECMode.marginBellMode;
1324 case 45: /* Reverse-wraparound mode */
1325 vtd->reverseWrapMode = vtd->saveDECMode.reverseWrapMode ;
1327 case 46: /* logging (stop/start ) */
1328 if (vtd->saveDECMode.logging) {
1329 vtw->term.logging = True ;
1330 _DtTermPrimStartLog(w);
1332 vtw->term.logging = False ;
1333 _DtTermPrimCloseLog(w) ;
1336 #ifdef NOT_SUPPORTED
1337 case 47: /* screen buffer (normal) */
1339 case 1000: /* don't send mouse x and y */
1341 case 1001: /* don't use hilite mouse tracking */
1343 #endif /* NOT_SUPPORTED */
1349 _DtTermSaveModeValues(Widget w) /* xterm - Save DEC mode values CSI?ps */
1351 ParserContext context ;
1352 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1353 DtTermWidget vtw = (DtTermWidget)w;
1354 DtTermData vtd = vtw->vt.td;
1356 Debug ('P', fprintf(stderr,">>In func _DtTermPModeReset\n")) ;
1357 context = GetParserContext(w) ;
1358 STORELASTARG(context) ;
1359 cnt = PCOUNT(context) ;
1360 for (i=1;i<=cnt;i++) {
1361 switch ( context->parms[i]) {
1363 case 1: /* Cursor key (Normal/Application) */
1364 vtd->saveDECMode.applicationMode = vtd->applicationMode ;
1366 #ifdef NOT_SUPPORTED
1367 case 2: /* set vt52 mode */
1369 #endif /* NOT_SUPPORTED */
1370 case 3: /* Columns (80/132) */
1371 vtd->saveDECMode.col132Mode = vtd->col132Mode ;
1373 case 4: /* Scroll Mode ( jump/smooth ) */
1374 vtd->saveDECMode.jumpScrollMode = vtw->term.jumpScroll ;
1376 case 5: /* Screen mode */
1377 vtd->saveDECMode.inverseVideoMode = vtw->term.reverseVideo ;
1379 case 6: /* Origin mode (on/off)*/
1380 vtd->saveDECMode.originMode = vtd->originMode ;
1382 case 7: /* Auto wrap (On/Off) */
1383 vtd->saveDECMode.wrapMode = vtw->term.tpd->autoWrapRight ;
1385 case 8: /* Auto repeat (Off) */
1386 /* implemented in the server */
1388 #ifdef NOT_SUPPORTED
1389 case 18: /* Print form feed (Off) */
1391 case 19: /* Print extent (scrolling region) */
1393 #endif /* NOT_SUPPORTED */
1394 case 25: /* Text cursor enable (Off) */
1395 vtd->saveDECMode.cursorVisible =
1396 _DtTermPrimGetCursorVisible(w);
1399 case 40: /* 80/132 mode (disallow/allow) */
1400 vtd->saveDECMode.allow80_132ColMode = vtw->vt.c132;
1402 case 41: /* curses fix (off/on) */
1403 vtd->saveDECMode.fixCursesMode = vtd->fixCursesMode ;
1405 case 44: /* margin bell (off/on) */
1406 vtd->saveDECMode.marginBellMode = vtw->term.marginBell ;
1408 case 45: /* Reverse-wraparound mode */
1409 vtd->saveDECMode.reverseWrapMode = vtd->reverseWrapMode ;
1411 case 46: /* logging (stop/start ) */
1412 vtd->saveDECMode.logging = vtw->term.logging;
1414 #ifdef NOT_SUPPORTED
1415 case 47: /* screen buffer (normal) */
1417 case 1000: /* don't send mouse x and y */
1419 case 1001: /* don't use hilite mouse tracking */
1421 #endif /* NOT_SUPPORTED */
1428 _DtTermAlignTest(Widget w) /* DECALN ESC#8 */
1430 DtTermWidget vtw = (DtTermWidget) w;
1431 int tlrow, blrow, cnt ;
1432 Debug('P', fprintf(stderr,">>In func _DtTermAlignTest\n")) ;
1433 vtw->term.tpd->parserNotInStartState = False ;
1434 tlrow = vtw->term.tpd->scrollLockTopRow ;
1435 blrow = vtw->term.tpd->scrollLockBottomRow ;
1436 vtw->term.tpd->scrollLockTopRow = TOPROW(w) ; ;
1437 vtw->term.tpd->scrollLockBottomRow = BOTTOMROW(vtw) ;
1438 cnt = (BOTTOMROW(vtw)+BASE)*(LASTCOLUMN(vtw)+BASE);
1439 vtw->term.tpd->cursorColumn = FIRSTCOLUMN(w) ;
1440 vtw->term.tpd->cursorRow = TOPROW(w) ;
1441 while(cnt--) _DtTermPrimInsertText(w,(unsigned char *) "E", 1) ;
1442 vtw->term.tpd->scrollLockTopRow = tlrow ;
1443 vtw->term.tpd->scrollLockBottomRow = blrow ;
1444 vtw->term.tpd->cursorRow = CEILING(vtw) ;
1445 vtw->term.tpd->cursorColumn = FIRSTCOLUMN(w) ;
1449 _DtTermInvokeG1(Widget w) /* ESC~ESC */
1451 ParserContext context ;
1453 Debug('P', fprintf(stderr,">>In func _DtTermInvokeG1\n")) ;
1454 context = GetParserContext(w) ;
1458 _DtTermSelEraseInLine(Widget w) /* DECSEL ESC?pK */
1460 DtTermWidget vtw = (DtTermWidget) w;
1461 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1462 TermBuffer tb = tw->term.tpd->termBuffer ;
1463 DtTermPrimData tpd = tw->term.tpd;
1464 DtTermData td = vtw->vt.td;
1465 ParserContext context ;
1467 int c,col1,col2,col,row ;
1469 DtTermInsertCharMode saveInsertCharMode;
1471 Debug('P', fprintf(stderr,">>In func _DtTermSelEraseInLine\n")) ;
1473 context = GetParserContext(w) ;
1474 STORELASTARG(context) ;
1475 col1 = FIRSTCOLUMN(vtw) ;
1476 col2 = LASTCOLUMN(vtw) ;
1477 switch ( context->parms[1] ) {
1479 col1= tpd->cursorColumn;
1482 col2 = tpd->cursorColumn;
1489 /* save away the current cursor position... */
1490 col = tpd->cursorColumn ;
1491 row = tpd->cursorRow ;
1493 /* save away the current insert mode... */
1494 saveInsertCharMode = vtw->term.tpd->insertCharMode;
1496 /* insert char needs to be off... */
1497 tpd->insertCharMode = DtTERM_INSERT_CHAR_OFF;
1499 tpd->parserNotInStartState = False ;
1503 (void)_DtTermPrimBufferGetEnhancement(tb, tpd->cursorRow,
1504 c, &evalues, &cnt, countAll);
1507 if (evalues[(int)enhField] == FIELD_UNPROTECT) {
1508 (void) _DtTermPrimBufferSetEnhancement(tb, tpd->cursorRow,
1509 c, enhVideo, evalues[(int)enhVideo]);
1510 (void) _DtTermPrimBufferSetEnhancement(tb, tpd->cursorRow,
1511 c, enhFgColor, evalues[(int)enhFgColor]);
1512 (void) _DtTermPrimBufferSetEnhancement(tb, tpd->cursorRow,
1513 c, enhBgColor, evalues[(int)enhBgColor]);
1514 while ((c <= col2) && cnt--) {
1515 tpd->cursorColumn = c;
1516 (void) _DtTermPrimInsertText(w, (unsigned char *) " ", 1);
1524 /* restore the insert char mode... */
1525 tpd->insertCharMode = saveInsertCharMode;
1527 /* restore the cursor position... */
1528 tpd->cursorColumn = col;
1529 tpd->cursorRow = row;
1531 /* restore the current enhancement state... */
1532 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1533 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhVideo,
1535 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1536 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhFgColor,
1537 td->enhFgColorState);
1538 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1539 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhBgColor,
1540 td->enhBgColorState);
1544 _DtTermSelEraseInDisplay(Widget w) /* DECSED ESC?pJ */
1546 DtTermWidget vtw = (DtTermWidget) w;
1547 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1548 TermBuffer tb = tw->term.tpd->termBuffer ;
1549 ParserContext context ;
1551 int r,col1,col2,row1,row2,col,row ;
1553 Debug('P', fprintf(stderr,">>In func _DtTermSelEraseInDisplay\n")) ;
1555 context = GetParserContext(w) ;
1556 STORELASTARG(context) ;
1557 col1 = FIRSTCOLUMN(vtw) ;
1558 row1 = TOPROW(vtw) ;
1559 col2 = LASTCOLUMN(vtw) ;
1560 row2 = BOTTOMROW(vtw) ;
1561 switch ( context->parms[1] ) {
1562 case 0: col1= vtw->term.tpd->cursorColumn;
1563 row1 = vtw->term.tpd->cursorRow;
1565 case 1: col2 = vtw->term.tpd->cursorColumn;
1566 row2 = vtw->term.tpd->cursorRow;
1571 col = vtw->term.tpd->cursorColumn;
1572 row = vtw->term.tpd->cursorRow;
1573 vtw->term.tpd->cursorColumn = col1 ;
1574 vtw->term.tpd->cursorRow = row1;
1575 context->workingNum = 0 ; /* erase to the end of line */
1576 _DtTermSelEraseInLine(w) ;
1577 context->workingNum = 2 ; /* erase the whole row */
1578 for ( r=row1+1; r<row2; r++) {
1579 vtw->term.tpd->cursorRow = r;
1580 _DtTermSelEraseInLine(w) ;
1582 vtw->term.tpd->cursorColumn = col2 ;
1583 vtw->term.tpd->cursorRow = row2;
1584 context->workingNum = 2 ; /* erase the beginning of the line */
1585 _DtTermSelEraseInLine(w) ;
1586 vtw->term.tpd->cursorColumn = col ;
1587 vtw->term.tpd->cursorRow = row;
1592 _DtTermSingleShiftG2(Widget w) /* SS2 ESCN */
1594 DtTermWidget vtw = (DtTermWidget) w;
1595 DtTermData vtd = vtw->vt.td;
1597 Debug('P', fprintf(stderr,">>In func _DtTermSingleShiftG2\n")) ;
1598 vtd->singleShiftPending = True;
1599 vtd->singleShiftFont = vtd->G2;
1603 _DtTermSingleShiftG3(Widget w) /* SS3 ESCO */
1605 DtTermWidget vtw = (DtTermWidget) w;
1606 DtTermData vtd = vtw->vt.td;
1608 Debug('P', fprintf(stderr,">>In func _DtTermSingleShiftG3\n")) ;
1609 vtd->singleShiftPending = True;
1610 vtd->singleShiftFont = vtd->G3;
1614 _DtTermLoadCharSet(Widget w) /* vt220 DCS - download char set ESCPpST */
1616 /* we're not implementing this */
1619 /*********************************************************************
1620 * The next 3 functions handle the user key string loading
1621 * DCS Pc;Pl | Ky1/st1;ky2/st2;...kyn/stn ST
1624 _DtTermParseUserKeyClear(Widget w) /* vt220 DECUDK clear function keys*/
1626 DtTermWidget vtw = (DtTermWidget) w;
1627 DtTermData vtd = vtw->vt.td;
1628 ParserContext context ;
1629 Debug('P', fprintf(stderr,">>In func _DtTermLoadSoftKey\n")) ;
1630 context = GetParserContext(w) ;
1631 STORELASTARG(context) ;
1632 if ( !vtd->userKeysLocked )
1634 vtd->needToLockUserKeys = False ;
1635 if (context->parms[1] == 0)
1636 _DtTermFunctionKeyClear(w) ;
1637 if (context->parms[0] == 2 && context->parms[2] == 0)
1638 vtd->needToLockUserKeys = True ;
1640 _DtTermClearParam(w) ;
1643 _DtTermParseUserKeyLoad(Widget w) /* vt220 DECUDK load function string */
1645 DtTermWidget vtw = (DtTermWidget) w;
1646 DtTermData vtd = vtw->vt.td;
1647 ParserContext context ;
1648 Debug('P', fprintf(stderr,">>In func _DtTermLoadSoftKey\n")) ;
1649 context = GetParserContext(w) ;
1650 STORELASTARG(context) ;
1651 if ( !vtd->userKeysLocked)
1653 context->stringParms[0].str[context->stringParms[0].length/2] =
1654 (unsigned char)0 ; /* Null terminate */
1655 _DtTermFunctionKeyStringStore(w,context->parms[1],
1656 (char *)context->stringParms[0].str);
1658 _DtTermClearParam(w) ;
1662 _DtTermParseUserKeyLoadLast(Widget w) /* vt220 DECUDK load function string */
1664 DtTermWidget vtw = (DtTermWidget) w;
1665 DtTermData vtd = vtw->vt.td;
1666 _DtTermParseUserKeyLoad(w);
1667 if (vtd->needToLockUserKeys) vtd->userKeysLocked = True ;
1668 vtd->needToLockUserKeys = False ;
1672 _DtTermParseHexDigit(Widget w) /* vt220 DECUDK store hex digit*/
1674 ParserContext context ;
1675 int ci, left_byte, i;
1677 Debug('P', fprintf(stderr,">>In func _DtTermLoadSoftKey\n")) ;
1678 context = GetParserContext(w) ;
1679 if ( (int)context->stringParms[0].length < 2*STR_SIZE-1 ) {
1680 /* fold the hex digits into characters */
1681 i = context->stringParms[0].length ;
1682 cbuf[0] = *context->inputChar ;
1684 sscanf(cbuf,"%x",&ci) ;
1686 left_byte = (i+1)%2 ;
1689 context->stringParms[0].str[i] = c<<4 ;
1691 context->stringParms[0].str[i] |= c & 0x0F ;
1692 context->stringParms[0].length++ ;
1697 _DtTermReset(Widget w) /* RIS ESCc */
1699 ParserContext context ;
1701 Debug('P', fprintf(stderr,">>In func _DtTermReset\n")) ;
1702 context = GetParserContext(w) ;
1703 _DtTermFuncHardReset(w,0 ,fromParser) ;
1707 _DtTermSelectG2(Widget w) /* LS2 ESCn */
1709 DtTermWidget vtw = (DtTermWidget)w ;
1710 DtTermData vtd = vtw->vt.td;
1711 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1712 DtTermPrimData tpd = tw->term.tpd;
1714 Debug('P', fprintf(stderr,">>In func _DtTermSelectG2\n")) ;
1717 vtd->enhFontState = *vtd->GL;
1718 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1719 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1720 enhFont, vtd->enhFontState);
1724 _DtTermSelectG3(Widget w) /* LS3 ESCo */
1726 DtTermWidget vtw = (DtTermWidget)w ;
1727 DtTermData vtd = vtw->vt.td;
1728 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1729 DtTermPrimData tpd = tw->term.tpd;
1731 Debug('P', fprintf(stderr,">>In func _DtTermSelectG3\n")) ;
1733 vtd->enhFontState = *vtd->GL;
1734 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1735 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1736 enhFont, vtd->enhFontState);
1740 _DtTermParseStatus(Widget w) /* DECID (same as DA) ESCZ */
1742 _DtTermDeviceAttributes(w) ;
1746 _DtTermSetCharEraseMode(Widget w) /* DECSCA ESCp"q */
1748 DtTermWidget vtw = (DtTermWidget) w;
1749 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1750 DtTermPrimData tpd = tw->term.tpd;
1751 ParserContext context ;
1752 Debug('P', fprintf(stderr,">>In func _DtTermSetCharEraseMode\n")) ;
1753 context = GetParserContext(w) ;
1754 STORELASTARG(context) ;
1755 switch ( context->parms[1] ) {
1756 case 0: /* set back to default which is unprotect */
1759 vtw->vt.td->enhFieldState = FIELD_UNPROTECT;
1760 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1761 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1762 enhField, vtw->vt.td->enhFieldState);
1765 vtw->vt.td->enhFieldState = FIELD_PROTECT;
1766 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1767 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1768 enhField, vtw->vt.td->enhFieldState);
1774 _DtTermSingleWide(Widget w) /* DECSWL ESC#5 */
1776 ParserContext context ;
1778 Debug('P', fprintf(stderr,">>In func _DtTermSingleWide\n")) ;
1779 context = GetParserContext(w) ;
1783 _DtTermDoubleWide(Widget w) /* DECDWL ESC#6 */
1785 ParserContext context ;
1787 Debug('P', fprintf(stderr,">>In func _DtTermDoubleWide\n")) ;
1788 context = GetParserContext(w) ;
1792 _DtTermDoubleHigh(Widget w) /* DECWHL ESC#4 */
1794 ParserContext context ;
1796 Debug('P', fprintf(stderr,">>In func _DtTermDoubleHigh\n")) ;
1797 context = GetParserContext(w) ;
1801 _DtTermParseFontG0(Widget w)
1803 DtTermWidget vtw = (DtTermWidget)w ;
1804 DtTermData vtd = vtw->vt.td;
1805 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1806 DtTermPrimData tpd = tw->term.tpd;
1807 ParserContext context ;
1808 context = GetParserContext(w) ;
1810 Debug('P', fprintf(stderr,">>In func _DtTermParseFontG0\n")) ;
1811 switch (*context->inputChar) {
1813 vtd->G0 = FONT_NORMAL;
1817 vtd->G0 = FONT_LINEDRAW;
1821 vtd->enhFontState = *vtd->GL;
1822 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1823 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1824 enhFont, vtd->enhFontState);
1828 _DtTermParseFontG1(Widget w)
1830 DtTermWidget vtw = (DtTermWidget)w ;
1831 DtTermData vtd = vtw->vt.td;
1832 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1833 DtTermPrimData tpd = tw->term.tpd;
1834 ParserContext context ;
1835 context = GetParserContext(w) ;
1837 Debug('P', fprintf(stderr,">>In func _DtTermParseFontG1\n")) ;
1838 switch (*context->inputChar) {
1840 vtd->G1 = FONT_NORMAL;
1844 vtd->G1 = FONT_LINEDRAW;
1848 vtd->enhFontState = *vtd->GL;
1849 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1850 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1851 enhFont, vtd->enhFontState);
1855 _DtTermParseFontG2(Widget w)
1857 DtTermWidget vtw = (DtTermWidget)w ;
1858 DtTermData vtd = vtw->vt.td;
1859 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1860 DtTermPrimData tpd = tw->term.tpd;
1861 ParserContext context ;
1862 context = GetParserContext(w) ;
1864 Debug('P', fprintf(stderr,">>In func _DtTermParseFontG1\n")) ;
1865 switch (*context->inputChar) {
1867 vtd->G2 = FONT_NORMAL;
1871 vtd->G2 = FONT_LINEDRAW;
1875 vtd->enhFontState = *vtd->GL;
1876 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1877 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1878 enhFont, vtd->enhFontState);
1882 _DtTermParseFontG3(Widget w)
1884 DtTermWidget vtw = (DtTermWidget)w ;
1885 DtTermData vtd = vtw->vt.td;
1886 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1887 DtTermPrimData tpd = tw->term.tpd;
1888 ParserContext context ;
1889 context = GetParserContext(w) ;
1891 Debug('P', fprintf(stderr,">>In func _DtTermParseFontG1\n")) ;
1892 switch (*context->inputChar) {
1894 vtd->G3 = FONT_NORMAL;
1898 vtd->G3 = FONT_LINEDRAW;
1902 vtd->enhFontState = *vtd->GL;
1903 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1904 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1905 enhFont, vtd->enhFontState);
1909 _DtTermParseFontShift(Widget w) /* Ctrl-E Ctrl-F */
1911 DtTermWidget vtw = (DtTermWidget)w ;
1912 DtTermData vtd = vtw->vt.td;
1913 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1914 DtTermPrimData tpd = tw->term.tpd;
1915 ParserContext context ;
1916 context = GetParserContext(w) ;
1918 Debug('P', fprintf(stderr,">>In func _DtTermParseFontShift\n")) ;
1919 switch (*context->inputChar) {
1931 vtd->enhFontState = *vtd->GL;
1932 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1933 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1934 enhFont, vtd->enhFontState);
1938 _DtTermParseTab(Widget w) /* Crtl-I */
1940 DtTermWidget vtw = (DtTermWidget)w ;
1941 Debug('P', fprintf(stderr,">>In func _DtTermParseTab\n")) ;
1942 if (vtw->term.tpd->cursorColumn > LASTCOLUMN(vtw)) {
1943 if (vtw->vt.td->fixCursesMode) {
1944 (void) _DtTermNextLine(w);
1945 (void) _DtTermFuncTab(w, 1, fromParser);
1947 /* we already tabbed to the end of the line, so do nothing... */
1950 (void) _DtTermFuncTab(w, 1, fromParser);
1956 _DtTermParseLF /* LineFeed (LF) or newline (NL) Ctrl-J,
1957 Vertical Tab Ctrl-K, Form Feed (NP) Ctrl-L */
1962 DtTermWidget vtw = (DtTermWidget)w ;
1963 Debug('P', fprintf(stderr,">>In func _vtParseLR\n")) ;
1965 if (vtw->term.tpd->cursorRow == BOTTOMMARGIN(vtw))
1968 ** scroll one line...
1970 (void) _DtTermPrimScrollText(w, 1);
1971 vtw->term.tpd->cursorRow = BOTTOMMARGIN(vtw);
1974 if (!(vtw->term.tpd->cursorRow == BOTTOMROW(vtw))) {
1975 vtw->term.tpd->cursorRow++ ;
1978 (void) _DtTermPrimFillScreenGap(w);
1980 if (vtw->term.tpd->autoLineFeed )
1981 _DtTermPrimParseCR(w);
1985 _DtTermSoftReset /* DECSTR ESC!p */
1990 Debug('P', fprintf(stderr,">>In func _DtTermSoftReset\n")) ;
1991 _DtTermFuncSoftReset(w,0 ,fromParser) ;
1995 _DtTermParseBackspace /* Ctrl-H */
2000 ParserContext context ;
2001 DtTermWidget vtw = (DtTermWidget) w;
2002 int row,col,fcol,cnt ;
2003 Debug('P', fprintf(stderr,">>In func _DtTermParseBackspace\n")) ;
2004 context = GetParserContext(w) ;
2005 fcol = FIRSTCOLUMN(vtw) ;
2006 row = vtw->term.tpd->cursorRow;
2007 col = vtw->term.tpd->cursorColumn;
2010 if (vtw->vt.td->reverseWrapMode) {
2011 if ( --row < TOPROW(vtw)) row = BOTTOMROW(vtw);
2012 if (vtw->vt.td->originMode && row < TOPMARGIN(vtw))
2013 row =BOTTOMMARGIN(vtw);
2014 col = LASTCOLUMN(vtw) ;
2020 vtw->term.tpd->cursorRow = row;
2021 vtw->term.tpd->cursorColumn = col;
2035 Window parentReturn;
2036 Window *childrenReturn;
2037 unsigned int nChildrenReturn;
2043 unsigned int widthReturn;
2044 unsigned int heightReturn;
2045 unsigned int topWidthReturn;
2046 unsigned int topHeightReturn;
2047 unsigned int borderWidthReturn;
2048 unsigned int depthReturn;
2055 if (XmIsMotifWMRunning(w)) {
2056 /* get the window we want to figure the offsets for... */
2057 topWindow = XtWindow(w);
2059 /* and the display involved... */
2060 display = XtDisplay(w);
2062 (void) XQueryTree(display, topWindow, &rootWindow, &parentReturn,
2063 &childrenReturn, &nChildrenReturn);
2064 (void) XFree(childrenReturn);
2066 /* walk up the tree until the parent window is root... */
2067 while (parentReturn != rootWindow) {
2068 topWindow = parentReturn;
2069 (void) XQueryTree(display, topWindow, &rootWindow,
2070 &parentReturn, &childrenReturn, &nChildrenReturn);
2071 (void) XFree(childrenReturn);
2074 /* we now know what our top window is. translate our upper
2075 * left corner relative to its upper left corner...
2077 (void) XTranslateCoordinates(display, XtWindow(w), topWindow,
2078 0, 0, &destXReturn, &destYReturn, &childReturn);
2079 *xOffset = destXReturn;
2080 *yOffset = destYReturn;
2082 /* now that we know the top window, we can figure out the size
2083 * difference between the two windows...
2085 (void) XGetGeometry(display, topWindow, &rootWindow,
2086 &destXReturn, &destYReturn, &topWidthReturn,
2087 &topHeightReturn, &borderWidthReturn, &depthReturn);
2089 (void) XGetGeometry(display, XtWindow(w), &rootWindow,
2090 &destXReturn, &destYReturn, &widthReturn, &heightReturn,
2091 &borderWidthReturn, &depthReturn);
2093 *widthOffset = topWidthReturn - widthReturn;
2094 *heightOffset = topHeightReturn - heightReturn;
2099 _DtTermParseSunMisc /* Misc sun esc seqs */
2104 ParserContext context ;
2105 DtTermWidget vtw = (DtTermWidget) w;
2106 Display *display = XtDisplay(w);
2107 int i, scr_num = XScreenNumberOfScreen(XtScreen(w));
2108 Window win = XtWindow(w);
2111 XWindowChanges values;
2116 Dimension height,width;
2117 char *fmt,*s,*title,*icon;
2123 context = GetParserContext(w) ;
2124 STORELASTARG(context) ;
2126 for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2127 sh_win = XtWindow(sw) ;
2128 switch (context->parms[1])
2131 XMapWindow(display,sh_win);
2134 XIconifyWindow(display,sh_win,scr_num);
2137 (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2140 (void) XMoveWindow(display, sh_win,
2141 context->parms[2] + xOffset, context->parms[3] + yOffset);
2143 (void) XtVaSetValues(sw, XmNx, context->parms[2] + xOffset,
2144 XmNy, context->parms[3] + yOffset, NULL);
2147 (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2149 (void) XtVaSetValues(sw, XmNwidth, context->parms[3] - widthOffset,
2150 XmNheight,context->parms[2] - heightOffset, NULL);
2153 XRaiseWindow(display,sh_win);
2156 XLowerWindow(display,sh_win);
2159 _DtTermPrimFuncRedrawDisplay(w, 1, fromParser);
2162 rows = context->parms[2];
2163 columns = context->parms[3];
2164 (void) XtVaSetValues(w, DtNrows, rows, DtNcolumns, columns, NULL);
2167 if (vtw->term.tpd->windowMapped)
2168 sendEscSequence(w,"\033[1t") ;
2170 sendEscSequence(w,"\033[2t") ;
2173 (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2175 (void) XtVaGetValues(sw, XtNx, &x, XtNy, &y, NULL);
2176 (void) sprintf(buf, "\033[3;%d;%dt", x - xOffset, y - yOffset);
2177 (void) sendEscSequence(w, buf);
2180 (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2182 (void) XtVaGetValues(sw, XtNheight, &height, XtNwidth, &width, NULL);
2183 (void) sprintf(buf,"\033[4;%d;%dt", height + heightOffset,
2184 width + widthOffset);
2185 (void) sendEscSequence(w, buf);
2188 (void) XtVaGetValues(w, DtNrows, &rows, DtNcolumns, &columns, NULL);
2189 (void) sprintf(buf, "\033[8;%hd;%hdt", rows, columns);
2190 (void) sendEscSequence(w, buf);
2193 XtVaGetValues(sw,XmNiconName, &icon, NULL);
2194 fmt = "\033]L%s\033\\";
2195 if (strlen(icon) + strlen(fmt) + 1 >= sizeof(buf))
2196 s = XtMalloc(strlen(icon) + strlen(fmt) + 1);
2199 sprintf(s, "%s", fmt);
2200 sendEscSequence(w,s) ;
2201 if (s != buf) XtFree(s);
2204 XtVaGetValues(sw,XmNtitle, &title, NULL);
2205 fmt = "\033]l%s\033\\";
2206 if (strlen(icon) + strlen(fmt) + 1 >= sizeof(buf))
2207 s = XtMalloc(strlen(icon) + strlen(fmt) + 1);
2210 sprintf(s, "%s", fmt);
2211 sendEscSequence(w,s) ;
2212 if (s != buf) XtFree(s);
2218 _DtTermParserSunWindowIcon( Widget w) /* sun set icon label */
2220 ParserContext context ;
2222 context = GetParserContext(w) ;
2223 for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2224 XtVaSetValues(sw, XmNiconName, context->stringParms[0].str, NULL) ;
2228 _DtTermParserSunWindowTitle /* Sun set title name */
2233 ParserContext context ;
2235 context = GetParserContext(w) ;
2236 for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2237 XtVaSetValues(sw,XmNtitle, context->stringParms[0].str, NULL) ;
2241 _DtTermParserSunIconFile(Widget w) /* Sun set icon to pixmap in file */
2244 (DtTermBuffer)((DtTermPrimitiveWidget)w)->term.tpd->termBuffer ;
2245 ParserContext context ;
2250 context = GetParserContext(w) ;
2251 for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2252 XtVaGetValues(sw, XtNforeground, &fg, XtNbackground, &bg, NULL);
2253 icon = XmGetPixmap(XtScreen(sw),(char *)context->stringParms[0].str,fg,bg);
2254 if (icon != XmUNSPECIFIED_PIXMAP)
2255 XtVaSetValues(sw, XmNiconPixmap, icon, NULL);