cde/lib/DtTerm/Term/TermParse.c

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   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)
  10  * any later version.
  11  *
  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
  16  * details.
  17  *
  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
  22  */
  23 #ifndef lint
  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 */
  27 #endif  /* lint */
  28
  29 /*                                                                      *
  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.                                          *
  37  */
  38
  39 #include "TermHeader.h"
  40 #include "TermPrimDebug.h"
  41 #include "TermPrimP.h"
  42 #include "TermPrimI.h"
  43 #include "TermP.h"
  44 #include "TermPrimData.h"
  45 #include "TermData.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"
  53
  54 #if defined (__hpux)
  55 /*
  56  * On HP MAXINT is defined in both <values.h> and <sys/param.h>
  57  */
  58 #undef MAXINT
  59 #endif
  60 #if defined(CSRG_BASED)
  61 #define MAXSHORT SHRT_MAX
  62 #else
  63 #include  <values.h>
  64 #endif
  65
  66 #if defined(USL) || defined(__uxp__)
  67 #include <ctype.h>
  68 #include <wctype.h>
  69 #endif
  70
  71 /*****************************************************************************/
  72
  73 #define NPARAM  16
  74 #define PCOUNT(c)  ((c)->parms[0])
  75 #define BASE   1   /* row and column count base 0 or 1 */
  76
  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
  80  *
  81  *  These defines need to account of for Origin mode eventually  TMH */
  82
  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:\
  91                                              BOTTOMROW(w))
  92 #define CEILING(w)  ((w)->vt.td->originMode?(w)->term.tpd->scrollLockTopRow:\
  93                                              TOPROW(w))
  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
  97
  98 /******************************************************************
  99  *   Upon entering a parse routine the parameter count is contained
 100  *   in  context->parms[0].
 101  *
 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]}
 105  *                    .
 106  *                    .
 107  *
 108  *   First parameter is in  context->parms[1]
 109  *
 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
 113  *   silently.
 114  *******************************************************************/
 115
 116 void
 117 _DtTermClearParam(Widget w)
 118 {
 119     ParserContext context ;
 120     context = GetParserContext(w) ;
 121
 122     PCOUNT(context)=0 ;
 123     _DtTermPrimParserClearParm(w) ;
 124     _DtTermPrimParserClrStrParm(w) ;
 125 }
 126
 127 void
 128 _DtTermEnterNum(Widget w)
 129 {
 130   ParserContext context ;
 131   context = GetParserContext(w) ;
 132   _DtTermPrimParserEnterNum(w) ;
 133   if (!PCOUNT(context)) PCOUNT(context)++ ; /* increment for first number ONLY*/
 134 }
 135
 136 void
 137 _DtTermParsePushNum(Widget w)
 138 {
 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)) ;
 144      }
 145   else {
 146    if (!PCOUNT(context)) PCOUNT(context)++ ;/* increment for first number ONLY*/
 147   }
 148
 149   if ( ++PCOUNT(context)>NPARAM ) {
 150     Debug('P',fprintf(stderr,">>Too many parameters\n")) ;
 151     return ;
 152   }
 153 }
 154
 155 void
 156 _DtTermSaveChar(Widget w)
 157 {
 158   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
 159   ParserContext context ;
 160   wchar_t c;
 161   context = GetParserContext(w) ;
 162
 163   mbtowc(&c,(char *)context->inputChar,MB_CUR_MAX);
 164   if ( context->stringParms[0].length < STR_SIZE && iswprint(c) ) {
 165       strncpy( (
 166          (char *)&context->stringParms[0].str[context->stringParms[0].length]),
 167                 (char *)context->inputChar, context->inputCharLen) ;
 168    context->stringParms[0].length += context->inputCharLen ;
 169   }
 170 }
 171
 172 void
 173 _DtTermPrintState(Widget w)
 174 {
 175   ParserContext context ;
 176   context = GetParserContext(w) ;
 177   /* fprintf(stderr,"Warning: Not a valid escape sequence\n") ;*/
 178   context->stateTable =  _DtTermStateStart ;
 179   _DtTermClearParam(w) ;
 180 }
 181
 182 /* a utility for checking for S8C1TMode */
 183 static void
 184 sendEscSequence(Widget w, char *transmitString)
 185 {
 186     DtTermWidget    tw  = (DtTermWidget)w;
 187     DtTermData      td = tw->vt.td;
 188
 189     if ( td->S8C1TMode ) {
 190            char *cbuf =malloc(strlen(transmitString)+1);
 191            strcpy(cbuf,transmitString) ;
 192            cbuf[1] = 0x9B ;
 193            (void) _DtTermPrimSendInput(w, (unsigned char *) (cbuf+1),
 194                 strlen(cbuf+1));
 195            free(cbuf) ;
 196          }
 197         else {
 198            (void) _DtTermPrimSendInput(w, (unsigned char *) transmitString,
 199                 strlen(transmitString));
 200         }
 201 }
 202
 203 void
 204 _DtTermDeviceStatus(Widget w)     /* DSR CSI?pn  */
 205 {
 206   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
 207   DtTermData vtd = ((DtTermWidget)w)->vt.td;
 208   ParserContext context ;
 209   char buf[100] ;
 210   int col,cnt ;
 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") ;
 217              break;
 218      case 25: /* User defined keys locked?  */
 219              if ( vtd->userKeysLocked )
 220                 sendEscSequence(w,"\033[?21n") ;
 221              else
 222                 sendEscSequence(w,"\033[?20n") ;
 223              break;
 224      case 26: /* keyboard status - always send North American */
 225              sendEscSequence(w,"\033[?27;1n") ;
 226              break;
 227   }
 228 }
 229
 230 void
 231 _DtTermDeviceStatusAnsi(Widget w)     /* DSR CSIpn  */
 232 {
 233   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
 234   DtTermData vtd = ((DtTermWidget)w)->vt.td;
 235   ParserContext context ;
 236   char buf[100] ;
 237   int row,col,cnt ;
 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") ;
 244              break;
 245      case 6:
 246        /* cursor could be past last row (for autowrap) */
 247        if ((col=tw->term.tpd->cursorColumn)>LASTCOLUMN(tw))
 248                      col=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) ;
 253        break ;
 254   }
 255 }
 256
 257 void
 258 _DtTermPModeSet(Widget w)   /*  DECSET CSI?ph */
 259 {
 260   ParserContext context ;
 261   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
 262   DtTermWidget vtw = (DtTermWidget)w;
 263   int i,cnt ;
 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]) {
 270           /* from vt220 */
 271           case 1: /* Cursor key (Application) */
 272                   vtw->vt.td->applicationMode=True;
 273                   break;
 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 ;
 284                   }
 285                   break;
 286           case 4: /* Scroll (smooth) */
 287                   _DtTermPrimScrollComplete(w, True) ;
 288                   vtw->term.jumpScroll = False ;
 289                   break;
 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),
 295                         0, 0, 0, 0, True);
 296                   break;
 297           case 6: /* Origin mode (On) */
 298                   vtw->vt.td->originMode=True;
 299                   _DtTermPrimCursorMove(w, TOPMARGIN(vtw), 0);
 300                   break;
 301           case 7: /* Auto wrap (On) */
 302                   vtw->term.tpd->autoWrapRight=True ;
 303                   break;
 304           /* case 8: ** Auto repeat (On)
 305            *      ** This is handled by the X server
 306            *      break;
 307            *
 308            * case 18: ** Print form feed (On)
 309            *      break;
 310            * case 19: ** Print extent (full screen)
 311            *      break;
 312            */
 313           case 25: /* Text cursor enable (On) */
 314                   (void) _DtTermPrimSetCursorVisible(w, True);
 315                   break;
 316            /* from xterm */
 317           case 40: /*  80/132 mode  (allow) */
 318                   vtw->vt.c132 = True ;
 319                   break;
 320           case 41: /*  curses fix */
 321                   vtw->vt.td->fixCursesMode = True ;
 322                   break;
 323           case 44: /* margin bell (on) */
 324                   vtw->term.marginBell = True ;
 325                   break;
 326           case 45: /* Reverse-wraparound mode */
 327                   vtw->vt.td->reverseWrapMode=True;
 328                   break;
 329           case 46: /* logging (start)  */
 330                   vtw->term.logging = True ;
 331                   _DtTermPrimStartLog(w);
 332                   break;
 333           /*  case 47: ** screen buffer (alternate)
 334            *      break;
 335            *  case 1000: ** Send mouse x and y
 336            *      break;
 337            *  case 1001: ** Use hilite mouse tracking
 338            *      break;
 339            */
 340       }
 341    }
 342 }
 343
 344
 345 void
 346 _DtTermPModeReset(Widget w)   /* DECRST CSI?pl */
 347 {
 348   ParserContext context ;
 349   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
 350   DtTermWidget vtw = (DtTermWidget)w;
 351   int i,cnt ;
 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]) {
 358           /* from vt220 */
 359           case 1: /* Cursor key (Normal) */
 360                   vtw->vt.td->applicationMode=False;
 361                   break;
 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 ;
 372                   }
 373                   break;
 374           case 4: /* Scroll (jump) */
 375                   _DtTermPrimScrollComplete(w, True) ;
 376                   vtw->term.jumpScroll = True ;
 377                   break;
 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),
 383                         0, 0, 0, 0, True);
 384                   break;
 385           case 6: /* Normal cursor (not Origin mode) */
 386                   vtw->vt.td->originMode=False;
 387                   _DtTermPrimCursorMove(w, 0, 0);
 388                   break;
 389           case 7: /* Auto wrap (Off) */
 390                   vtw->term.tpd->autoWrapRight=False;
 391                   break;
 392           /* case 8: ** Auto repeat (Off)
 393            *      ** implemented in the server
 394            *      break;
 395            * case 18: ** Print form feed (Off)
 396            *      break;
 397            * case 19: ** Print extent (scrolling region)
 398            *      break;
 399            */
 400           case 25: /* Text cursor enable (Off) */
 401                   (void) _DtTermPrimSetCursorVisible(w, False);
 402                   break;
 403            /* from xterm */
 404           case 40: /*  80/132 mode  (disallow) */
 405                   vtw->vt.c132 = False;
 406                   break;
 407           case 41: /*  curses fix  */
 408                   vtw->vt.td->fixCursesMode = False;
 409                   break;
 410           case 44: /* margin bell (off) */
 411                   vtw->term.marginBell = False ;
 412                   break;
 413           case 45: /* Reverse-wraparound mode */
 414                   vtw->vt.td->reverseWrapMode=False;
 415                   break;
 416           case 46: /* logging (stop )  */
 417                   vtw->term.logging = False ;
 418                   _DtTermPrimCloseLog(w) ;
 419                   break;
 420           /* case 47: ** screen buffer  (normal)
 421            *      break;
 422            * case 1000: ** don't send mouse x and y
 423            *      break;
 424            * case 1001: ** don't use hilite mouse tracking
 425            *      break;
 426            */
 427       }
 428   }
 429 }
 430
 431 void
 432 _DtTermSetMode(Widget w)   /* SM CSIph */
 433 {
 434   ParserContext context ;
 435   DtTermWidget vtw = (DtTermWidget)w ;
 436   int i,cnt ;
 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);
 446                   break;
 447           case 4: /* Insert mode */
 448                   _DtTermPrimInsertCharUpdate(w, DtTERM_INSERT_CHAR_ON) ;
 449                   break;
 450           case 12: /* SRM Send/Receive (Off) */
 451                   vtw->term.tpd->halfDuplex = False;
 452                   break;
 453           case 20: /* Line feed/newline (new line) */
 454                   vtw->term.tpd->autoLineFeed=True ;
 455                   break;
 456            }
 457     }
 458 }
 459
 460 void
 461 _DtTermResetMode(Widget w)   /* RM CSIpl  */
 462 {
 463   ParserContext context ;
 464   DtTermWidget vtw = (DtTermWidget)w ;
 465   int i,cnt ;
 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);
 475                   break;
 476           case 4: /* Replace mode */
 477                   _DtTermPrimInsertCharUpdate(w, DtTERM_INSERT_CHAR_OFF) ;
 478                   break;
 479           case 12: /* SRM Send/Receive (On) */
 480                   vtw->term.tpd->halfDuplex = True;
 481                   break;
 482           case 20: /* Line feed/newline (line feed) */
 483                   vtw->term.tpd->autoLineFeed=False ;
 484                   break;
 485            }
 486     }
 487 }
 488
 489 void
 490 _DtTermCursorPos(Widget w)   /* CUP CSIp;pH */
 491 {
 492   ParserContext context ;
 493   DtTermWidget vtw = (DtTermWidget) w;
 494   int row, col;
 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] ;
 500   if (row)row-=BASE ;
 501   if (col)col-=BASE ;
 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 ;
 507 }
 508
 509 void
 510 _DtTermEraseDisplay(Widget w)    /* ED CSIpJ */
 511 {
 512   int cnt ;
 513   DtTermWidget vtw = (DtTermWidget) w;
 514   ParserContext context ;
 515   DtEraseMode   eraseMode;
 516   int  row, col;
 517
 518   Debug('P', fprintf(stderr,">>In func _DtTermEraseDisplay\n")) ;
 519   context = GetParserContext(w) ;
 520   KILLWRAP(vtw) ;
 521   STORELASTARG(context) ;
 522   row = vtw->term.tpd->cursorRow;
 523   col = vtw->term.tpd->cursorColumn ;
 524
 525   /*
 526   ** pick the correct erase mode...
 527   */
 528   switch (context->parms[1])
 529   {
 530     case 0:
 531       eraseMode = eraseToEOB;
 532       break;
 533     case 1:
 534       eraseMode = eraseFromRow0Col0;
 535       break;
 536     case 2:
 537       eraseMode = eraseBuffer;
 538       break ;
 539    }
 540    _DtTermFuncEraseInDisplay(w, (int)eraseMode, fromParser);
 541   vtw->term.tpd->cursorRow = row;
 542   vtw->term.tpd->cursorColumn = col;
 543 }
 544
 545 void
 546 _DtTermEraseChars(Widget w)   /* ECH  CSIpX */
 547 {
 548   ParserContext context ;
 549   DtTermWidget vtw = (DtTermWidget) w;
 550   int row,col,cnt ;
 551   Debug('P', fprintf(stderr,">>In func _DtTermEraseChars\n")) ;
 552   KILLWRAP(vtw) ;
 553   context = GetParserContext(w) ;
 554   row = vtw->term.tpd->cursorRow ;
 555   col = vtw->term.tpd->cursorColumn ;
 556   STORELASTARG(context) ;
 557   cnt = context->parms[1] ;
 558   if (!(cnt))cnt=1;
 559   else
 560     if ( cnt > LASTCOLUMN(vtw)-col+1 ) cnt = LASTCOLUMN(vtw)-col+1 ;
 561
 562   _DtTermFuncEraseCharacter(w, cnt, fromParser);
 563 }
 564
 565 void
 566 _DtTermInsertChars(Widget w)    /* ICH  CSIp@ */
 567 {
 568     DtTermWidget vtw = (DtTermWidget) w;
 569     ParserContext context ;
 570     int row, col, cnt ;
 571     DtTermInsertCharMode        saveInsertCharMode;
 572
 573     Debug('P', fprintf(stderr,">>In func _DtTermInsertChars\n")) ;
 574     KILLWRAP(vtw) ;
 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] ;
 581     if (!cnt)
 582         cnt++;
 583     else
 584         if (cnt > LASTCOLUMN(vtw) - col + 1)
 585             cnt = LASTCOLUMN(vtw) - col + 1;
 586
 587     /* save away the insert char mode... */
 588     saveInsertCharMode = vtw->term.tpd->insertCharMode;
 589
 590     /* turn on insert char mode.  We don't want to invoke any status
 591      * change callbacks, so we will justs set it directly...
 592      */
 593     vtw->term.tpd->insertCharMode = DtTERM_INSERT_CHAR_ON;
 594
 595     /* insert blanks... */
 596     while (cnt--)
 597         (void) _DtTermPrimInsertText(w,(unsigned char *) " ", 1) ;
 598
 599     /* restore the insert char mode... */
 600     vtw->term.tpd->insertCharMode = saveInsertCharMode;
 601
 602     _DtTermPrimCursorMove(w,row,col) ;
 603 }
 604
 605 void
 606 _DtTermCursorUp(Widget w)    /* CUU  CISpA */
 607 {
 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) ;
 613   KILLWRAP(vtw) ;
 614   tmargin = TOPMARGIN(vtw) ;
 615   trow = TOPROW(vtw) ;
 616   STORELASTARG(context) ;
 617   cnt = context->parms[1] ;
 618   if (!(cnt))cnt=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) ;
 625 }
 626
 627 void
 628 _DtTermCursorDown(Widget w)    /* CUD CISpB */
 629 {
 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) ;
 635   KILLWRAP(vtw) ;
 636   bmargin = BOTTOMMARGIN(vtw) ;
 637   brow = BOTTOMROW(vtw) ;
 638   STORELASTARG(context) ;
 639   cnt = context->parms[1] ;
 640   if (!(cnt))cnt=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) ;
 648 }
 649
 650 void
 651 _DtTermCursorForward(Widget w)    /* CUF CISpC */
 652 {
 653   ParserContext context ;
 654   DtTermWidget vtw = (DtTermWidget) w;
 655   int col,lcol,cnt ;
 656   Debug('P', fprintf(stderr,">>In func _DtTermCursorForward\n")) ;
 657   context = GetParserContext(w) ;
 658   KILLWRAP(vtw) ;
 659   lcol = LASTCOLUMN(vtw) ;
 660   STORELASTARG(context) ;
 661   cnt = context->parms[1] ;
 662   if (!cnt) cnt=1;
 663   col = vtw->term.tpd->cursorColumn+cnt;
 664   if (col>lcol) col=lcol;
 665   _DtTermPrimCursorMove(w,vtw->term.tpd->cursorRow,col);
 666 }
 667
 668 void
 669 _DtTermCursorBack(Widget w)    /* CUB CISpD */
 670 {
 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")) ;
 675   KILLWRAP(vtw) ;
 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;
 682   if (!cnt) cnt=1;
 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);
 689          }
 690         if((i = (j = LASTCOLUMN(vtw) + 1) * row + col) < 0) {
 691               k = j * (lastrow + 1);
 692               i += ((-i) / k + 1) * k;
 693         }
 694         row = i / j;
 695         if (vtw->vt.td->originMode) row+=TOPMARGIN(vtw);
 696         col = i % j;
 697       } else
 698         col = 0;
 699   }
 700   _DtTermPrimCursorMove(w,row,col);
 701 }
 702
 703 void
 704 _DtTermCursorToLineUp(Widget w)   /* CPL  CSIpF */
 705 {
 706   DtTermWidget vtw = (DtTermWidget) w;
 707   ParserContext context ;
 708   Debug('P', fprintf(stderr,">>In func _DtTermCursorToLineUp\n")) ;
 709   KILLWRAP(vtw) ;
 710   context = GetParserContext(w) ;
 711   vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
 712   _DtTermCursorUp(w) ;
 713 }
 714
 715 void
 716 _DtTermCursorToCol(Widget w)    /* CHA CSIpG */
 717 {
 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 ;
 725 }
 726
 727 void
 728 _DtTermEraseInLine(Widget w)  /* EL  ESC[pK */
 729 {
 730   DtTermWidget vtw = (DtTermWidget) w;
 731   ParserContext context ;
 732   DtEraseMode eraseMode;
 733
 734
 735   Debug('P', fprintf(stderr,">>In func _DtTermEraseInLine\n")) ;
 736   KILLWRAP(vtw) ;
 737   context = GetParserContext(w) ;
 738   STORELASTARG(context) ;
 739   /*
 740   ** pick the correct erase mode...
 741   */
 742   switch ( context->parms[1] )
 743   {
 744     case 0:
 745       eraseMode = eraseToEOL;
 746       break;
 747
 748     case 1:
 749       eraseMode = eraseFromCol0;
 750       break;
 751
 752     case 2:
 753       eraseMode = eraseLine;
 754       break;
 755
 756   }
 757   _DtTermFuncEraseInLine(w, (int)eraseMode, fromParser);
 758 }
 759
 760 void
 761 _DtTermInsertLines(Widget w)  /* IL CSIpL */
 762 {
 763   DtTermWidget vtw = (DtTermWidget) w;
 764   ParserContext context ;
 765   int lines , cnt ;
 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*/
 769      return ;
 770   context = GetParserContext(w) ;
 771   KILLWRAP((DtTermWidget)w) ;
 772   STORELASTARG(context) ;
 773   cnt=context->parms[1];
 774   if (!cnt)cnt++;
 775   lines  = BOTTOMMARGIN(vtw) -  vtw->term.tpd->cursorRow + 1;
 776   if (cnt > lines) cnt=lines ;
 777   _DtTermFuncInsertLine(w,cnt,fromParser) ;
 778 }
 779
 780 void
 781 _DtTermDeleteLines(Widget w)   /* DL CSIpM */
 782 {
 783   DtTermWidget vtw = (DtTermWidget) w;
 784   ParserContext context ;
 785   int cnt ;
 786   Debug('P', fprintf(stderr,">>In func _DtTermDeleteLines\n")) ;
 787
 788   if ( vtw->term.tpd->cursorRow < TOPMARGIN(vtw) ||
 789       vtw->term.tpd->cursorRow > BOTTOMMARGIN(vtw) )  /* outside scrolling region*/
 790      return ;
 791   KILLWRAP((DtTermWidget)w) ;
 792   context = GetParserContext(w) ;
 793   STORELASTARG(context) ;
 794   cnt = context->parms[1];
 795   if(!cnt)cnt++;
 796   _DtTermFuncDeleteLine(w,cnt,fromParser) ;
 797 }
 798
 799 void
 800 _DtTermDeleteChars(Widget w)   /* DCH CSIpP */
 801 {
 802   ParserContext context ;
 803   DtTermWidget vtw = (DtTermWidget) w;
 804   int cnt ;
 805   Debug('P', fprintf(stderr,">>In func _DtTermDeleteChars\n")) ;
 806   KILLWRAP(vtw) ;
 807   context = GetParserContext(w) ;
 808   STORELASTARG(context) ;
 809   cnt= context->parms[1];
 810   if (!cnt) cnt++;
 811   else if (cnt>MAXSHORT) cnt=MAXSHORT-100;
 812   _DtTermFuncDeleteChar(w,cnt,fromParser) ;
 813 }
 814
 815 void
 816 _DtTermNextLine(Widget w) /* NEL ESCE */
 817 {
 818   DtTermWidget vtw = (DtTermWidget) w;
 819   int brow;
 820   Debug('P', fprintf(stderr,">>In func _DtTermNextLine\n")) ;
 821   vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
 822   _DtTermIndex(w) ;  /* use IND */
 823 }
 824
 825 void
 826 _DtTermReverseIndex(Widget w) /* RI ESCM */
 827 {
 828   DtTermWidget vtw = (DtTermWidget) w;
 829   int tmargin, trow, col;
 830   Debug('P', fprintf(stderr,">>In func _DtTermReverseIndex\n")) ;
 831   KILLWRAP(vtw) ;
 832   trow = TOPROW(vtw) ;
 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 ;
 839    }
 840   else if (vtw->term.tpd->cursorRow > trow){
 841            vtw->term.tpd->cursorRow-- ;
 842    }
 843 }
 844
 845 void
 846 _DtTermIndex(Widget w) /* IND  ESCD */
 847 {
 848   DtTermWidget vtw = (DtTermWidget) w;
 849   int bmargin, brow ;
 850   Debug('P', fprintf(stderr,">>In func _DtTermIndex\n")) ;
 851   KILLWRAP(vtw) ;
 852   brow = BOTTOMROW(vtw) ;
 853   bmargin = BOTTOMMARGIN(vtw) ;
 854   if ( vtw->term.tpd->cursorRow == bmargin) {
 855        (void) _DtTermPrimScrollText(w, 1);
 856    }
 857   else if (vtw->term.tpd->cursorRow < brow){
 858          vtw->term.tpd->cursorRow++ ;
 859    }
 860   (void) _DtTermPrimFillScreenGap(w);
 861 }
 862
 863 void
 864 _DtTermScrollingRegion(Widget w)   /* DECSTBM  CSIp;pr */
 865 {
 866   DtTermWidget vtw = (DtTermWidget)w ;
 867   ParserContext context ;
 868   int row1,row2 ;
 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 ;
 876   row1-=BASE ;
 877   row2-=BASE ;
 878   if ( row1 < row2 ) {
 879     if ( row1 == TOPROW(vtw) && row2 == BOTTOMROW(vtw))
 880        vtw->term.tpd->memoryLockMode=SCROLL_LOCKoff ;
 881     else
 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) ;
 887   }
 888 }
 889
 890 void
 891 _DtTermCharAttributes(Widget w)   /* SGR CSIpm */
 892 {
 893   ParserContext context ;
 894   int i,cnt ;
 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]) ;
 902    }
 903   else
 904    _DtTermVideoEnhancement(w,0) ;
 905 }
 906
 907 void
 908 _DtTermDeviceAttributes(Widget w)    /* DA CSIpc */
 909 {
 910   DtTermWidget vtw = (DtTermWidget) w;
 911   ParserContext context ;
 912   int cnt ;
 913   char buf[50];
 914   Debug('P', fprintf(stderr,">>In func _DtTermDeviceAttributes\n")) ;
 915   context = GetParserContext(w) ;
 916   STORELASTARG(context) ;
 917   switch(context->parms[1]) {
 918     case 0:
 919          switch(vtw->vt.td->terminalId ) {
 920             case 100:
 921                      sprintf(buf,"\033[?%d;%dc",1,2) ;
 922                      break;
 923             case 101:
 924                      sprintf(buf,"\033[?%d;%dc",1,0) ;
 925                      break;
 926             case 102:
 927                      sprintf(buf,"\033[?%dc",6) ;
 928                      break;
 929             case 220:
 930                 /*  class 2 terminal (62), 132 columns (1), printer port (2),
 931                  *  selective erase (6), DRCS (7), UDK (8),
 932                  *  national replacement char sets
 933                  */
 934                 sprintf(buf,"\033[?%d;%d;%d;%d;%d;%d;%dc",62,1,2,6,7,8,9) ;
 935                 break;
 936           }
 937         sendEscSequence(w,buf) ;
 938         break;
 939   }
 940 }
 941
 942 void
 943 _DtTermChangeTextParam(Widget w)  /* xterm  CSIp;pcCtrl-G  */
 944 {
 945   ParserContext context ;
 946   DtTermWidget tw = (DtTermWidget) w;
 947   DtTermData vtd = tw->vt.td;
 948   Widget sw;
 949   int i ;
 950   Arg arg[5];
 951   Debug('P', fprintf(stderr,">>In func _DtTermChangeTextParam\n")) ;
 952   context = GetParserContext(w) ;
 953   i=0;
 954   for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
 955   /*
 956    *  context->parms[1] is inited to 0, so if no numeric param was entered,
 957    *  we default appropriately to case 0.
 958    */
 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) ;
 964             break;
 965     case 1: /* change Icon name */
 966             XtSetArg(arg[i], XmNiconName, context->stringParms[0].str); i++;
 967             XtSetValues(sw,arg,i) ;
 968             break;
 969     case 2: /* change Window title */
 970             XtSetArg(arg[i], XmNtitle, context->stringParms[0].str); i++;
 971             XtSetValues(sw,arg,i) ;
 972             break;
 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);
 978             break;
 979    /*  These are handled by xterm but not by us.
 980     case 46:  Change log file to context->stringParms[0]
 981             break;
 982     case 50: ** change font to context->stringParms[0]
 983             break;
 984    */
 985   }
 986 }
 987
 988 void
 989 _DtTermTabClear(Widget w)    /*  TBC CSIpg */
 990 {
 991   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
 992   TermBuffer tb = tw->term.tpd->termBuffer ;
 993   ParserContext context ;
 994   int type ;
 995   Debug('P', fprintf(stderr,">>In func _DtTermTabClear\n")) ;
 996   context = GetParserContext(w) ;
 997   STORELASTARG(context) ;
 998   type = context->parms[1] ;
 999   switch ( type ) {
1000     case 0:(void)_DtTermPrimBufferClearTab(tb,tw->term.tpd->cursorColumn) ;
1001            break ;
1002     case 3: (void)_DtTermPrimBufferClearAllTabs(tb) ;
1003            break ;
1004    }
1005 }
1006
1007 void
1008 _DtTermRequestParam(Widget w) /* DECREQTPARM CSIpx */
1009 {
1010     ParserContext context ;
1011     int row ;
1012     char buf[100];
1013     Debug('P', fprintf(stderr,">>In func _DtTermRequestParam\n")) ;
1014     context = GetParserContext(w) ;
1015     STORELASTARG(context) ;
1016     row = context->parms[1] ;
1017     if ( row < 2) {
1018        row += 2;
1019
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'.
1023         */
1024        sprintf(buf,"\033[%d;%d;%d;%d;%d;%d;%dx",row,1,1,112,112,1,0) ;
1025        sendEscSequence(w,buf) ;
1026      }
1027 }
1028
1029
1030 void
1031 _DtTermTabSet(Widget w) /* HTS ESCH */
1032 {
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) ;
1037 }
1038
1039 void
1040 _DtTermSaveCursor(Widget w) /* DECSC ESC7 */
1041 {
1042   DtTermWidget vtw = (DtTermWidget) w;
1043   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1044   DtTermBuffer tb = (DtTermBuffer)tw->term.tpd->termBuffer ;
1045   DtTermData vtd = vtw->vt.td;
1046
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;
1065 }
1066
1067 void
1068 _DtTermRestoreCursor(Widget w) /* DECRC ESC8 */
1069 {
1070   DtTermPrimitiveWidget      tw        = (DtTermPrimitiveWidget) w;
1071   DtTermPrimData        tpd        = tw->term.tpd;
1072   DtTermWidget vtw = (DtTermWidget) w;
1073   DtTermData vtd = vtw->vt.td;
1074
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,
1100               *(vtd->GL));
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 ;
1112   }
1113 }
1114
1115 void
1116 _DtTermAppKeypad(Widget w)  /* DECPAM  ESC= */
1117 {
1118   DtTermWidget vtw = (DtTermWidget) w;
1119   Debug('P', fprintf(stderr,">>In func _DtTermAppKeypad\n")) ;
1120   vtw->vt.td->applicationKPMode=True;
1121 }
1122
1123 void
1124 _DtTermNormalKeypad(Widget w) /* DECPNM ESC> */
1125 {
1126   DtTermWidget vtw = (DtTermWidget) w;
1127   Debug('P', fprintf(stderr,">>In func _DtTermNormalKeypad\n")) ;
1128   vtw->vt.td->applicationKPMode=False;
1129 }
1130
1131 void
1132 _DtTermS8C1T(Widget w)   /* S8C1T  ESCG  */
1133 {
1134   DtTermWidget vtw = (DtTermWidget) w;
1135   Debug('P', fprintf(stderr,">>In func _vt8CIT\n")) ;
1136   vtw->vt.td->S8C1TMode=True;
1137 }
1138
1139 void
1140 _DtTermS7C1T(Widget w)   /* S7C1T  ESCF */
1141 {
1142   DtTermWidget vtw = (DtTermWidget) w;
1143   Debug('P', fprintf(stderr,">>In func _vt8CIT\n")) ;
1144   vtw->vt.td->S8C1TMode=False;
1145 }
1146
1147 void
1148 _DtTermSetCompatLevel(Widget w)   /* DECSCL CSI p;p"p (last p literal) */
1149 {
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;
1160                            break;
1161                  case 62:  vtw->vt.td->S8C1TMode=True;
1162                            break;
1163                }
1164               break;
1165       case 2: switch (context->parms[2]) {
1166                  case 0:
1167                  case 2: vtw->vt.td->S8C1TMode=True;
1168                          break;
1169                  case 1:
1170                          vtw->vt.td->S8C1TMode=False;
1171                          break;
1172                }
1173     }
1174 }
1175
1176 void
1177 _DtTermInvokeG3(Widget w)  /* LS3R  ESC| */
1178 {
1179   ParserContext context ;
1180   int cnt ;
1181   Debug('P', fprintf(stderr,">>In func _DtTermInvokeG3\n")) ;
1182   context = GetParserContext(w) ;
1183 }
1184
1185 void
1186 _DtTermInvokeG2(Widget w)  /* LS3R  ESC} */
1187 {
1188   ParserContext context ;
1189   int cnt ;
1190   Debug('P', fprintf(stderr,">>In func _DtTermInvokeG2\n")) ;
1191   context = GetParserContext(w) ;
1192 }
1193
1194 void
1195 _DtTermScrollUp(Widget w)    /* SU CSIpS */
1196 {
1197     ParserContext context ;
1198     DtTermWidget vtw = (DtTermWidget) w;
1199     int row,col,cnt ;
1200
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)   \
1206                                    return;
1207     EXIT_IF_OUTSIDE_SR(vtw)
1208     KILLWRAP(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;
1217
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;
1223     }
1224
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;
1229 }
1230
1231 void
1232 _DtTermScrollDown(Widget w)  /* SD CSIpT */
1233 {
1234     ParserContext context ;
1235     DtTermWidget vtw = (DtTermWidget) w;
1236     int row,col,cnt ;
1237
1238     Debug('P', fprintf(stderr,">>In func _DtTermScrollDown\n")) ;
1239     EXIT_IF_OUTSIDE_SR(vtw)
1240     KILLWRAP(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;
1249
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;
1255     }
1256
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;
1261 }
1262
1263 void
1264 _DtTermRestoreModeValues(Widget w)  /* xterm - Restore DEC mode values CSI?pr */
1265 {
1266   ParserContext context ;
1267   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1268   DtTermWidget vtw = (DtTermWidget)w;
1269   DtTermData vtd = vtw->vt.td;
1270   int i,cnt ;
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]) {
1277           /* from vt220 */
1278           case 1: /* Cursor key (Normal/Application) */
1279                   vtd->applicationMode = vtd->saveDECMode.applicationMode ;
1280                   break;
1281 #ifdef  NOT_SUPPORTED
1282           case 2:  /* set vt52 mode */
1283                   break;
1284 #endif  /* NOT_SUPPORTED */
1285           case 3: /* Columns (80/132) */
1286                   vtd->col132Mode = vtd->saveDECMode.col132Mode ;
1287                   break;
1288           case 4: /* Scroll Mode ( jump/smooth ) */
1289                   _DtTermPrimScrollComplete(w, True) ;
1290                   vtw->term.jumpScroll = vtd->saveDECMode.jumpScrollMode ;
1291                   break;
1292           case 5: /* Screen mode */
1293                   vtw->term.reverseVideo = vtd->saveDECMode.inverseVideoMode ;
1294                   break;
1295           case 6: /*  Origin mode (on/off)*/
1296                   vtd->originMode = vtd->saveDECMode.originMode ;
1297                   break;
1298           case 7: /* Auto wrap (On/Off) */
1299                   vtw->term.tpd->autoWrapRight = vtd->saveDECMode.wrapMode ;
1300                   break;
1301           case 8: /* Auto repeat (Off) */
1302                   /* implemented in the server */
1303                   break;
1304 #ifdef  NOT_SUPPORTED
1305           case 18: /* Print form feed (Off) */
1306                   break;
1307           case 19: /* Print extent (scrolling region) */
1308                   break;
1309 #endif  /* NOT_SUPPORTED */
1310           case 25: /* Text cursor enable (Off) */
1311                   _DtTermPrimSetCursorVisible(w,
1312                         vtd->saveDECMode.cursorVisible);
1313                   break;
1314
1315            /* from xterm */
1316           case 40: /*  80/132 mode  (disallow/allow) */
1317                   vtw->vt.c132 = vtd->saveDECMode.allow80_132ColMode;
1318                   break;
1319           case 41: /*  curses fix  (off/on) */
1320                   vtd->fixCursesMode = vtd->saveDECMode.fixCursesMode;
1321                   break;
1322           case 44: /* margin bell (off/on) */
1323                   vtw->term.marginBell = vtd->saveDECMode.marginBellMode;
1324                   break;
1325           case 45: /* Reverse-wraparound mode */
1326                   vtd->reverseWrapMode = vtd->saveDECMode.reverseWrapMode ;
1327                   break;
1328           case 46: /* logging (stop/start )  */
1329                   if (vtd->saveDECMode.logging) {
1330                       vtw->term.logging = True ;
1331                       _DtTermPrimStartLog(w);
1332                   } else {
1333                       vtw->term.logging = False ;
1334                       _DtTermPrimCloseLog(w) ;
1335                   }
1336                   break;
1337 #ifdef  NOT_SUPPORTED
1338           case 47: /* screen buffer  (normal) */
1339                   break;
1340           case 1000: /* don't send mouse x and y */
1341                   break;
1342           case 1001: /* don't use hilite mouse tracking */
1343                   break;
1344 #endif  /* NOT_SUPPORTED */
1345       }
1346    }
1347 }
1348
1349 void
1350 _DtTermSaveModeValues(Widget w)  /* xterm - Save DEC mode values CSI?ps  */
1351 {
1352   ParserContext context ;
1353   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1354   DtTermWidget vtw = (DtTermWidget)w;
1355   DtTermData vtd = vtw->vt.td;
1356   int i,cnt ;
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]) {
1363           /* from vt220 */
1364           case 1: /* Cursor key (Normal/Application) */
1365                   vtd->saveDECMode.applicationMode = vtd->applicationMode ;
1366                   break;
1367 #ifdef  NOT_SUPPORTED
1368           case 2:  /* set vt52 mode */
1369                   break;
1370 #endif  /* NOT_SUPPORTED */
1371           case 3: /* Columns (80/132) */
1372                   vtd->saveDECMode.col132Mode = vtd->col132Mode ;
1373                   break;
1374           case 4: /* Scroll Mode ( jump/smooth ) */
1375                   vtd->saveDECMode.jumpScrollMode = vtw->term.jumpScroll ;
1376                   break;
1377           case 5: /* Screen mode */
1378                   vtd->saveDECMode.inverseVideoMode = vtw->term.reverseVideo ;
1379                   break;
1380           case 6: /*  Origin mode (on/off)*/
1381                   vtd->saveDECMode.originMode = vtd->originMode ;
1382                   break;
1383           case 7: /* Auto wrap (On/Off) */
1384                   vtd->saveDECMode.wrapMode = vtw->term.tpd->autoWrapRight ;
1385                   break;
1386           case 8: /* Auto repeat (Off) */
1387                   /* implemented in the server */
1388                   break;
1389 #ifdef  NOT_SUPPORTED
1390           case 18: /* Print form feed (Off) */
1391                   break;
1392           case 19: /* Print extent (scrolling region) */
1393                   break;
1394 #endif  /* NOT_SUPPORTED */
1395           case 25: /* Text cursor enable (Off) */
1396                   vtd->saveDECMode.cursorVisible =
1397                             _DtTermPrimGetCursorVisible(w);
1398                   break;
1399            /* from xterm */
1400           case 40: /*  80/132 mode  (disallow/allow) */
1401                   vtd->saveDECMode.allow80_132ColMode = vtw->vt.c132;
1402                   break;
1403           case 41: /*  curses fix  (off/on) */
1404                   vtd->saveDECMode.fixCursesMode = vtd->fixCursesMode ;
1405                   break;
1406           case 44: /* margin bell (off/on) */
1407                   vtd->saveDECMode.marginBellMode = vtw->term.marginBell ;
1408                   break;
1409           case 45: /* Reverse-wraparound mode */
1410                   vtd->saveDECMode.reverseWrapMode = vtd->reverseWrapMode ;
1411                   break;
1412           case 46: /* logging (stop/start ) */
1413                   vtd->saveDECMode.logging = vtw->term.logging;
1414                   break;
1415 #ifdef  NOT_SUPPORTED
1416           case 47: /* screen buffer  (normal) */
1417                   break;
1418           case 1000: /* don't send mouse x and y */
1419                   break;
1420           case 1001: /* don't use hilite mouse tracking */
1421                   break;
1422 #endif  /* NOT_SUPPORTED */
1423       }
1424    }
1425 }
1426
1427
1428 void
1429 _DtTermAlignTest(Widget w)     /* DECALN ESC#8 */
1430 {
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) ;
1447 }
1448
1449 void
1450 _DtTermInvokeG1(Widget w)     /* ESC~ESC */
1451 {
1452   ParserContext context ;
1453   int cnt ;
1454   Debug('P', fprintf(stderr,">>In func _DtTermInvokeG1\n")) ;
1455   context = GetParserContext(w) ;
1456 }
1457
1458 void
1459 _DtTermSelEraseInLine(Widget w) /* DECSEL ESC?pK */
1460 {
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 ;
1467     enhValues evalues;
1468     int c,col1,col2,col,row ;
1469     short cnt ;
1470     DtTermInsertCharMode        saveInsertCharMode;
1471
1472     Debug('P', fprintf(stderr,">>In func _DtTermSelEraseInLine\n")) ;
1473     KILLWRAP(vtw) ;
1474     context = GetParserContext(w) ;
1475     STORELASTARG(context) ;
1476     col1 = FIRSTCOLUMN(vtw) ;
1477     col2 = LASTCOLUMN(vtw) ;
1478     switch ( context->parms[1] )  {
1479     case 0:
1480         col1= tpd->cursorColumn;
1481         break;
1482     case 1:
1483         col2 = tpd->cursorColumn;
1484         break;
1485     case 2:
1486         break ;
1487     default:
1488         return ;
1489     }
1490     /* save away the current cursor position... */
1491     col = tpd->cursorColumn ;
1492     row = tpd->cursorRow    ;
1493
1494     /* save away the current insert mode... */
1495     saveInsertCharMode = vtw->term.tpd->insertCharMode;
1496
1497     /* insert char needs to be off... */
1498     tpd->insertCharMode = DtTERM_INSERT_CHAR_OFF;
1499
1500     tpd->parserNotInStartState = False ;
1501     c = col1;
1502
1503     while (c <= col2) {
1504         (void)_DtTermPrimBufferGetEnhancement(tb, tpd->cursorRow,
1505                     c, &evalues, &cnt, countAll);
1506         if (!cnt)
1507             break ;
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);
1518                 c++;
1519             }
1520         } else {
1521             c += cnt;
1522         }
1523     }
1524
1525     /* restore the insert char mode... */
1526     tpd->insertCharMode = saveInsertCharMode;
1527
1528     /* restore the cursor position... */
1529     tpd->cursorColumn = col;
1530     tpd->cursorRow = row;
1531
1532     /* restore the current enhancement state... */
1533     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1534               tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhVideo,
1535               td->enhVideoState);
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);
1542 }
1543
1544 void
1545 _DtTermSelEraseInDisplay(Widget w) /* DECSED ESC?pJ */
1546 {
1547   DtTermWidget vtw = (DtTermWidget) w;
1548   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1549   TermBuffer tb = tw->term.tpd->termBuffer ;
1550   ParserContext context ;
1551   enhValues evalues;
1552   int r,col1,col2,row1,row2,col,row ;
1553   int   cnt ;
1554   Debug('P', fprintf(stderr,">>In func _DtTermSelEraseInDisplay\n")) ;
1555   KILLWRAP(vtw) ;
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;
1565               break;
1566       case 1: col2 = vtw->term.tpd->cursorColumn;
1567               row2 = vtw->term.tpd->cursorRow;
1568               break;
1569       case 2: break ;
1570       default: return ;
1571     }
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) ;
1582    }
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;
1589 }
1590
1591
1592 void
1593 _DtTermSingleShiftG2(Widget w) /* SS2  ESCN */
1594 {
1595   DtTermWidget vtw = (DtTermWidget) w;
1596   DtTermData vtd =      vtw->vt.td;
1597
1598   Debug('P', fprintf(stderr,">>In func _DtTermSingleShiftG2\n")) ;
1599   vtd->singleShiftPending = True;
1600   vtd->singleShiftFont = vtd->G2;
1601 }
1602
1603 void
1604 _DtTermSingleShiftG3(Widget w) /* SS3  ESCO */
1605 {
1606   DtTermWidget vtw = (DtTermWidget) w;
1607   DtTermData vtd =      vtw->vt.td;
1608
1609   Debug('P', fprintf(stderr,">>In func _DtTermSingleShiftG3\n")) ;
1610   vtd->singleShiftPending = True;
1611   vtd->singleShiftFont = vtd->G3;
1612 }
1613
1614 void
1615 _DtTermLoadCharSet(Widget w) /* vt220 DCS - download char set ESCPpST  */
1616 {
1617   /* we're not implementing this */
1618 }
1619
1620 /*********************************************************************
1621  *  The next 3 functions handle the user key string loading
1622  *    DCS Pc;Pl | Ky1/st1;ky2/st2;...kyn/stn ST
1623  */
1624 void
1625 _DtTermParseUserKeyClear(Widget w) /* vt220 DECUDK clear function keys*/
1626 {
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 )
1634   {
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 ;
1640   }
1641   _DtTermClearParam(w) ;
1642 }
1643 void
1644 _DtTermParseUserKeyLoad(Widget w) /* vt220 DECUDK load function string */
1645 {
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)
1653   {
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);
1658   }
1659   _DtTermClearParam(w) ;
1660 }
1661
1662 void
1663 _DtTermParseUserKeyLoadLast(Widget w) /* vt220 DECUDK load function string */
1664 {
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 ;
1670 }
1671
1672 void
1673 _DtTermParseHexDigit(Widget w) /* vt220 DECUDK store hex digit*/
1674 {
1675   ParserContext context ;
1676   int ci, left_byte, i;
1677   char c, cbuf[2] ;
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 ;
1684       cbuf[1] = (char)0 ;
1685       sscanf(cbuf,"%x",&ci)   ;
1686       c = (char)ci ;
1687       left_byte  = (i+1)%2 ;
1688       i /= 2 ;
1689       if ( left_byte  )
1690            context->stringParms[0].str[i] = c<<4 ;
1691       else
1692            context->stringParms[0].str[i] |= c & 0x0F ;
1693       context->stringParms[0].length++ ;
1694    }
1695 }
1696
1697 void
1698 _DtTermReset(Widget w) /* RIS  ESCc */
1699 {
1700   ParserContext context ;
1701   int cnt ;
1702   Debug('P', fprintf(stderr,">>In func _DtTermReset\n")) ;
1703   context = GetParserContext(w) ;
1704   _DtTermFuncHardReset(w,0 ,fromParser) ;
1705 }
1706
1707 void
1708 _DtTermSelectG2(Widget w) /* LS2  ESCn */
1709 {
1710     DtTermWidget vtw = (DtTermWidget)w ;
1711     DtTermData vtd =      vtw->vt.td;
1712     DtTermPrimitiveWidget tw         = (DtTermPrimitiveWidget) w;
1713     DtTermPrimData        tpd        = tw->term.tpd;
1714
1715     Debug('P', fprintf(stderr,">>In func _DtTermSelectG2\n")) ;
1716     vtd->GL = &vtd->G2;
1717
1718     vtd->enhFontState = *vtd->GL;
1719     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1720             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1721             enhFont, vtd->enhFontState);
1722 }
1723
1724 void
1725 _DtTermSelectG3(Widget w) /* LS3 ESCo */
1726 {
1727     DtTermWidget vtw = (DtTermWidget)w ;
1728     DtTermData vtd =      vtw->vt.td;
1729     DtTermPrimitiveWidget tw         = (DtTermPrimitiveWidget) w;
1730     DtTermPrimData        tpd        = tw->term.tpd;
1731
1732     Debug('P', fprintf(stderr,">>In func _DtTermSelectG3\n")) ;
1733     vtd->GL = &vtd->G3;
1734     vtd->enhFontState = *vtd->GL;
1735     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1736             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1737             enhFont, vtd->enhFontState);
1738 }
1739
1740 void
1741 _DtTermParseStatus(Widget w)  /* DECID (same as DA)  ESCZ */
1742 {
1743    _DtTermDeviceAttributes(w) ;
1744 }
1745
1746 void
1747 _DtTermSetCharEraseMode(Widget w) /* DECSCA ESCp"q */
1748 {
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  */
1758               /* fall through */
1759      case 2:
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);
1764              break;
1765      case 1:
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);
1770              break;
1771    }
1772 }
1773
1774 void
1775 _DtTermSingleWide(Widget w) /* DECSWL ESC#5 */
1776 {
1777   ParserContext context ;
1778   int cnt ;
1779   Debug('P', fprintf(stderr,">>In func _DtTermSingleWide\n")) ;
1780   context = GetParserContext(w) ;
1781 }
1782
1783 void
1784 _DtTermDoubleWide(Widget w) /* DECDWL ESC#6  */
1785 {
1786   ParserContext context ;
1787   int cnt ;
1788   Debug('P', fprintf(stderr,">>In func _DtTermDoubleWide\n")) ;
1789   context = GetParserContext(w) ;
1790 }
1791
1792 void
1793 _DtTermDoubleHigh(Widget w) /* DECWHL ESC#4 */
1794 {
1795   ParserContext context ;
1796   int cnt ;
1797   Debug('P', fprintf(stderr,">>In func _DtTermDoubleHigh\n")) ;
1798   context = GetParserContext(w) ;
1799 }
1800
1801 void
1802 _DtTermParseFontG0(Widget w)
1803 {
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) ;
1810
1811     Debug('P', fprintf(stderr,">>In func _DtTermParseFontG0\n")) ;
1812     switch (*context->inputChar) {
1813     case 'B':
1814         vtd->G0 = FONT_NORMAL;
1815         break;
1816
1817     case '0':
1818         vtd->G0 = FONT_LINEDRAW;
1819         break;
1820     }
1821
1822     vtd->enhFontState = *vtd->GL;
1823     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1824             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1825             enhFont, vtd->enhFontState);
1826 }
1827
1828 void
1829 _DtTermParseFontG1(Widget w)
1830 {
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) ;
1837
1838     Debug('P', fprintf(stderr,">>In func _DtTermParseFontG1\n")) ;
1839     switch (*context->inputChar) {
1840     case 'B':
1841         vtd->G1 = FONT_NORMAL;
1842         break;
1843
1844     case '0':
1845         vtd->G1 = FONT_LINEDRAW;
1846         break;
1847     }
1848
1849     vtd->enhFontState = *vtd->GL;
1850     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1851             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1852             enhFont, vtd->enhFontState);
1853 }
1854
1855 void
1856 _DtTermParseFontG2(Widget w)
1857 {
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) ;
1864
1865     Debug('P', fprintf(stderr,">>In func _DtTermParseFontG1\n")) ;
1866     switch (*context->inputChar) {
1867     case 'B':
1868         vtd->G2 = FONT_NORMAL;
1869         break;
1870
1871     case '0':
1872         vtd->G2 = FONT_LINEDRAW;
1873         break;
1874     }
1875
1876     vtd->enhFontState = *vtd->GL;
1877     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1878             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1879             enhFont, vtd->enhFontState);
1880 }
1881
1882 void
1883 _DtTermParseFontG3(Widget w)
1884 {
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) ;
1891
1892     Debug('P', fprintf(stderr,">>In func _DtTermParseFontG1\n")) ;
1893     switch (*context->inputChar) {
1894     case 'B':
1895         vtd->G3 = FONT_NORMAL;
1896         break;
1897
1898     case '0':
1899         vtd->G3 = FONT_LINEDRAW;
1900         break;
1901     }
1902
1903     vtd->enhFontState = *vtd->GL;
1904     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1905             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1906             enhFont, vtd->enhFontState);
1907 }
1908
1909 void
1910 _DtTermParseFontShift(Widget w)  /* Ctrl-E  Ctrl-F  */
1911 {
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) ;
1918
1919     Debug('P', fprintf(stderr,">>In func _DtTermParseFontShift\n")) ;
1920     switch (*context->inputChar) {
1921     case 'O' & 0x1f:
1922         /* SHIFT OUT */
1923         vtd->GL = &vtd->G0;
1924         break;
1925
1926     case 'N' & 0x1f:
1927         /* SHIFT OUT */
1928         vtd->GL = &vtd->G1;
1929         break;
1930     }
1931
1932     vtd->enhFontState = *vtd->GL;
1933     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1934             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1935             enhFont, vtd->enhFontState);
1936 }
1937
1938 void
1939 _DtTermParseTab(Widget w)    /* Crtl-I */
1940 {
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);
1947         } else {
1948             /* we already tabbed to the end of the line, so do nothing... */
1949         }
1950     } else {
1951         (void) _DtTermFuncTab(w, 1, fromParser);
1952     }
1953     return;
1954 }
1955
1956 void
1957 _DtTermParseLF    /* LineFeed (LF) or newline (NL) Ctrl-J,
1958                      Vertical Tab Ctrl-K, Form Feed (NP) Ctrl-L */
1959 (
1960     Widget w
1961 )
1962 {
1963   DtTermWidget vtw = (DtTermWidget)w ;
1964   Debug('P', fprintf(stderr,">>In func _vtParseLR\n")) ;
1965   KILLWRAP(vtw) ;
1966   if (vtw->term.tpd->cursorRow == BOTTOMMARGIN(vtw))
1967    {
1968      /*
1969         ** scroll one line...
1970         */
1971         (void) _DtTermPrimScrollText(w, 1);
1972         vtw->term.tpd->cursorRow = BOTTOMMARGIN(vtw);
1973     }
1974    else {
1975     if (!(vtw->term.tpd->cursorRow == BOTTOMROW(vtw))) {
1976        vtw->term.tpd->cursorRow++ ;
1977      }
1978    }
1979    (void) _DtTermPrimFillScreenGap(w);
1980
1981    if (vtw->term.tpd->autoLineFeed )
1982         _DtTermPrimParseCR(w);
1983 }
1984
1985 void
1986 _DtTermSoftReset   /* DECSTR  ESC!p  */
1987 (
1988     Widget w
1989 )
1990 {
1991   Debug('P', fprintf(stderr,">>In func _DtTermSoftReset\n")) ;
1992    _DtTermFuncSoftReset(w,0 ,fromParser) ;
1993 }
1994
1995 void
1996 _DtTermParseBackspace  /*  Ctrl-H  */
1997 (
1998     Widget w
1999 )
2000 {
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;
2009     (void) col--;
2010     if (col<fcol) {
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) ;
2016        }
2017       else {
2018          col=fcol;
2019       }
2020     }
2021   vtw->term.tpd->cursorRow = row;
2022   vtw->term.tpd->cursorColumn = col;
2023 }
2024
2025 static void
2026 GetWindowOffsets
2027 (
2028     Widget                        w,
2029     int                          *xOffset,
2030     int                          *yOffset,
2031     int                          *widthOffset,
2032     int                          *heightOffset
2033 )
2034 {
2035     Display                      *display;
2036     Window                        parentReturn;
2037     Window                       *childrenReturn;
2038     unsigned int                  nChildrenReturn;
2039     Window                        rootWindow;
2040     Window                        topWindow;
2041     Window                        childReturn;
2042     int                           destXReturn;
2043     int                           destYReturn;
2044     unsigned int                  widthReturn;
2045     unsigned int                  heightReturn;
2046     unsigned int                  topWidthReturn;
2047     unsigned int                  topHeightReturn;
2048     unsigned int                  borderWidthReturn;
2049     unsigned int                  depthReturn;
2050
2051     *xOffset = 0;
2052     *yOffset = 0;
2053     *widthOffset = 0;
2054     *heightOffset = 0;
2055
2056     if (XmIsMotifWMRunning(w)) {
2057         /* get the window we want to figure the offsets for... */
2058         topWindow = XtWindow(w);
2059
2060         /* and the display involved... */
2061         display = XtDisplay(w);
2062
2063         (void) XQueryTree(display, topWindow, &rootWindow, &parentReturn,
2064                 &childrenReturn, &nChildrenReturn);
2065         (void) XFree(childrenReturn);
2066
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);
2073         }
2074
2075         /* we now know what our top window is.  translate our upper
2076          * left corner relative to its upper left corner...
2077          */
2078         (void) XTranslateCoordinates(display, XtWindow(w), topWindow,
2079                 0, 0, &destXReturn, &destYReturn, &childReturn);
2080         *xOffset = destXReturn;
2081         *yOffset = destYReturn;
2082
2083         /* now that we know the top window, we can figure out the size
2084          * difference between the two windows...
2085          */
2086         (void) XGetGeometry(display, topWindow, &rootWindow,
2087                 &destXReturn, &destYReturn, &topWidthReturn,
2088                 &topHeightReturn, &borderWidthReturn, &depthReturn);
2089
2090         (void) XGetGeometry(display, XtWindow(w), &rootWindow,
2091                 &destXReturn, &destYReturn, &widthReturn, &heightReturn,
2092                 &borderWidthReturn, &depthReturn);
2093
2094         *widthOffset = topWidthReturn - widthReturn;
2095         *heightOffset = topHeightReturn - heightReturn;
2096     }
2097 }
2098
2099 void
2100 _DtTermParseSunMisc  /*  Misc sun esc seqs  */
2101 (
2102     Widget w
2103 )
2104 {
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);
2110   Window sh_win;
2111   Widget sw;
2112   XWindowChanges values;
2113   Arg arg[5];
2114   char buf[BUFSIZ];
2115   Position x,y;
2116   short   rows,columns;
2117   Dimension height,width;
2118   char *fmt,*s,*title,*icon;
2119   int xOffset;
2120   int yOffset;
2121   int widthOffset;
2122   int heightOffset;
2123
2124   context = GetParserContext(w) ;
2125   STORELASTARG(context) ;
2126
2127   for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2128   sh_win = XtWindow(sw) ;
2129   switch (context->parms[1])
2130   {
2131     case 1:
2132       XMapWindow(display,sh_win);
2133       break;
2134     case 2:
2135       XIconifyWindow(display,sh_win,scr_num);
2136       break;
2137     case 3:
2138         (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2139                 &heightOffset);
2140         /* DKS
2141         (void) XMoveWindow(display, sh_win,
2142                 context->parms[2] + xOffset, context->parms[3] + yOffset);
2143                 DKS */
2144         (void) XtVaSetValues(sw, XmNx, context->parms[2] + xOffset,
2145                 XmNy, context->parms[3] + yOffset, NULL);
2146         break ;
2147     case 4:
2148         (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2149                 &heightOffset);
2150         (void) XtVaSetValues(sw, XmNwidth, context->parms[3] - widthOffset,
2151                        XmNheight,context->parms[2] - heightOffset, NULL);
2152       break ;
2153     case 5:
2154       XRaiseWindow(display,sh_win);
2155       break ;
2156     case 6:
2157       XLowerWindow(display,sh_win);
2158       break ;
2159     case 7:
2160       _DtTermPrimFuncRedrawDisplay(w, 1, fromParser);
2161       break ;
2162     case 8:
2163         rows = context->parms[2];
2164         columns = context->parms[3];
2165         (void) XtVaSetValues(w, DtNrows, rows, DtNcolumns, columns, NULL);
2166         break ;
2167     case 11:
2168       if (vtw->term.tpd->windowMapped)
2169          sendEscSequence(w,"\033[1t") ;
2170       else
2171          sendEscSequence(w,"\033[2t") ;
2172       break ;
2173     case 13:
2174         (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2175                 &heightOffset);
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);
2179         break;
2180     case 14:
2181         (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2182                 &heightOffset);
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);
2187         break;
2188     case 18:
2189         (void) XtVaGetValues(w, DtNrows, &rows, DtNcolumns, &columns, NULL);
2190         (void) sprintf(buf, "\033[8;%hd;%hdt", rows, columns);
2191         (void) sendEscSequence(w, buf);
2192         break;
2193     case 20:
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);
2198       else
2199         s = buf;
2200       sprintf(s,fmt);
2201       sendEscSequence(w,s) ;
2202       if (s != buf) XtFree(s);
2203       break ;
2204     case 21:
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);
2209       else
2210         s = buf;
2211       sprintf(s,fmt);
2212       sendEscSequence(w,s) ;
2213       if (s != buf) XtFree(s);
2214       break ;
2215    }
2216 }
2217
2218 void
2219 _DtTermParserSunWindowIcon( Widget w)   /* sun set icon label */
2220 {
2221   ParserContext context ;
2222   Widget sw;
2223   context = GetParserContext(w) ;
2224   for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2225   XtVaSetValues(sw, XmNiconName, context->stringParms[0].str, NULL) ;
2226 }
2227
2228 void
2229 _DtTermParserSunWindowTitle     /* Sun set title name */
2230 (
2231 Widget w
2232 )
2233 {
2234   ParserContext context ;
2235   Widget sw;
2236   context = GetParserContext(w) ;
2237   for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2238   XtVaSetValues(sw,XmNtitle, context->stringParms[0].str, NULL) ;
2239 }
2240
2241 void
2242 _DtTermParserSunIconFile(Widget w)   /* Sun set icon to pixmap in file */
2243 {
2244   DtTermBuffer tb =
2245             (DtTermBuffer)((DtTermPrimitiveWidget)w)->term.tpd->termBuffer ;
2246   ParserContext context ;
2247   int fg, bg;
2248   Widget sw;
2249   Pixmap icon;
2250
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);
2257 }
2258