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. *
39 #include "TermHeader.h"
40 #include "TermPrimDebug.h"
41 #include "TermPrimP.h"
42 #include "TermPrimI.h"
44 #include "TermPrimData.h"
46 #include "TermPrimBuffer.h"
47 #include "TermPrimParserP.h"
48 #include "TermFunction.h"
49 #include "TermBuffer.h"
50 #include "TermFunctionKey.h"
51 #include "TermParseTableP.h"
52 #include "TermBufferP.h"
56 * On HP MAXINT is defined in both <values.h> and <sys/param.h>
60 #if defined(CSRG_BASED)
61 #define MAXSHORT SHRT_MAX
66 #if defined(USL) || defined(__uxp__)
71 /*****************************************************************************/
74 #define PCOUNT(c) ((c)->parms[0])
75 #define BASE 1 /* row and column count base 0 or 1 */
77 /*********************************************************************
78 * Macros for handling cursor constraints - return values in coordinate
79 * system for Term widget (base 0) BASE which is 1 reflects the Vt base
81 * These defines need to account of for Origin mode eventually TMH */
83 #define TOPROW(w) (1-BASE)
84 #define TOPMARGIN(w) ((w)->term.tpd->scrollLockTopRow-(1-BASE))
85 #define BOTTOMMARGIN(w) ((w)->term.tpd->scrollLockBottomRow-(1-BASE))
86 #define BOTTOMROW(w) ((w)->term.rows-BASE)
87 /* FIRSTCOLUMN(w) ABS(BASE-1) */
88 #define FIRSTCOLUMN(w) 0
89 #define LASTCOLUMN(w) ((w)->term.columns-BASE)
90 #define FLOOR(w) ((w)->vt.td->originMode?(w)->term.tpd->scrollLockBottomRow:\
92 #define CEILING(w) ((w)->vt.td->originMode?(w)->term.tpd->scrollLockTopRow:\
94 #define KILLWRAP(w) if((w)->term.tpd->cursorColumn>LASTCOLUMN(w)) \
95 (w)->term.tpd->cursorColumn=LASTCOLUMN(w)
96 #define STORELASTARG(c) (c)->parms[PCOUNT(c)]=(c)->workingNum
98 /******************************************************************
99 * Upon entering a parse routine the parameter count is contained
100 * in context->parms[0].
102 * The last parmameter parsed is in context->workingNum
103 * Next to last parmameter is in {context->parms[0]==1?context->workingNum:
104 * context->parms[context->param[0]-1]}
108 * First parameter is in context->parms[1]
110 * In some of the parse routines, the default case of too many parameters
111 * needs to be handled like Vt (silently use the first n parameters)
112 * Vt has a max of 16 numeric parameters; The rest fall off the end
114 *******************************************************************/
117 _DtTermClearParam(Widget w)
119 ParserContext context ;
120 context = GetParserContext(w) ;
123 _DtTermPrimParserClearParm(w) ;
124 _DtTermPrimParserClrStrParm(w) ;
128 _DtTermEnterNum(Widget w)
130 ParserContext context ;
131 context = GetParserContext(w) ;
132 _DtTermPrimParserEnterNum(w) ;
133 if (!PCOUNT(context)) PCOUNT(context)++ ; /* increment for first number ONLY*/
137 _DtTermParsePushNum(Widget w)
139 ParserContext context ;
140 context = GetParserContext(w) ;
141 /* parmN(w,PCOUNT(c)) ; Should use this but not global */
142 if ( context->workingNumIsDefault != True) { /* did we actually parse a num*/
143 _DtTermPrimParserNumParmPush(w,PCOUNT(context)) ;
146 if (!PCOUNT(context)) PCOUNT(context)++ ;/* increment for first number ONLY*/
149 if ( ++PCOUNT(context)>NPARAM ) {
150 Debug('P',fprintf(stderr,">>Too many parameters\n")) ;
156 _DtTermSaveChar(Widget w)
158 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
159 ParserContext context ;
161 context = GetParserContext(w) ;
163 mbtowc(&c,(char *)context->inputChar,MB_CUR_MAX);
164 if ( context->stringParms[0].length < STR_SIZE && iswprint(c) ) {
166 (char *)&context->stringParms[0].str[context->stringParms[0].length]),
167 (char *)context->inputChar, context->inputCharLen) ;
168 context->stringParms[0].length += context->inputCharLen ;
173 _DtTermPrintState(Widget w)
175 ParserContext context ;
176 context = GetParserContext(w) ;
177 /* fprintf(stderr,"Warning: Not a valid escape sequence\n") ;*/
178 context->stateTable = _DtTermStateStart ;
179 _DtTermClearParam(w) ;
182 /* a utility for checking for S8C1TMode */
184 sendEscSequence(Widget w, char *transmitString)
186 DtTermWidget tw = (DtTermWidget)w;
187 DtTermData td = tw->vt.td;
189 if ( td->S8C1TMode ) {
190 char *cbuf =malloc(strlen(transmitString)+1);
191 strcpy(cbuf,transmitString) ;
193 (void) _DtTermPrimSendInput(w, (unsigned char *) (cbuf+1),
198 (void) _DtTermPrimSendInput(w, (unsigned char *) transmitString,
199 strlen(transmitString));
204 _DtTermDeviceStatus(Widget w) /* DSR CSI?pn */
206 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
207 DtTermData vtd = ((DtTermWidget)w)->vt.td;
208 ParserContext context ;
211 Debug('P', fprintf(stderr,">>In func _DtTermDeviceStatus\n")) ;
212 context = GetParserContext(w) ;
213 STORELASTARG(context) ;
214 switch ( context->parms[1] ) {
215 case 15: /* printer status - we don't have one */
216 sendEscSequence(w,"\033[?13n") ;
218 case 25: /* User defined keys locked? */
219 if ( vtd->userKeysLocked )
220 sendEscSequence(w,"\033[?21n") ;
222 sendEscSequence(w,"\033[?20n") ;
224 case 26: /* keyboard status - always send North American */
225 sendEscSequence(w,"\033[?27;1n") ;
231 _DtTermDeviceStatusAnsi(Widget w) /* DSR CSIpn */
233 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
234 DtTermData vtd = ((DtTermWidget)w)->vt.td;
235 ParserContext context ;
238 Debug('P', fprintf(stderr,">>In func _DtTermDeviceStatus\n")) ;
239 context = GetParserContext(w) ;
240 STORELASTARG(context) ;
241 switch ( context->parms[1] ) {
242 case 5: /* as far as I know, all's well... So send OK */
243 sendEscSequence(w,"\033[0n") ;
246 /* cursor could be past last row (for autowrap) */
247 if ((col=tw->term.tpd->cursorColumn)>LASTCOLUMN(tw))
249 row = tw->term.tpd->cursorRow+BASE ;
250 if (vtd->originMode==True) row -= TOPMARGIN(tw) ;
251 sprintf(buf,"\033[%d;%dR",row , col+BASE) ;
252 sendEscSequence(w,buf) ;
258 _DtTermPModeSet(Widget w) /* DECSET CSI?ph */
260 ParserContext context ;
261 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
262 DtTermWidget vtw = (DtTermWidget)w;
264 Debug('P', fprintf(stderr,">>In func _DtTermPModeSet\n")) ;
265 context = GetParserContext(w) ;
266 STORELASTARG(context) ;
267 cnt = PCOUNT(context) ;
268 for (i=1;i<=cnt;i++) {
269 switch ( context->parms[i]) {
271 case 1: /* Cursor key (Application) */
272 vtw->vt.td->applicationMode=True;
274 /* case 2: can't return from vt52 mode */
275 case 3: /* Column (132) */
276 if ( vtw->vt.c132 ) { /* xterm allow 132 mode */
277 (void) _DtTermFuncClearBuffer(w, NULL, fromParser);
278 vtw->term.tpd->cursorRow = TOPROW(vtw) ;
279 vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
280 vtw->term.tpd->scrollLockTopRow = TOPROW(vtw);
281 vtw->term.tpd->scrollLockBottomRow = BOTTOMROW(vtw) ;
282 XtVaSetValues(w, DtNcolumns, 132, NULL) ;
283 vtw->vt.td->col132Mode = True ;
286 case 4: /* Scroll (smooth) */
287 _DtTermPrimScrollComplete(w, True) ;
288 vtw->term.jumpScroll = False ;
290 case 5: /* Screen (Reverse) */
291 /*DKS: this is just to test out the functionality... */
292 vtw->term.reverseVideo = True;
293 /* clear the window to force refresh... */
294 (void) XClearArea(XtDisplay(w), XtWindow(w),
297 case 6: /* Origin mode (On) */
298 vtw->vt.td->originMode=True;
299 _DtTermPrimCursorMove(w, TOPMARGIN(vtw), 0);
301 case 7: /* Auto wrap (On) */
302 vtw->term.tpd->autoWrapRight=True ;
304 /* case 8: ** Auto repeat (On)
305 * ** This is handled by the X server
308 * case 18: ** Print form feed (On)
310 * case 19: ** Print extent (full screen)
313 case 25: /* Text cursor enable (On) */
314 (void) _DtTermPrimSetCursorVisible(w, True);
317 case 40: /* 80/132 mode (allow) */
318 vtw->vt.c132 = True ;
320 case 41: /* curses fix */
321 vtw->vt.td->fixCursesMode = True ;
323 case 44: /* margin bell (on) */
324 vtw->term.marginBell = True ;
326 case 45: /* Reverse-wraparound mode */
327 vtw->vt.td->reverseWrapMode=True;
329 case 46: /* logging (start) */
330 vtw->term.logging = True ;
331 _DtTermPrimStartLog(w);
333 /* case 47: ** screen buffer (alternate)
335 * case 1000: ** Send mouse x and y
337 * case 1001: ** Use hilite mouse tracking
346 _DtTermPModeReset(Widget w) /* DECRST CSI?pl */
348 ParserContext context ;
349 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
350 DtTermWidget vtw = (DtTermWidget)w;
352 Debug ('P', fprintf(stderr,">>In func _DtTermPModeReset\n")) ;
353 context = GetParserContext(w) ;
354 STORELASTARG(context) ;
355 cnt = PCOUNT(context) ;
356 for (i=1;i<=cnt;i++) {
357 switch ( context->parms[i]) {
359 case 1: /* Cursor key (Normal) */
360 vtw->vt.td->applicationMode=False;
362 /* case 2: ** set vt52 mode */
363 case 3: /* Column (80) */
364 if (vtw->vt.c132) { /* allow 132 mode */
365 (void) _DtTermFuncClearBuffer(w, NULL, fromParser);
366 vtw->term.tpd->cursorRow = TOPROW(vtw) ;
367 vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
368 vtw->term.tpd->scrollLockTopRow = TOPROW(vtw);
369 vtw->term.tpd->scrollLockBottomRow = BOTTOMROW(vtw) ;
370 XtVaSetValues(w, DtNcolumns, 80, NULL) ;
371 vtw->vt.td->col132Mode = False ;
374 case 4: /* Scroll (jump) */
375 _DtTermPrimScrollComplete(w, True) ;
376 vtw->term.jumpScroll = True ;
378 case 5: /* Screen (normal ) */
379 /*DKS: this is just to test out the functionality... */
380 vtw->term.reverseVideo = False;
381 /* clear the window to force refresh... */
382 (void) XClearArea(XtDisplay(w), XtWindow(w),
385 case 6: /* Normal cursor (not Origin mode) */
386 vtw->vt.td->originMode=False;
387 _DtTermPrimCursorMove(w, 0, 0);
389 case 7: /* Auto wrap (Off) */
390 vtw->term.tpd->autoWrapRight=False;
392 /* case 8: ** Auto repeat (Off)
393 * ** implemented in the server
395 * case 18: ** Print form feed (Off)
397 * case 19: ** Print extent (scrolling region)
400 case 25: /* Text cursor enable (Off) */
401 (void) _DtTermPrimSetCursorVisible(w, False);
404 case 40: /* 80/132 mode (disallow) */
405 vtw->vt.c132 = False;
407 case 41: /* curses fix */
408 vtw->vt.td->fixCursesMode = False;
410 case 44: /* margin bell (off) */
411 vtw->term.marginBell = False ;
413 case 45: /* Reverse-wraparound mode */
414 vtw->vt.td->reverseWrapMode=False;
416 case 46: /* logging (stop ) */
417 vtw->term.logging = False ;
418 _DtTermPrimCloseLog(w) ;
420 /* case 47: ** screen buffer (normal)
422 * case 1000: ** don't send mouse x and y
424 * case 1001: ** don't use hilite mouse tracking
432 _DtTermSetMode(Widget w) /* SM CSIph */
434 ParserContext context ;
435 DtTermWidget vtw = (DtTermWidget)w ;
437 Debug('P', fprintf(stderr,">>In func _DtTermSetMode\n")) ;
438 context = GetParserContext(w) ;
439 STORELASTARG(context) ;
440 cnt = PCOUNT(context) ;
441 for (i=1;i<=cnt;i++) {
442 switch ( context->parms[i]) {
443 case 2: /* KAM Keyboard Action (locked) */
444 vtw->term.tpd->keyboardLocked.escape=True ;
445 (void) _DtTermPrimInvokeStatusChangeCallback(w);
447 case 4: /* Insert mode */
448 _DtTermPrimInsertCharUpdate(w, DtTERM_INSERT_CHAR_ON) ;
450 case 12: /* SRM Send/Receive (Off) */
451 vtw->term.tpd->halfDuplex = False;
453 case 20: /* Line feed/newline (new line) */
454 vtw->term.tpd->autoLineFeed=True ;
461 _DtTermResetMode(Widget w) /* RM CSIpl */
463 ParserContext context ;
464 DtTermWidget vtw = (DtTermWidget)w ;
466 Debug('P', fprintf(stderr,">>In func _DtTermResetMode\n")) ;
467 context = GetParserContext(w) ;
468 STORELASTARG(context) ;
469 cnt = PCOUNT(context) ;
470 for (i=1;i<=cnt;i++) {
471 switch ( context->parms[i]) {
472 case 2: /* KAM Keyboard Action (unlocked) */
473 vtw->term.tpd->keyboardLocked.escape=False;
474 (void) _DtTermPrimInvokeStatusChangeCallback(w);
476 case 4: /* Replace mode */
477 _DtTermPrimInsertCharUpdate(w, DtTERM_INSERT_CHAR_OFF) ;
479 case 12: /* SRM Send/Receive (On) */
480 vtw->term.tpd->halfDuplex = True;
482 case 20: /* Line feed/newline (line feed) */
483 vtw->term.tpd->autoLineFeed=False ;
490 _DtTermCursorPos(Widget w) /* CUP CSIp;pH */
492 ParserContext context ;
493 DtTermWidget vtw = (DtTermWidget) w;
495 Debug( 'P', fprintf(stderr,">>In func _DtTermCursorPos\n")) ;
496 context = GetParserContext(w) ;
497 STORELASTARG(context) ;
498 row = context->parms[1] ;
499 col = context->parms[2] ;
502 if (vtw->vt.td->originMode) row += vtw->term.tpd->scrollLockTopRow ;
503 if (row > FLOOR(vtw)) row = FLOOR(vtw) ;
504 if (col > LASTCOLUMN(vtw)) col = LASTCOLUMN(vtw) ;
505 vtw->term.tpd->cursorRow = row ;
506 vtw->term.tpd->cursorColumn = col ;
510 _DtTermEraseDisplay(Widget w) /* ED CSIpJ */
513 DtTermWidget vtw = (DtTermWidget) w;
514 ParserContext context ;
515 DtEraseMode eraseMode;
518 Debug('P', fprintf(stderr,">>In func _DtTermEraseDisplay\n")) ;
519 context = GetParserContext(w) ;
521 STORELASTARG(context) ;
522 row = vtw->term.tpd->cursorRow;
523 col = vtw->term.tpd->cursorColumn ;
526 ** pick the correct erase mode...
528 switch (context->parms[1])
531 eraseMode = eraseToEOB;
534 eraseMode = eraseFromRow0Col0;
537 eraseMode = eraseBuffer;
540 _DtTermFuncEraseInDisplay(w, (int)eraseMode, fromParser);
541 vtw->term.tpd->cursorRow = row;
542 vtw->term.tpd->cursorColumn = col;
546 _DtTermEraseChars(Widget w) /* ECH CSIpX */
548 ParserContext context ;
549 DtTermWidget vtw = (DtTermWidget) w;
551 Debug('P', fprintf(stderr,">>In func _DtTermEraseChars\n")) ;
553 context = GetParserContext(w) ;
554 row = vtw->term.tpd->cursorRow ;
555 col = vtw->term.tpd->cursorColumn ;
556 STORELASTARG(context) ;
557 cnt = context->parms[1] ;
560 if ( cnt > LASTCOLUMN(vtw)-col+1 ) cnt = LASTCOLUMN(vtw)-col+1 ;
562 _DtTermFuncEraseCharacter(w, cnt, fromParser);
566 _DtTermInsertChars(Widget w) /* ICH CSIp@ */
568 DtTermWidget vtw = (DtTermWidget) w;
569 ParserContext context ;
571 DtTermInsertCharMode saveInsertCharMode;
573 Debug('P', fprintf(stderr,">>In func _DtTermInsertChars\n")) ;
575 context = GetParserContext(w) ;
576 vtw->term.tpd->parserNotInStartState = False ;
577 row = vtw->term.tpd->cursorRow ;
578 col = vtw->term.tpd->cursorColumn ;
579 STORELASTARG(context) ;
580 cnt = context->parms[1] ;
584 if (cnt > LASTCOLUMN(vtw) - col + 1)
585 cnt = LASTCOLUMN(vtw) - col + 1;
587 /* save away the insert char mode... */
588 saveInsertCharMode = vtw->term.tpd->insertCharMode;
590 /* turn on insert char mode. We don't want to invoke any status
591 * change callbacks, so we will justs set it directly...
593 vtw->term.tpd->insertCharMode = DtTERM_INSERT_CHAR_ON;
595 /* insert blanks... */
597 (void) _DtTermPrimInsertText(w,(unsigned char *) " ", 1) ;
599 /* restore the insert char mode... */
600 vtw->term.tpd->insertCharMode = saveInsertCharMode;
602 _DtTermPrimCursorMove(w,row,col) ;
606 _DtTermCursorUp(Widget w) /* CUU CISpA */
608 ParserContext context ;
609 DtTermWidget vtw = (DtTermWidget) w;
610 int trow, row, tmargin, cnt;
611 Debug('P', fprintf(stderr,">>In func _DtTermCursorUp\n")) ;
612 context = GetParserContext(w) ;
614 tmargin = TOPMARGIN(vtw) ;
616 STORELASTARG(context) ;
617 cnt = context->parms[1] ;
619 else if (cnt>MAXSHORT) cnt=MAXSHORT-100;
620 row = vtw->term.tpd->cursorRow-cnt;
621 /* are we about the top margin and did we actually cross it? */
622 /* This handles the case top margin == top row */
623 if (row < tmargin && row+cnt >= tmargin) row = tmargin;
624 _DtTermPrimCursorMove(w, row, vtw->term.tpd->cursorColumn) ;
628 _DtTermCursorDown(Widget w) /* CUD CISpB */
630 ParserContext context ;
631 DtTermWidget vtw = (DtTermWidget) w;
632 int bmargin, row, cnt, brow ;
633 Debug('P', fprintf(stderr,">>In func _DtTermCursorDown\n")) ;
634 context = GetParserContext(w) ;
636 bmargin = BOTTOMMARGIN(vtw) ;
637 brow = BOTTOMROW(vtw) ;
638 STORELASTARG(context) ;
639 cnt = context->parms[1] ;
641 row = vtw->term.tpd->cursorRow+cnt;
642 /* are we below bottom margin and did we actually cross it? */
643 /* NOTE that this also handles the case when bmargin == brow */
644 if (row > bmargin && row-cnt <= bmargin) row = bmargin;
645 /* did we start below bottom margin and cross bottom row? */
646 if (row > brow && bmargin < brow ) row = brow;
647 _DtTermPrimCursorMove(w, row, vtw->term.tpd->cursorColumn) ;
651 _DtTermCursorForward(Widget w) /* CUF CISpC */
653 ParserContext context ;
654 DtTermWidget vtw = (DtTermWidget) w;
656 Debug('P', fprintf(stderr,">>In func _DtTermCursorForward\n")) ;
657 context = GetParserContext(w) ;
659 lcol = LASTCOLUMN(vtw) ;
660 STORELASTARG(context) ;
661 cnt = context->parms[1] ;
663 col = vtw->term.tpd->cursorColumn+cnt;
664 if (col>lcol) col=lcol;
665 _DtTermPrimCursorMove(w,vtw->term.tpd->cursorRow,col);
669 _DtTermCursorBack(Widget w) /* CUB CISpD */
671 ParserContext context ;
672 DtTermWidget vtw = (DtTermWidget) w;
673 int i,k,j,row,col,fcol,cnt ;
674 Debug('P', fprintf(stderr,">>In func _DtTermCursorBack\n")) ;
676 context = GetParserContext(w) ;
677 STORELASTARG(context) ;
678 cnt = context->parms[1] ;
679 fcol = FIRSTCOLUMN(vtw) ;
680 row = vtw->term.tpd->cursorRow;
681 col = vtw->term.tpd->cursorColumn;
683 if ((col -= cnt) < 0) {
684 if(vtw->vt.td->reverseWrapMode && vtw->term.tpd->autoWrapRight) {
685 int lastrow = BOTTOMROW(vtw);
686 if (vtw->vt.td->originMode) {
687 row-=TOPMARGIN(vtw) ;
688 lastrow = BOTTOMMARGIN(vtw)-TOPMARGIN(vtw);
690 if((i = (j = LASTCOLUMN(vtw) + 1) * row + col) < 0) {
691 k = j * (lastrow + 1);
692 i += ((-i) / k + 1) * k;
695 if (vtw->vt.td->originMode) row+=TOPMARGIN(vtw);
700 _DtTermPrimCursorMove(w,row,col);
704 _DtTermCursorToLineUp(Widget w) /* CPL CSIpF */
706 DtTermWidget vtw = (DtTermWidget) w;
707 ParserContext context ;
708 Debug('P', fprintf(stderr,">>In func _DtTermCursorToLineUp\n")) ;
710 context = GetParserContext(w) ;
711 vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
716 _DtTermCursorToCol(Widget w) /* CHA CSIpG */
718 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
719 ParserContext context ;
720 context = GetParserContext(w) ;
721 STORELASTARG(context) ;
722 if (!context->parms[1] ) context->parms[1]=1;
723 if (context->parms[1]>tw->term.columns) context->parms[1]=tw->term.columns;
724 tw->term.tpd->cursorColumn = context->parms[1] - BASE ;
728 _DtTermEraseInLine(Widget w) /* EL ESC[pK */
730 DtTermWidget vtw = (DtTermWidget) w;
731 ParserContext context ;
732 DtEraseMode eraseMode;
735 Debug('P', fprintf(stderr,">>In func _DtTermEraseInLine\n")) ;
737 context = GetParserContext(w) ;
738 STORELASTARG(context) ;
740 ** pick the correct erase mode...
742 switch ( context->parms[1] )
745 eraseMode = eraseToEOL;
749 eraseMode = eraseFromCol0;
753 eraseMode = eraseLine;
757 _DtTermFuncEraseInLine(w, (int)eraseMode, fromParser);
761 _DtTermInsertLines(Widget w) /* IL CSIpL */
763 DtTermWidget vtw = (DtTermWidget) w;
764 ParserContext context ;
766 Debug('P', fprintf(stderr,">>In func _DtTermInsertLines\n")) ;
767 if ( vtw->term.tpd->cursorRow < TOPMARGIN(vtw) ||
768 vtw->term.tpd->cursorRow > BOTTOMMARGIN(vtw) )/*outside scrolling region*/
770 context = GetParserContext(w) ;
771 KILLWRAP((DtTermWidget)w) ;
772 STORELASTARG(context) ;
773 cnt=context->parms[1];
775 lines = BOTTOMMARGIN(vtw) - vtw->term.tpd->cursorRow + 1;
776 if (cnt > lines) cnt=lines ;
777 _DtTermFuncInsertLine(w,cnt,fromParser) ;
781 _DtTermDeleteLines(Widget w) /* DL CSIpM */
783 DtTermWidget vtw = (DtTermWidget) w;
784 ParserContext context ;
786 Debug('P', fprintf(stderr,">>In func _DtTermDeleteLines\n")) ;
788 if ( vtw->term.tpd->cursorRow < TOPMARGIN(vtw) ||
789 vtw->term.tpd->cursorRow > BOTTOMMARGIN(vtw) ) /* outside scrolling region*/
791 KILLWRAP((DtTermWidget)w) ;
792 context = GetParserContext(w) ;
793 STORELASTARG(context) ;
794 cnt = context->parms[1];
796 _DtTermFuncDeleteLine(w,cnt,fromParser) ;
800 _DtTermDeleteChars(Widget w) /* DCH CSIpP */
802 ParserContext context ;
803 DtTermWidget vtw = (DtTermWidget) w;
805 Debug('P', fprintf(stderr,">>In func _DtTermDeleteChars\n")) ;
807 context = GetParserContext(w) ;
808 STORELASTARG(context) ;
809 cnt= context->parms[1];
811 else if (cnt>MAXSHORT) cnt=MAXSHORT-100;
812 _DtTermFuncDeleteChar(w,cnt,fromParser) ;
816 _DtTermNextLine(Widget w) /* NEL ESCE */
818 DtTermWidget vtw = (DtTermWidget) w;
820 Debug('P', fprintf(stderr,">>In func _DtTermNextLine\n")) ;
821 vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
822 _DtTermIndex(w) ; /* use IND */
826 _DtTermReverseIndex(Widget w) /* RI ESCM */
828 DtTermWidget vtw = (DtTermWidget) w;
829 int tmargin, trow, col;
830 Debug('P', fprintf(stderr,">>In func _DtTermReverseIndex\n")) ;
833 tmargin = TOPMARGIN(vtw) ;
834 col = vtw->term.tpd->cursorColumn ;
835 if ( vtw->term.tpd->cursorRow == tmargin) {
836 _DtTermFuncInsertLine(w,1,fromParser) ;
837 /* _DtTermFuncInsertLine sets column to first column */
838 vtw->term.tpd->cursorColumn = col ;
840 else if (vtw->term.tpd->cursorRow > trow){
841 vtw->term.tpd->cursorRow-- ;
846 _DtTermIndex(Widget w) /* IND ESCD */
848 DtTermWidget vtw = (DtTermWidget) w;
850 Debug('P', fprintf(stderr,">>In func _DtTermIndex\n")) ;
852 brow = BOTTOMROW(vtw) ;
853 bmargin = BOTTOMMARGIN(vtw) ;
854 if ( vtw->term.tpd->cursorRow == bmargin) {
855 (void) _DtTermPrimScrollText(w, 1);
857 else if (vtw->term.tpd->cursorRow < brow){
858 vtw->term.tpd->cursorRow++ ;
860 (void) _DtTermPrimFillScreenGap(w);
864 _DtTermScrollingRegion(Widget w) /* DECSTBM CSIp;pr */
866 DtTermWidget vtw = (DtTermWidget)w ;
867 ParserContext context ;
869 Debug('P', fprintf(stderr,">>In func _DtTermScrollingRegion\n")) ;
870 context = GetParserContext(w) ;
871 STORELASTARG(context) ;
872 row1 = context->parms[1] ;
873 row2 = context->parms[2] ;
874 if (!row1) row1 = 1 ;
875 if (!row2 || row2>vtw->term.rows) row2 = vtw->term.rows ;
879 if ( row1 == TOPROW(vtw) && row2 == BOTTOMROW(vtw))
880 vtw->term.tpd->memoryLockMode=SCROLL_LOCKoff ;
882 vtw->term.tpd->memoryLockMode=SCROLL_LOCKon ;
883 vtw->term.tpd->scrollLockTopRow = row1 ;
884 vtw->term.tpd->scrollLockBottomRow = row2 ;
885 if (vtw->vt.td->originMode) _DtTermPrimCursorMove(w,row1,0) ;
886 else _DtTermPrimCursorMove(w,0,0) ;
891 _DtTermCharAttributes(Widget w) /* SGR CSIpm */
893 ParserContext context ;
895 Debug('P', fprintf(stderr,">>In func _DtTermCharAttributes\n")) ;
896 context = GetParserContext(w) ;
897 STORELASTARG(context) ;
898 cnt = PCOUNT(context) ;
899 if(PCOUNT(context)) {
900 for (cnt=1; cnt <= PCOUNT(context); cnt++)
901 _DtTermVideoEnhancement(w,context->parms[cnt]) ;
904 _DtTermVideoEnhancement(w,0) ;
908 _DtTermDeviceAttributes(Widget w) /* DA CSIpc */
910 DtTermWidget vtw = (DtTermWidget) w;
911 ParserContext context ;
914 Debug('P', fprintf(stderr,">>In func _DtTermDeviceAttributes\n")) ;
915 context = GetParserContext(w) ;
916 STORELASTARG(context) ;
917 switch(context->parms[1]) {
919 switch(vtw->vt.td->terminalId ) {
921 sprintf(buf,"\033[?%d;%dc",1,2) ;
924 sprintf(buf,"\033[?%d;%dc",1,0) ;
927 sprintf(buf,"\033[?%dc",6) ;
930 /* class 2 terminal (62), 132 columns (1), printer port (2),
931 * selective erase (6), DRCS (7), UDK (8),
932 * national replacement char sets
934 sprintf(buf,"\033[?%d;%d;%d;%d;%d;%d;%dc",62,1,2,6,7,8,9) ;
937 sendEscSequence(w,buf) ;
943 _DtTermChangeTextParam(Widget w) /* xterm CSIp;pcCtrl-G */
945 ParserContext context ;
946 DtTermWidget tw = (DtTermWidget) w;
947 DtTermData vtd = tw->vt.td;
951 Debug('P', fprintf(stderr,">>In func _DtTermChangeTextParam\n")) ;
952 context = GetParserContext(w) ;
954 for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
956 * context->parms[1] is inited to 0, so if no numeric param was entered,
957 * we default appropriately to case 0.
959 switch(context->parms[1]) {
960 case 0: /* change Icon name and Window title */
961 XtSetArg(arg[i], XmNtitle, context->stringParms[0].str); i++;
962 XtSetArg(arg[i], XmNiconName, context->stringParms[0].str); i++;
963 XtSetValues(sw,arg,i) ;
965 case 1: /* change Icon name */
966 XtSetArg(arg[i], XmNiconName, context->stringParms[0].str); i++;
967 XtSetValues(sw,arg,i) ;
969 case 2: /* change Window title */
970 XtSetArg(arg[i], XmNtitle, context->stringParms[0].str); i++;
971 XtSetValues(sw,arg,i) ;
973 case 3: /* change current working directory */
974 tw->term.subprocessCWD = XtRealloc(tw->term.subprocessCWD,
975 strlen((char *) context->stringParms[0].str) + 1);
976 (void) strcpy(tw->term.subprocessCWD,
977 (char *) context->stringParms[0].str);
979 /* These are handled by xterm but not by us.
980 case 46: Change log file to context->stringParms[0]
982 case 50: ** change font to context->stringParms[0]
989 _DtTermTabClear(Widget w) /* TBC CSIpg */
991 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
992 TermBuffer tb = tw->term.tpd->termBuffer ;
993 ParserContext context ;
995 Debug('P', fprintf(stderr,">>In func _DtTermTabClear\n")) ;
996 context = GetParserContext(w) ;
997 STORELASTARG(context) ;
998 type = context->parms[1] ;
1000 case 0:(void)_DtTermPrimBufferClearTab(tb,tw->term.tpd->cursorColumn) ;
1002 case 3: (void)_DtTermPrimBufferClearAllTabs(tb) ;
1008 _DtTermRequestParam(Widget w) /* DECREQTPARM CSIpx */
1010 ParserContext context ;
1013 Debug('P', fprintf(stderr,">>In func _DtTermRequestParam\n")) ;
1014 context = GetParserContext(w) ;
1015 STORELASTARG(context) ;
1016 row = context->parms[1] ;
1020 /* row (?), 1 no parity, 1 eight bits, 112 xmit 9600 baud,
1021 * 112, receive 9600 baud, 1 clock multiplier (?),
1022 * 0 STP flags (?) These are from xterm file 'charproc.c'.
1024 sprintf(buf,"\033[%d;%d;%d;%d;%d;%d;%dx",row,1,1,112,112,1,0) ;
1025 sendEscSequence(w,buf) ;
1031 _DtTermTabSet(Widget w) /* HTS ESCH */
1033 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1034 TermBuffer tb = tw->term.tpd->termBuffer ;
1035 Debug('P', fprintf(stderr,">>In func _DtTermTabSet\n")) ;
1036 (void)_DtTermPrimBufferSetTab(tb,tw->term.tpd->cursorColumn) ;
1040 _DtTermSaveCursor(Widget w) /* DECSC ESC7 */
1042 DtTermWidget vtw = (DtTermWidget) w;
1043 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1044 DtTermBuffer tb = (DtTermBuffer)tw->term.tpd->termBuffer ;
1045 DtTermData vtd = vtw->vt.td;
1047 Debug('P', fprintf(stderr,">>In func _DtTermSaveCursor\n")) ;
1048 vtd->saveCursor.cursorRow = vtw->term.tpd->cursorRow ;
1049 vtd->saveCursor.cursorColumn = vtw->term.tpd->cursorColumn ;
1050 vtd->saveCursor.originMode = vtw->vt.td->originMode ;
1051 /* The following is save at the TermPrim level */
1052 /* vtw->vt.td->saveCursor.wrapMode = */
1053 vtd->saveCursor.enhVideoState = vtd->enhVideoState ;
1054 vtd->saveCursor.enhFieldState = vtd->enhFieldState ;
1055 vtd->saveCursor.enhFgColorState = vtd->enhFgColorState;
1056 vtd->saveCursor.enhBgColorState = vtd->enhBgColorState;
1057 vtd->saveCursor.GL = vtd->GL;
1058 vtd->saveCursor.GR = vtd->GR;
1059 vtd->saveCursor.G0 = vtd->G0;
1060 vtd->saveCursor.G1 = vtd->G1;
1061 vtd->saveCursor.G2 = vtd->G2;
1062 vtd->saveCursor.G3 = vtd->G3;
1063 vtd->saveCursor.singleShiftFont = vtd->singleShiftFont;
1064 vtd->saveCursor.singleShiftPending = vtd->singleShiftPending;
1068 _DtTermRestoreCursor(Widget w) /* DECRC ESC8 */
1070 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1071 DtTermPrimData tpd = tw->term.tpd;
1072 DtTermWidget vtw = (DtTermWidget) w;
1073 DtTermData vtd = vtw->vt.td;
1075 Debug('P', fprintf(stderr,">>In func _DtTermRestoreCursor\n")) ;
1076 tpd->cursorRow = vtd->saveCursor.cursorRow ;
1077 tpd->cursorColumn = vtd->saveCursor.cursorColumn ;
1078 vtw->vt.td->originMode = vtd->saveCursor.originMode ;
1079 tpd->autoWrapRight = vtd->saveCursor.wrapMode ;
1080 vtd->enhVideoState = vtd->saveCursor.enhVideoState ;
1081 vtd->enhFieldState = vtd->saveCursor.enhFieldState ;
1082 vtd->enhFgColorState = vtd->saveCursor.enhFgColorState;
1083 vtd->enhBgColorState = vtd->saveCursor.enhBgColorState;
1084 vtd->GR = vtd->saveCursor.GR;
1085 vtd->GL = vtd->saveCursor.GL;
1086 vtd->G0 = vtd->saveCursor.G0;
1087 vtd->G1 = vtd->saveCursor.G1;
1088 vtd->G2 = vtd->saveCursor.G2;
1089 vtd->G3 = vtd->saveCursor.G3;
1090 vtd->singleShiftFont = vtd->saveCursor.singleShiftFont;
1091 vtd->singleShiftPending = vtd->saveCursor.singleShiftPending;
1092 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1093 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhVideo,
1094 vtd->enhVideoState);
1095 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1096 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhField,
1097 vtd->enhFieldState);
1098 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1099 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhFont,
1101 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1102 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhBgColor,
1103 vtd->saveCursor.enhBgColorState);
1104 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1105 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhFgColor,
1106 vtd->saveCursor.enhFgColorState);
1107 if ( vtd->originMode ) {
1108 if (tpd->cursorRow < tpd->scrollLockTopRow )
1109 tpd->cursorRow = tpd->scrollLockTopRow ;
1110 else if (tpd->cursorRow > tpd->scrollLockBottomRow )
1111 tpd->cursorRow = tpd->scrollLockBottomRow ;
1116 _DtTermAppKeypad(Widget w) /* DECPAM ESC= */
1118 DtTermWidget vtw = (DtTermWidget) w;
1119 Debug('P', fprintf(stderr,">>In func _DtTermAppKeypad\n")) ;
1120 vtw->vt.td->applicationKPMode=True;
1124 _DtTermNormalKeypad(Widget w) /* DECPNM ESC> */
1126 DtTermWidget vtw = (DtTermWidget) w;
1127 Debug('P', fprintf(stderr,">>In func _DtTermNormalKeypad\n")) ;
1128 vtw->vt.td->applicationKPMode=False;
1132 _DtTermS8C1T(Widget w) /* S8C1T ESCG */
1134 DtTermWidget vtw = (DtTermWidget) w;
1135 Debug('P', fprintf(stderr,">>In func _vt8CIT\n")) ;
1136 vtw->vt.td->S8C1TMode=True;
1140 _DtTermS7C1T(Widget w) /* S7C1T ESCF */
1142 DtTermWidget vtw = (DtTermWidget) w;
1143 Debug('P', fprintf(stderr,">>In func _vt8CIT\n")) ;
1144 vtw->vt.td->S8C1TMode=False;
1148 _DtTermSetCompatLevel(Widget w) /* DECSCL CSI p;p"p (last p literal) */
1150 ParserContext context ;
1151 DtTermWidget vtw = (DtTermWidget) w;
1152 Debug('P', fprintf(stderr,">>In func _DtTermSetCompatLevel\n")) ;
1153 context = GetParserContext(w) ;
1154 STORELASTARG(context) ;
1155 vtw->vt.td->compatLevel= 2; /* assume vt200 mode */
1156 switch ( PCOUNT(context) ) {
1157 case 1: switch (context->parms[1]) {
1158 case 61: vtw->vt.td->compatLevel= 1;
1159 vtw->vt.td->S8C1TMode=False;
1161 case 62: vtw->vt.td->S8C1TMode=True;
1165 case 2: switch (context->parms[2]) {
1167 case 2: vtw->vt.td->S8C1TMode=True;
1170 vtw->vt.td->S8C1TMode=False;
1177 _DtTermInvokeG3(Widget w) /* LS3R ESC| */
1179 ParserContext context ;
1181 Debug('P', fprintf(stderr,">>In func _DtTermInvokeG3\n")) ;
1182 context = GetParserContext(w) ;
1186 _DtTermInvokeG2(Widget w) /* LS3R ESC} */
1188 ParserContext context ;
1190 Debug('P', fprintf(stderr,">>In func _DtTermInvokeG2\n")) ;
1191 context = GetParserContext(w) ;
1195 _DtTermScrollUp(Widget w) /* SU CSIpS */
1197 ParserContext context ;
1198 DtTermWidget vtw = (DtTermWidget) w;
1201 Debug('P', fprintf(stderr,">>In func _DtTermScrollUp\n")) ;
1202 #define EXIT_IF_OUTSIDE_SR(w) if((w)->term.tpd->scrollLockTopRow > \
1203 (w)->term.tpd->cursorRow || \
1204 (w)->term.tpd->scrollLockBottomRow < \
1205 (w)->term.tpd->cursorRow) \
1207 EXIT_IF_OUTSIDE_SR(vtw)
1209 context = GetParserContext(w) ;
1210 row = vtw->term.tpd->cursorRow;
1211 col = vtw->term.tpd->cursorColumn;
1212 STORELASTARG(context) ;
1213 if (!context->parms[1])
1214 context->parms[1] = 1;
1215 else if (context->parms[1] > MAXSHORT)
1216 context->parms[1] = MAXSHORT - 100;
1218 /* clip the number of rows to the scroll region... */
1219 if (context->parms[1] > (vtw->term.tpd->scrollLockBottomRow -
1220 vtw->term.tpd->scrollLockTopRow + 1)) {
1221 context->parms[1] = vtw->term.tpd->scrollLockBottomRow -
1222 vtw->term.tpd->scrollLockTopRow + 1;
1225 vtw->term.tpd->cursorRow = TOPMARGIN(vtw) ;
1226 _DtTermFuncDeleteLine(w, context->parms[1], fromParser);
1227 vtw->term.tpd->cursorRow = row;
1228 vtw->term.tpd->cursorColumn = col;
1232 _DtTermScrollDown(Widget w) /* SD CSIpT */
1234 ParserContext context ;
1235 DtTermWidget vtw = (DtTermWidget) w;
1238 Debug('P', fprintf(stderr,">>In func _DtTermScrollDown\n")) ;
1239 EXIT_IF_OUTSIDE_SR(vtw)
1241 context = GetParserContext(w) ;
1242 row = vtw->term.tpd->cursorRow;
1243 col = vtw->term.tpd->cursorColumn ;
1244 STORELASTARG(context) ;
1245 if (!context->parms[1])
1246 context->parms[1] = 1;
1247 else if (context->parms[1] > MAXSHORT)
1248 context->parms[1] = MAXSHORT - 100;
1250 /* clip the number of rows to the scroll region... */
1251 if (context->parms[1] > (vtw->term.tpd->scrollLockBottomRow -
1252 vtw->term.tpd->scrollLockTopRow) + 1) {
1253 context->parms[1] = vtw->term.tpd->scrollLockBottomRow -
1254 vtw->term.tpd->scrollLockTopRow + 1;
1257 vtw->term.tpd->cursorRow = TOPMARGIN(vtw) ;
1258 _DtTermFuncInsertLine(w, context->parms[1], fromParser) ;
1259 vtw->term.tpd->cursorRow = row;
1260 vtw->term.tpd->cursorColumn = col;
1264 _DtTermRestoreModeValues(Widget w) /* xterm - Restore DEC mode values CSI?pr */
1266 ParserContext context ;
1267 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1268 DtTermWidget vtw = (DtTermWidget)w;
1269 DtTermData vtd = vtw->vt.td;
1271 Debug ('P', fprintf(stderr,">>In func _DtTermPModeReset\n")) ;
1272 context = GetParserContext(w) ;
1273 STORELASTARG(context) ;
1274 cnt = PCOUNT(context) ;
1275 for (i=1;i<=cnt;i++) {
1276 switch ( context->parms[i]) {
1278 case 1: /* Cursor key (Normal/Application) */
1279 vtd->applicationMode = vtd->saveDECMode.applicationMode ;
1281 #ifdef NOT_SUPPORTED
1282 case 2: /* set vt52 mode */
1284 #endif /* NOT_SUPPORTED */
1285 case 3: /* Columns (80/132) */
1286 vtd->col132Mode = vtd->saveDECMode.col132Mode ;
1288 case 4: /* Scroll Mode ( jump/smooth ) */
1289 _DtTermPrimScrollComplete(w, True) ;
1290 vtw->term.jumpScroll = vtd->saveDECMode.jumpScrollMode ;
1292 case 5: /* Screen mode */
1293 vtw->term.reverseVideo = vtd->saveDECMode.inverseVideoMode ;
1295 case 6: /* Origin mode (on/off)*/
1296 vtd->originMode = vtd->saveDECMode.originMode ;
1298 case 7: /* Auto wrap (On/Off) */
1299 vtw->term.tpd->autoWrapRight = vtd->saveDECMode.wrapMode ;
1301 case 8: /* Auto repeat (Off) */
1302 /* implemented in the server */
1304 #ifdef NOT_SUPPORTED
1305 case 18: /* Print form feed (Off) */
1307 case 19: /* Print extent (scrolling region) */
1309 #endif /* NOT_SUPPORTED */
1310 case 25: /* Text cursor enable (Off) */
1311 _DtTermPrimSetCursorVisible(w,
1312 vtd->saveDECMode.cursorVisible);
1316 case 40: /* 80/132 mode (disallow/allow) */
1317 vtw->vt.c132 = vtd->saveDECMode.allow80_132ColMode;
1319 case 41: /* curses fix (off/on) */
1320 vtd->fixCursesMode = vtd->saveDECMode.fixCursesMode;
1322 case 44: /* margin bell (off/on) */
1323 vtw->term.marginBell = vtd->saveDECMode.marginBellMode;
1325 case 45: /* Reverse-wraparound mode */
1326 vtd->reverseWrapMode = vtd->saveDECMode.reverseWrapMode ;
1328 case 46: /* logging (stop/start ) */
1329 if (vtd->saveDECMode.logging) {
1330 vtw->term.logging = True ;
1331 _DtTermPrimStartLog(w);
1333 vtw->term.logging = False ;
1334 _DtTermPrimCloseLog(w) ;
1337 #ifdef NOT_SUPPORTED
1338 case 47: /* screen buffer (normal) */
1340 case 1000: /* don't send mouse x and y */
1342 case 1001: /* don't use hilite mouse tracking */
1344 #endif /* NOT_SUPPORTED */
1350 _DtTermSaveModeValues(Widget w) /* xterm - Save DEC mode values CSI?ps */
1352 ParserContext context ;
1353 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1354 DtTermWidget vtw = (DtTermWidget)w;
1355 DtTermData vtd = vtw->vt.td;
1357 Debug ('P', fprintf(stderr,">>In func _DtTermPModeReset\n")) ;
1358 context = GetParserContext(w) ;
1359 STORELASTARG(context) ;
1360 cnt = PCOUNT(context) ;
1361 for (i=1;i<=cnt;i++) {
1362 switch ( context->parms[i]) {
1364 case 1: /* Cursor key (Normal/Application) */
1365 vtd->saveDECMode.applicationMode = vtd->applicationMode ;
1367 #ifdef NOT_SUPPORTED
1368 case 2: /* set vt52 mode */
1370 #endif /* NOT_SUPPORTED */
1371 case 3: /* Columns (80/132) */
1372 vtd->saveDECMode.col132Mode = vtd->col132Mode ;
1374 case 4: /* Scroll Mode ( jump/smooth ) */
1375 vtd->saveDECMode.jumpScrollMode = vtw->term.jumpScroll ;
1377 case 5: /* Screen mode */
1378 vtd->saveDECMode.inverseVideoMode = vtw->term.reverseVideo ;
1380 case 6: /* Origin mode (on/off)*/
1381 vtd->saveDECMode.originMode = vtd->originMode ;
1383 case 7: /* Auto wrap (On/Off) */
1384 vtd->saveDECMode.wrapMode = vtw->term.tpd->autoWrapRight ;
1386 case 8: /* Auto repeat (Off) */
1387 /* implemented in the server */
1389 #ifdef NOT_SUPPORTED
1390 case 18: /* Print form feed (Off) */
1392 case 19: /* Print extent (scrolling region) */
1394 #endif /* NOT_SUPPORTED */
1395 case 25: /* Text cursor enable (Off) */
1396 vtd->saveDECMode.cursorVisible =
1397 _DtTermPrimGetCursorVisible(w);
1400 case 40: /* 80/132 mode (disallow/allow) */
1401 vtd->saveDECMode.allow80_132ColMode = vtw->vt.c132;
1403 case 41: /* curses fix (off/on) */
1404 vtd->saveDECMode.fixCursesMode = vtd->fixCursesMode ;
1406 case 44: /* margin bell (off/on) */
1407 vtd->saveDECMode.marginBellMode = vtw->term.marginBell ;
1409 case 45: /* Reverse-wraparound mode */
1410 vtd->saveDECMode.reverseWrapMode = vtd->reverseWrapMode ;
1412 case 46: /* logging (stop/start ) */
1413 vtd->saveDECMode.logging = vtw->term.logging;
1415 #ifdef NOT_SUPPORTED
1416 case 47: /* screen buffer (normal) */
1418 case 1000: /* don't send mouse x and y */
1420 case 1001: /* don't use hilite mouse tracking */
1422 #endif /* NOT_SUPPORTED */
1429 _DtTermAlignTest(Widget w) /* DECALN ESC#8 */
1431 DtTermWidget vtw = (DtTermWidget) w;
1432 int tlrow, blrow, cnt ;
1433 Debug('P', fprintf(stderr,">>In func _DtTermAlignTest\n")) ;
1434 vtw->term.tpd->parserNotInStartState = False ;
1435 tlrow = vtw->term.tpd->scrollLockTopRow ;
1436 blrow = vtw->term.tpd->scrollLockBottomRow ;
1437 vtw->term.tpd->scrollLockTopRow = TOPROW(w) ; ;
1438 vtw->term.tpd->scrollLockBottomRow = BOTTOMROW(vtw) ;
1439 cnt = (BOTTOMROW(vtw)+BASE)*(LASTCOLUMN(vtw)+BASE);
1440 vtw->term.tpd->cursorColumn = FIRSTCOLUMN(w) ;
1441 vtw->term.tpd->cursorRow = TOPROW(w) ;
1442 while(cnt--) _DtTermPrimInsertText(w,(unsigned char *) "E", 1) ;
1443 vtw->term.tpd->scrollLockTopRow = tlrow ;
1444 vtw->term.tpd->scrollLockBottomRow = blrow ;
1445 vtw->term.tpd->cursorRow = CEILING(vtw) ;
1446 vtw->term.tpd->cursorColumn = FIRSTCOLUMN(w) ;
1450 _DtTermInvokeG1(Widget w) /* ESC~ESC */
1452 ParserContext context ;
1454 Debug('P', fprintf(stderr,">>In func _DtTermInvokeG1\n")) ;
1455 context = GetParserContext(w) ;
1459 _DtTermSelEraseInLine(Widget w) /* DECSEL ESC?pK */
1461 DtTermWidget vtw = (DtTermWidget) w;
1462 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1463 TermBuffer tb = tw->term.tpd->termBuffer ;
1464 DtTermPrimData tpd = tw->term.tpd;
1465 DtTermData td = vtw->vt.td;
1466 ParserContext context ;
1468 int c,col1,col2,col,row ;
1470 DtTermInsertCharMode saveInsertCharMode;
1472 Debug('P', fprintf(stderr,">>In func _DtTermSelEraseInLine\n")) ;
1474 context = GetParserContext(w) ;
1475 STORELASTARG(context) ;
1476 col1 = FIRSTCOLUMN(vtw) ;
1477 col2 = LASTCOLUMN(vtw) ;
1478 switch ( context->parms[1] ) {
1480 col1= tpd->cursorColumn;
1483 col2 = tpd->cursorColumn;
1490 /* save away the current cursor position... */
1491 col = tpd->cursorColumn ;
1492 row = tpd->cursorRow ;
1494 /* save away the current insert mode... */
1495 saveInsertCharMode = vtw->term.tpd->insertCharMode;
1497 /* insert char needs to be off... */
1498 tpd->insertCharMode = DtTERM_INSERT_CHAR_OFF;
1500 tpd->parserNotInStartState = False ;
1504 (void)_DtTermPrimBufferGetEnhancement(tb, tpd->cursorRow,
1505 c, &evalues, &cnt, countAll);
1508 if (evalues[(int)enhField] == FIELD_UNPROTECT) {
1509 (void) _DtTermPrimBufferSetEnhancement(tb, tpd->cursorRow,
1510 c, enhVideo, evalues[(int)enhVideo]);
1511 (void) _DtTermPrimBufferSetEnhancement(tb, tpd->cursorRow,
1512 c, enhFgColor, evalues[(int)enhFgColor]);
1513 (void) _DtTermPrimBufferSetEnhancement(tb, tpd->cursorRow,
1514 c, enhBgColor, evalues[(int)enhBgColor]);
1515 while ((c <= col2) && cnt--) {
1516 tpd->cursorColumn = c;
1517 (void) _DtTermPrimInsertText(w, (unsigned char *) " ", 1);
1525 /* restore the insert char mode... */
1526 tpd->insertCharMode = saveInsertCharMode;
1528 /* restore the cursor position... */
1529 tpd->cursorColumn = col;
1530 tpd->cursorRow = row;
1532 /* restore the current enhancement state... */
1533 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1534 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhVideo,
1536 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1537 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhFgColor,
1538 td->enhFgColorState);
1539 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1540 tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhBgColor,
1541 td->enhBgColorState);
1545 _DtTermSelEraseInDisplay(Widget w) /* DECSED ESC?pJ */
1547 DtTermWidget vtw = (DtTermWidget) w;
1548 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1549 TermBuffer tb = tw->term.tpd->termBuffer ;
1550 ParserContext context ;
1552 int r,col1,col2,row1,row2,col,row ;
1554 Debug('P', fprintf(stderr,">>In func _DtTermSelEraseInDisplay\n")) ;
1556 context = GetParserContext(w) ;
1557 STORELASTARG(context) ;
1558 col1 = FIRSTCOLUMN(vtw) ;
1559 row1 = TOPROW(vtw) ;
1560 col2 = LASTCOLUMN(vtw) ;
1561 row2 = BOTTOMROW(vtw) ;
1562 switch ( context->parms[1] ) {
1563 case 0: col1= vtw->term.tpd->cursorColumn;
1564 row1 = vtw->term.tpd->cursorRow;
1566 case 1: col2 = vtw->term.tpd->cursorColumn;
1567 row2 = vtw->term.tpd->cursorRow;
1572 col = vtw->term.tpd->cursorColumn;
1573 row = vtw->term.tpd->cursorRow;
1574 vtw->term.tpd->cursorColumn = col1 ;
1575 vtw->term.tpd->cursorRow = row1;
1576 context->workingNum = 0 ; /* erase to the end of line */
1577 _DtTermSelEraseInLine(w) ;
1578 context->workingNum = 2 ; /* erase the whole row */
1579 for ( r=row1+1; r<row2; r++) {
1580 vtw->term.tpd->cursorRow = r;
1581 _DtTermSelEraseInLine(w) ;
1583 vtw->term.tpd->cursorColumn = col2 ;
1584 vtw->term.tpd->cursorRow = row2;
1585 context->workingNum = 2 ; /* erase the beginning of the line */
1586 _DtTermSelEraseInLine(w) ;
1587 vtw->term.tpd->cursorColumn = col ;
1588 vtw->term.tpd->cursorRow = row;
1593 _DtTermSingleShiftG2(Widget w) /* SS2 ESCN */
1595 DtTermWidget vtw = (DtTermWidget) w;
1596 DtTermData vtd = vtw->vt.td;
1598 Debug('P', fprintf(stderr,">>In func _DtTermSingleShiftG2\n")) ;
1599 vtd->singleShiftPending = True;
1600 vtd->singleShiftFont = vtd->G2;
1604 _DtTermSingleShiftG3(Widget w) /* SS3 ESCO */
1606 DtTermWidget vtw = (DtTermWidget) w;
1607 DtTermData vtd = vtw->vt.td;
1609 Debug('P', fprintf(stderr,">>In func _DtTermSingleShiftG3\n")) ;
1610 vtd->singleShiftPending = True;
1611 vtd->singleShiftFont = vtd->G3;
1615 _DtTermLoadCharSet(Widget w) /* vt220 DCS - download char set ESCPpST */
1617 /* we're not implementing this */
1620 /*********************************************************************
1621 * The next 3 functions handle the user key string loading
1622 * DCS Pc;Pl | Ky1/st1;ky2/st2;...kyn/stn ST
1625 _DtTermParseUserKeyClear(Widget w) /* vt220 DECUDK clear function keys*/
1627 DtTermWidget vtw = (DtTermWidget) w;
1628 DtTermData vtd = vtw->vt.td;
1629 ParserContext context ;
1630 Debug('P', fprintf(stderr,">>In func _DtTermLoadSoftKey\n")) ;
1631 context = GetParserContext(w) ;
1632 STORELASTARG(context) ;
1633 if ( !vtd->userKeysLocked )
1635 vtd->needToLockUserKeys = False ;
1636 if (context->parms[1] == 0)
1637 _DtTermFunctionKeyClear(w) ;
1638 if (context->parms[0] == 2 && context->parms[2] == 0)
1639 vtd->needToLockUserKeys = True ;
1641 _DtTermClearParam(w) ;
1644 _DtTermParseUserKeyLoad(Widget w) /* vt220 DECUDK load function string */
1646 DtTermWidget vtw = (DtTermWidget) w;
1647 DtTermData vtd = vtw->vt.td;
1648 ParserContext context ;
1649 Debug('P', fprintf(stderr,">>In func _DtTermLoadSoftKey\n")) ;
1650 context = GetParserContext(w) ;
1651 STORELASTARG(context) ;
1652 if ( !vtd->userKeysLocked)
1654 context->stringParms[0].str[context->stringParms[0].length/2] =
1655 (unsigned char)0 ; /* Null terminate */
1656 _DtTermFunctionKeyStringStore(w,context->parms[1],
1657 (char *)context->stringParms[0].str);
1659 _DtTermClearParam(w) ;
1663 _DtTermParseUserKeyLoadLast(Widget w) /* vt220 DECUDK load function string */
1665 DtTermWidget vtw = (DtTermWidget) w;
1666 DtTermData vtd = vtw->vt.td;
1667 _DtTermParseUserKeyLoad(w);
1668 if (vtd->needToLockUserKeys) vtd->userKeysLocked = True ;
1669 vtd->needToLockUserKeys = False ;
1673 _DtTermParseHexDigit(Widget w) /* vt220 DECUDK store hex digit*/
1675 ParserContext context ;
1676 int ci, left_byte, i;
1678 Debug('P', fprintf(stderr,">>In func _DtTermLoadSoftKey\n")) ;
1679 context = GetParserContext(w) ;
1680 if ( (int)context->stringParms[0].length < 2*STR_SIZE-1 ) {
1681 /* fold the hex digits into characters */
1682 i = context->stringParms[0].length ;
1683 cbuf[0] = *context->inputChar ;
1685 sscanf(cbuf,"%x",&ci) ;
1687 left_byte = (i+1)%2 ;
1690 context->stringParms[0].str[i] = c<<4 ;
1692 context->stringParms[0].str[i] |= c & 0x0F ;
1693 context->stringParms[0].length++ ;
1698 _DtTermReset(Widget w) /* RIS ESCc */
1700 ParserContext context ;
1702 Debug('P', fprintf(stderr,">>In func _DtTermReset\n")) ;
1703 context = GetParserContext(w) ;
1704 _DtTermFuncHardReset(w,0 ,fromParser) ;
1708 _DtTermSelectG2(Widget w) /* LS2 ESCn */
1710 DtTermWidget vtw = (DtTermWidget)w ;
1711 DtTermData vtd = vtw->vt.td;
1712 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1713 DtTermPrimData tpd = tw->term.tpd;
1715 Debug('P', fprintf(stderr,">>In func _DtTermSelectG2\n")) ;
1718 vtd->enhFontState = *vtd->GL;
1719 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1720 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1721 enhFont, vtd->enhFontState);
1725 _DtTermSelectG3(Widget w) /* LS3 ESCo */
1727 DtTermWidget vtw = (DtTermWidget)w ;
1728 DtTermData vtd = vtw->vt.td;
1729 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1730 DtTermPrimData tpd = tw->term.tpd;
1732 Debug('P', fprintf(stderr,">>In func _DtTermSelectG3\n")) ;
1734 vtd->enhFontState = *vtd->GL;
1735 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1736 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1737 enhFont, vtd->enhFontState);
1741 _DtTermParseStatus(Widget w) /* DECID (same as DA) ESCZ */
1743 _DtTermDeviceAttributes(w) ;
1747 _DtTermSetCharEraseMode(Widget w) /* DECSCA ESCp"q */
1749 DtTermWidget vtw = (DtTermWidget) w;
1750 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1751 DtTermPrimData tpd = tw->term.tpd;
1752 ParserContext context ;
1753 Debug('P', fprintf(stderr,">>In func _DtTermSetCharEraseMode\n")) ;
1754 context = GetParserContext(w) ;
1755 STORELASTARG(context) ;
1756 switch ( context->parms[1] ) {
1757 case 0: /* set back to default which is unprotect */
1760 vtw->vt.td->enhFieldState = FIELD_UNPROTECT;
1761 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1762 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1763 enhField, vtw->vt.td->enhFieldState);
1766 vtw->vt.td->enhFieldState = FIELD_PROTECT;
1767 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1768 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1769 enhField, vtw->vt.td->enhFieldState);
1775 _DtTermSingleWide(Widget w) /* DECSWL ESC#5 */
1777 ParserContext context ;
1779 Debug('P', fprintf(stderr,">>In func _DtTermSingleWide\n")) ;
1780 context = GetParserContext(w) ;
1784 _DtTermDoubleWide(Widget w) /* DECDWL ESC#6 */
1786 ParserContext context ;
1788 Debug('P', fprintf(stderr,">>In func _DtTermDoubleWide\n")) ;
1789 context = GetParserContext(w) ;
1793 _DtTermDoubleHigh(Widget w) /* DECWHL ESC#4 */
1795 ParserContext context ;
1797 Debug('P', fprintf(stderr,">>In func _DtTermDoubleHigh\n")) ;
1798 context = GetParserContext(w) ;
1802 _DtTermParseFontG0(Widget w)
1804 DtTermWidget vtw = (DtTermWidget)w ;
1805 DtTermData vtd = vtw->vt.td;
1806 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1807 DtTermPrimData tpd = tw->term.tpd;
1808 ParserContext context ;
1809 context = GetParserContext(w) ;
1811 Debug('P', fprintf(stderr,">>In func _DtTermParseFontG0\n")) ;
1812 switch (*context->inputChar) {
1814 vtd->G0 = FONT_NORMAL;
1818 vtd->G0 = FONT_LINEDRAW;
1822 vtd->enhFontState = *vtd->GL;
1823 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1824 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1825 enhFont, vtd->enhFontState);
1829 _DtTermParseFontG1(Widget w)
1831 DtTermWidget vtw = (DtTermWidget)w ;
1832 DtTermData vtd = vtw->vt.td;
1833 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1834 DtTermPrimData tpd = tw->term.tpd;
1835 ParserContext context ;
1836 context = GetParserContext(w) ;
1838 Debug('P', fprintf(stderr,">>In func _DtTermParseFontG1\n")) ;
1839 switch (*context->inputChar) {
1841 vtd->G1 = FONT_NORMAL;
1845 vtd->G1 = FONT_LINEDRAW;
1849 vtd->enhFontState = *vtd->GL;
1850 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1851 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1852 enhFont, vtd->enhFontState);
1856 _DtTermParseFontG2(Widget w)
1858 DtTermWidget vtw = (DtTermWidget)w ;
1859 DtTermData vtd = vtw->vt.td;
1860 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1861 DtTermPrimData tpd = tw->term.tpd;
1862 ParserContext context ;
1863 context = GetParserContext(w) ;
1865 Debug('P', fprintf(stderr,">>In func _DtTermParseFontG1\n")) ;
1866 switch (*context->inputChar) {
1868 vtd->G2 = FONT_NORMAL;
1872 vtd->G2 = FONT_LINEDRAW;
1876 vtd->enhFontState = *vtd->GL;
1877 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1878 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1879 enhFont, vtd->enhFontState);
1883 _DtTermParseFontG3(Widget w)
1885 DtTermWidget vtw = (DtTermWidget)w ;
1886 DtTermData vtd = vtw->vt.td;
1887 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1888 DtTermPrimData tpd = tw->term.tpd;
1889 ParserContext context ;
1890 context = GetParserContext(w) ;
1892 Debug('P', fprintf(stderr,">>In func _DtTermParseFontG1\n")) ;
1893 switch (*context->inputChar) {
1895 vtd->G3 = FONT_NORMAL;
1899 vtd->G3 = FONT_LINEDRAW;
1903 vtd->enhFontState = *vtd->GL;
1904 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1905 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1906 enhFont, vtd->enhFontState);
1910 _DtTermParseFontShift(Widget w) /* Ctrl-E Ctrl-F */
1912 DtTermWidget vtw = (DtTermWidget)w ;
1913 DtTermData vtd = vtw->vt.td;
1914 DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1915 DtTermPrimData tpd = tw->term.tpd;
1916 ParserContext context ;
1917 context = GetParserContext(w) ;
1919 Debug('P', fprintf(stderr,">>In func _DtTermParseFontShift\n")) ;
1920 switch (*context->inputChar) {
1932 vtd->enhFontState = *vtd->GL;
1933 (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1934 tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1935 enhFont, vtd->enhFontState);
1939 _DtTermParseTab(Widget w) /* Crtl-I */
1941 DtTermWidget vtw = (DtTermWidget)w ;
1942 Debug('P', fprintf(stderr,">>In func _DtTermParseTab\n")) ;
1943 if (vtw->term.tpd->cursorColumn > LASTCOLUMN(vtw)) {
1944 if (vtw->vt.td->fixCursesMode) {
1945 (void) _DtTermNextLine(w);
1946 (void) _DtTermFuncTab(w, 1, fromParser);
1948 /* we already tabbed to the end of the line, so do nothing... */
1951 (void) _DtTermFuncTab(w, 1, fromParser);
1957 _DtTermParseLF /* LineFeed (LF) or newline (NL) Ctrl-J,
1958 Vertical Tab Ctrl-K, Form Feed (NP) Ctrl-L */
1963 DtTermWidget vtw = (DtTermWidget)w ;
1964 Debug('P', fprintf(stderr,">>In func _vtParseLR\n")) ;
1966 if (vtw->term.tpd->cursorRow == BOTTOMMARGIN(vtw))
1969 ** scroll one line...
1971 (void) _DtTermPrimScrollText(w, 1);
1972 vtw->term.tpd->cursorRow = BOTTOMMARGIN(vtw);
1975 if (!(vtw->term.tpd->cursorRow == BOTTOMROW(vtw))) {
1976 vtw->term.tpd->cursorRow++ ;
1979 (void) _DtTermPrimFillScreenGap(w);
1981 if (vtw->term.tpd->autoLineFeed )
1982 _DtTermPrimParseCR(w);
1986 _DtTermSoftReset /* DECSTR ESC!p */
1991 Debug('P', fprintf(stderr,">>In func _DtTermSoftReset\n")) ;
1992 _DtTermFuncSoftReset(w,0 ,fromParser) ;
1996 _DtTermParseBackspace /* Ctrl-H */
2001 ParserContext context ;
2002 DtTermWidget vtw = (DtTermWidget) w;
2003 int row,col,fcol,cnt ;
2004 Debug('P', fprintf(stderr,">>In func _DtTermParseBackspace\n")) ;
2005 context = GetParserContext(w) ;
2006 fcol = FIRSTCOLUMN(vtw) ;
2007 row = vtw->term.tpd->cursorRow;
2008 col = vtw->term.tpd->cursorColumn;
2011 if (vtw->vt.td->reverseWrapMode) {
2012 if ( --row < TOPROW(vtw)) row = BOTTOMROW(vtw);
2013 if (vtw->vt.td->originMode && row < TOPMARGIN(vtw))
2014 row =BOTTOMMARGIN(vtw);
2015 col = LASTCOLUMN(vtw) ;
2021 vtw->term.tpd->cursorRow = row;
2022 vtw->term.tpd->cursorColumn = col;
2036 Window parentReturn;
2037 Window *childrenReturn;
2038 unsigned int nChildrenReturn;
2044 unsigned int widthReturn;
2045 unsigned int heightReturn;
2046 unsigned int topWidthReturn;
2047 unsigned int topHeightReturn;
2048 unsigned int borderWidthReturn;
2049 unsigned int depthReturn;
2056 if (XmIsMotifWMRunning(w)) {
2057 /* get the window we want to figure the offsets for... */
2058 topWindow = XtWindow(w);
2060 /* and the display involved... */
2061 display = XtDisplay(w);
2063 (void) XQueryTree(display, topWindow, &rootWindow, &parentReturn,
2064 &childrenReturn, &nChildrenReturn);
2065 (void) XFree(childrenReturn);
2067 /* walk up the tree until the parent window is root... */
2068 while (parentReturn != rootWindow) {
2069 topWindow = parentReturn;
2070 (void) XQueryTree(display, topWindow, &rootWindow,
2071 &parentReturn, &childrenReturn, &nChildrenReturn);
2072 (void) XFree(childrenReturn);
2075 /* we now know what our top window is. translate our upper
2076 * left corner relative to its upper left corner...
2078 (void) XTranslateCoordinates(display, XtWindow(w), topWindow,
2079 0, 0, &destXReturn, &destYReturn, &childReturn);
2080 *xOffset = destXReturn;
2081 *yOffset = destYReturn;
2083 /* now that we know the top window, we can figure out the size
2084 * difference between the two windows...
2086 (void) XGetGeometry(display, topWindow, &rootWindow,
2087 &destXReturn, &destYReturn, &topWidthReturn,
2088 &topHeightReturn, &borderWidthReturn, &depthReturn);
2090 (void) XGetGeometry(display, XtWindow(w), &rootWindow,
2091 &destXReturn, &destYReturn, &widthReturn, &heightReturn,
2092 &borderWidthReturn, &depthReturn);
2094 *widthOffset = topWidthReturn - widthReturn;
2095 *heightOffset = topHeightReturn - heightReturn;
2100 _DtTermParseSunMisc /* Misc sun esc seqs */
2105 ParserContext context ;
2106 DtTermWidget vtw = (DtTermWidget) w;
2107 Display *display = XtDisplay(w);
2108 int i, scr_num = XScreenNumberOfScreen(XtScreen(w));
2109 Window win = XtWindow(w);
2112 XWindowChanges values;
2117 Dimension height,width;
2118 char *fmt,*s,*title,*icon;
2124 context = GetParserContext(w) ;
2125 STORELASTARG(context) ;
2127 for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2128 sh_win = XtWindow(sw) ;
2129 switch (context->parms[1])
2132 XMapWindow(display,sh_win);
2135 XIconifyWindow(display,sh_win,scr_num);
2138 (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2141 (void) XMoveWindow(display, sh_win,
2142 context->parms[2] + xOffset, context->parms[3] + yOffset);
2144 (void) XtVaSetValues(sw, XmNx, context->parms[2] + xOffset,
2145 XmNy, context->parms[3] + yOffset, NULL);
2148 (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2150 (void) XtVaSetValues(sw, XmNwidth, context->parms[3] - widthOffset,
2151 XmNheight,context->parms[2] - heightOffset, NULL);
2154 XRaiseWindow(display,sh_win);
2157 XLowerWindow(display,sh_win);
2160 _DtTermPrimFuncRedrawDisplay(w, 1, fromParser);
2163 rows = context->parms[2];
2164 columns = context->parms[3];
2165 (void) XtVaSetValues(w, DtNrows, rows, DtNcolumns, columns, NULL);
2168 if (vtw->term.tpd->windowMapped)
2169 sendEscSequence(w,"\033[1t") ;
2171 sendEscSequence(w,"\033[2t") ;
2174 (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2176 (void) XtVaGetValues(sw, XtNx, &x, XtNy, &y, NULL);
2177 (void) sprintf(buf, "\033[3;%d;%dt", x - xOffset, y - yOffset);
2178 (void) sendEscSequence(w, buf);
2181 (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2183 (void) XtVaGetValues(sw, XtNheight, &height, XtNwidth, &width, NULL);
2184 (void) sprintf(buf,"\033[4;%d;%dt", height + heightOffset,
2185 width + widthOffset);
2186 (void) sendEscSequence(w, buf);
2189 (void) XtVaGetValues(w, DtNrows, &rows, DtNcolumns, &columns, NULL);
2190 (void) sprintf(buf, "\033[8;%hd;%hdt", rows, columns);
2191 (void) sendEscSequence(w, buf);
2194 XtVaGetValues(sw,XmNiconName, &icon, NULL);
2195 fmt = "\033]L%s\033\\";
2196 if (strlen(icon) + strlen(fmt) + 1 >= sizeof(buf))
2197 s = XtMalloc(strlen(icon) + strlen(fmt) + 1);
2200 sprintf(s, "%s", fmt);
2201 sendEscSequence(w,s) ;
2202 if (s != buf) XtFree(s);
2205 XtVaGetValues(sw,XmNtitle, &title, NULL);
2206 fmt = "\033]l%s\033\\";
2207 if (strlen(icon) + strlen(fmt) + 1 >= sizeof(buf))
2208 s = XtMalloc(strlen(icon) + strlen(fmt) + 1);
2211 sprintf(s, "%s", fmt);
2212 sendEscSequence(w,s) ;
2213 if (s != buf) XtFree(s);
2219 _DtTermParserSunWindowIcon( Widget w) /* sun set icon label */
2221 ParserContext context ;
2223 context = GetParserContext(w) ;
2224 for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2225 XtVaSetValues(sw, XmNiconName, context->stringParms[0].str, NULL) ;
2229 _DtTermParserSunWindowTitle /* Sun set title name */
2234 ParserContext context ;
2236 context = GetParserContext(w) ;
2237 for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2238 XtVaSetValues(sw,XmNtitle, context->stringParms[0].str, NULL) ;
2242 _DtTermParserSunIconFile(Widget w) /* Sun set icon to pixmap in file */
2245 (DtTermBuffer)((DtTermPrimitiveWidget)w)->term.tpd->termBuffer ;
2246 ParserContext context ;
2251 context = GetParserContext(w) ;
2252 for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2253 XtVaGetValues(sw, XtNforeground, &fg, XtNbackground, &bg, NULL);
2254 icon = XmGetPixmap(XtScreen(sw),(char *)context->stringParms[0].str,fg,bg);
2255 if (icon != XmUNSPECIFIED_PIXMAP)
2256 XtVaSetValues(sw, XmNiconPixmap, icon, NULL);