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 libraries 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 <wctype.h>
  40
  41 #include "TermHeader.h"
  42 #include "TermPrimDebug.h"
  43 #include "TermPrimP.h"
  44 #include "TermPrimI.h"
  45 #include "TermP.h"
  46 #include "TermPrimData.h"
  47 #include "TermData.h"
  48 #include "TermPrimBuffer.h"
  49 #include "TermPrimParserP.h"
  50 #include "TermFunction.h"
  51 #include "TermBuffer.h"
  52 #include "TermFunctionKey.h"
  53 #include "TermParseTableP.h"
  54 #include "TermBufferP.h"
  55 #include "TermPrimUtil.h"
  56 #include "TermPrimParseTable.h"
  57
  58 #if defined (__hpux)
  59 /*
  60  * On HP MAXINT is defined in both <values.h> and <sys/param.h>
  61  */
  62 #undef MAXINT
  63 #endif
  64 #if defined(CSRG_BASED)
  65 #define MAXSHORT SHRT_MAX
  66 #else
  67 #include  <values.h>
  68 #endif
  69
  70 /*****************************************************************************/
  71
  72 #define NPARAM  16
  73 #define PCOUNT(c)  ((c)->parms[0])
  74 #define BASE   1   /* row and column count base 0 or 1 */
  75
  76 /*********************************************************************
  77  *  Macros for handling cursor constraints - return values in coordinate
  78  *  system for Term widget (base 0)  BASE which is 1 reflects the Vt base
  79  *
  80  *  These defines need to account of for Origin mode eventually  TMH */
  81
  82 #define TOPROW(w)    (1-BASE)
  83 #define TOPMARGIN(w) ((w)->term.tpd->scrollLockTopRow-(1-BASE))
  84 #define BOTTOMMARGIN(w) ((w)->term.tpd->scrollLockBottomRow-(1-BASE))
  85 #define BOTTOMROW(w) ((w)->term.rows-BASE)
  86 /* FIRSTCOLUMN(w)  ABS(BASE-1) */
  87 #define FIRSTCOLUMN(w) 0
  88 #define LASTCOLUMN(w) ((w)->term.columns-BASE)
  89 #define FLOOR(w)  ((w)->vt.td->originMode?(w)->term.tpd->scrollLockBottomRow:\
  90                                              BOTTOMROW(w))
  91 #define CEILING(w)  ((w)->vt.td->originMode?(w)->term.tpd->scrollLockTopRow:\
  92                                              TOPROW(w))
  93 #define KILLWRAP(w) if((w)->term.tpd->cursorColumn>LASTCOLUMN(w)) \
  94                                 (w)->term.tpd->cursorColumn=LASTCOLUMN(w)
  95 #define STORELASTARG(c) (c)->parms[PCOUNT(c)]=(c)->workingNum
  96
  97 /******************************************************************
  98  *   Upon entering a parse routine the parameter count is contained
  99  *   in  context->parms[0].
 100  *
 101  *   The last parmameter parsed is in context->workingNum
 102  *   Next to last parmameter is in {context->parms[0]==1?context->workingNum:
 103  *                                  context->parms[context->param[0]-1]}
 104  *                    .
 105  *                    .
 106  *
 107  *   First parameter is in  context->parms[1]
 108  *
 109  *   In some of the parse routines, the default case of too many parameters
 110  *   needs to be handled like Vt (silently use the first n parameters)
 111  *   Vt has a max of 16 numeric parameters;  The rest fall off the end
 112  *   silently.
 113  *******************************************************************/
 114
 115 void
 116 _DtTermClearParam(Widget w)
 117 {
 118     ParserContext context ;
 119     context = GetParserContext(w) ;
 120
 121     PCOUNT(context)=0 ;
 122     _DtTermPrimParserClearParm(w) ;
 123     _DtTermPrimParserClrStrParm(w) ;
 124 }
 125
 126 void
 127 _DtTermEnterNum(Widget w)
 128 {
 129   ParserContext context ;
 130   context = GetParserContext(w) ;
 131   _DtTermPrimParserEnterNum(w) ;
 132   if (!PCOUNT(context)) PCOUNT(context)++ ; /* increment for first number ONLY*/
 133 }
 134
 135 void
 136 _DtTermParsePushNum(Widget w)
 137 {
 138   ParserContext context ;
 139   context = GetParserContext(w) ;
 140   /* parmN(w,PCOUNT(c)) ;  Should  use this but not global   */
 141   if ( context->workingNumIsDefault != True) {  /* did we actually parse a num*/
 142      _DtTermPrimParserNumParmPush(w,PCOUNT(context)) ;
 143      }
 144   else {
 145    if (!PCOUNT(context)) PCOUNT(context)++ ;/* increment for first number ONLY*/
 146   }
 147
 148   if ( ++PCOUNT(context)>NPARAM ) {
 149     Debug('P',fprintf(stderr,">>Too many parameters\n")) ;
 150     return ;
 151   }
 152 }
 153
 154 void
 155 _DtTermSaveChar(Widget w)
 156 {
 157   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
 158   ParserContext context ;
 159   wchar_t c;
 160   context = GetParserContext(w) ;
 161
 162   mbtowc(&c,(char *)context->inputChar,MB_CUR_MAX);
 163   if ( context->stringParms[0].length < STR_SIZE && iswprint(c) ) {
 164       strncpy( (
 165          (char *)&context->stringParms[0].str[context->stringParms[0].length]),
 166                 (char *)context->inputChar, context->inputCharLen) ;
 167    context->stringParms[0].length += context->inputCharLen ;
 168   }
 169 }
 170
 171 void
 172 _DtTermPrintState(Widget w)
 173 {
 174   ParserContext context ;
 175   context = GetParserContext(w) ;
 176   /* fprintf(stderr,"Warning: Not a valid escape sequence\n") ;*/
 177   context->stateTable =  _DtTermStateStart ;
 178   _DtTermClearParam(w) ;
 179 }
 180
 181 /* a utility for checking for S8C1TMode */
 182 static void
 183 sendEscSequence(Widget w, char *transmitString)
 184 {
 185     DtTermWidget    tw  = (DtTermWidget)w;
 186     DtTermData      td = tw->vt.td;
 187
 188     if ( td->S8C1TMode ) {
 189            char *cbuf =malloc(strlen(transmitString)+1);
 190            strcpy(cbuf,transmitString) ;
 191            cbuf[1] = 0x9B ;
 192            (void) _DtTermPrimSendInput(w, (unsigned char *) (cbuf+1),
 193                 strlen(cbuf+1));
 194            free(cbuf) ;
 195          }
 196         else {
 197            (void) _DtTermPrimSendInput(w, (unsigned char *) transmitString,
 198                 strlen(transmitString));
 199         }
 200 }
 201
 202 void
 203 _DtTermDeviceStatus(Widget w)     /* DSR CSI?pn  */
 204 {
 205   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
 206   DtTermData vtd = ((DtTermWidget)w)->vt.td;
 207   ParserContext context ;
 208   char buf[100] ;
 209   int col,cnt ;
 210   Debug('P', fprintf(stderr,">>In func  _DtTermDeviceStatus\n")) ;
 211   context = GetParserContext(w) ;
 212   STORELASTARG(context) ;
 213   switch ( context->parms[1] )  {
 214      case 15: /* printer status - we don't have one         */
 215              sendEscSequence(w,"\033[?13n") ;
 216              break;
 217      case 25: /* User defined keys locked?  */
 218              if ( vtd->userKeysLocked )
 219                 sendEscSequence(w,"\033[?21n") ;
 220              else
 221                 sendEscSequence(w,"\033[?20n") ;
 222              break;
 223      case 26: /* keyboard status - always send North American */
 224              sendEscSequence(w,"\033[?27;1n") ;
 225              break;
 226   }
 227 }
 228
 229 void
 230 _DtTermDeviceStatusAnsi(Widget w)     /* DSR CSIpn  */
 231 {
 232   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
 233   DtTermData vtd = ((DtTermWidget)w)->vt.td;
 234   ParserContext context ;
 235   char buf[100] ;
 236   int row,col,cnt ;
 237   Debug('P', fprintf(stderr,">>In func  _DtTermDeviceStatus\n")) ;
 238   context = GetParserContext(w) ;
 239   STORELASTARG(context) ;
 240   switch ( context->parms[1] )  {
 241      case 5: /* as far as I know, all's well... So send OK */
 242              sendEscSequence(w,"\033[0n") ;
 243              break;
 244      case 6:
 245        /* cursor could be past last row (for autowrap) */
 246        if ((col=tw->term.tpd->cursorColumn)>LASTCOLUMN(tw))
 247                      col=LASTCOLUMN(tw) ;
 248        row = tw->term.tpd->cursorRow+BASE ;
 249        if (vtd->originMode==True) row -= TOPMARGIN(tw) ;
 250        sprintf(buf,"\033[%d;%dR",row , col+BASE) ;
 251        sendEscSequence(w,buf) ;
 252        break ;
 253   }
 254 }
 255
 256 void
 257 _DtTermPModeSet(Widget w)   /*  DECSET CSI?ph */
 258 {
 259   ParserContext context ;
 260   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
 261   DtTermWidget vtw = (DtTermWidget)w;
 262   int i,cnt ;
 263   Debug('P', fprintf(stderr,">>In func _DtTermPModeSet\n")) ;
 264   context = GetParserContext(w) ;
 265   STORELASTARG(context) ;
 266   cnt = PCOUNT(context) ;
 267   for (i=1;i<=cnt;i++) {
 268       switch ( context->parms[i]) {
 269           /* from vt220 */
 270           case 1: /* Cursor key (Application) */
 271                   vtw->vt.td->applicationMode=True;
 272                   break;
 273           /* case 2:  can't return from vt52 mode */
 274           case 3: /* Column (132) */
 275                    if ( vtw->vt.c132 )  {  /* xterm allow 132 mode */
 276                      (void) _DtTermFuncClearBuffer(w, 0, fromParser);
 277                      vtw->term.tpd->cursorRow = TOPROW(vtw) ;
 278                      vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
 279                      vtw->term.tpd->scrollLockTopRow = TOPROW(vtw);
 280                      vtw->term.tpd->scrollLockBottomRow = BOTTOMROW(vtw) ;
 281                      XtVaSetValues(w, DtNcolumns, 132, NULL) ;
 282                      vtw->vt.td->col132Mode = True ;
 283                   }
 284                   break;
 285           case 4: /* Scroll (smooth) */
 286                   _DtTermPrimScrollComplete(w, True) ;
 287                   vtw->term.jumpScroll = False ;
 288                   break;
 289           case 5: /* Screen (Reverse) */
 290                   /*DKS: this is just to test out the functionality... */
 291                   vtw->term.reverseVideo = True;
 292                   /* clear the window to force refresh... */
 293                   (void) XClearArea(XtDisplay(w), XtWindow(w),
 294                         0, 0, 0, 0, True);
 295                   break;
 296           case 6: /* Origin mode (On) */
 297                   vtw->vt.td->originMode=True;
 298                   _DtTermPrimCursorMove(w, TOPMARGIN(vtw), 0);
 299                   break;
 300           case 7: /* Auto wrap (On) */
 301                   vtw->term.tpd->autoWrapRight=True ;
 302                   break;
 303           /* case 8: ** Auto repeat (On)
 304            *      ** This is handled by the X server
 305            *      break;
 306            *
 307            * case 18: ** Print form feed (On)
 308            *      break;
 309            * case 19: ** Print extent (full screen)
 310            *      break;
 311            */
 312           case 25: /* Text cursor enable (On) */
 313                   (void) _DtTermPrimSetCursorVisible(w, True);
 314                   break;
 315            /* from xterm */
 316           case 40: /*  80/132 mode  (allow) */
 317                   vtw->vt.c132 = True ;
 318                   break;
 319           case 41: /*  curses fix */
 320                   vtw->vt.td->fixCursesMode = True ;
 321                   break;
 322           case 44: /* margin bell (on) */
 323                   vtw->term.marginBell = True ;
 324                   break;
 325           case 45: /* Reverse-wraparound mode */
 326                   vtw->vt.td->reverseWrapMode=True;
 327                   break;
 328           case 46: /* logging (start)  */
 329                   vtw->term.logging = True ;
 330                   _DtTermPrimStartLog(w);
 331                   break;
 332           /*  case 47: ** screen buffer (alternate)
 333            *      break;
 334            *  case 1000: ** Send mouse x and y
 335            *      break;
 336            *  case 1001: ** Use hilite mouse tracking
 337            *      break;
 338            */
 339       }
 340    }
 341 }
 342
 343
 344 void
 345 _DtTermPModeReset(Widget w)   /* DECRST CSI?pl */
 346 {
 347   ParserContext context ;
 348   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
 349   DtTermWidget vtw = (DtTermWidget)w;
 350   int i,cnt ;
 351   Debug ('P', fprintf(stderr,">>In func _DtTermPModeReset\n")) ;
 352   context = GetParserContext(w) ;
 353   STORELASTARG(context) ;
 354   cnt = PCOUNT(context) ;
 355   for (i=1;i<=cnt;i++) {
 356       switch ( context->parms[i]) {
 357           /* from vt220 */
 358           case 1: /* Cursor key (Normal) */
 359                   vtw->vt.td->applicationMode=False;
 360                   break;
 361           /* case 2:   ** set vt52 mode */
 362           case 3: /* Column (80) */
 363                   if (vtw->vt.c132)  {   /* allow 132 mode */
 364                     (void) _DtTermFuncClearBuffer(w, 0, fromParser);
 365                     vtw->term.tpd->cursorRow = TOPROW(vtw) ;
 366                     vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
 367                     vtw->term.tpd->scrollLockTopRow = TOPROW(vtw);
 368                     vtw->term.tpd->scrollLockBottomRow = BOTTOMROW(vtw) ;
 369                     XtVaSetValues(w, DtNcolumns, 80, NULL) ;
 370                     vtw->vt.td->col132Mode = False ;
 371                   }
 372                   break;
 373           case 4: /* Scroll (jump) */
 374                   _DtTermPrimScrollComplete(w, True) ;
 375                   vtw->term.jumpScroll = True ;
 376                   break;
 377           case 5: /* Screen (normal ) */
 378                   /*DKS: this is just to test out the functionality... */
 379                   vtw->term.reverseVideo = False;
 380                   /* clear the window to force refresh... */
 381                   (void) XClearArea(XtDisplay(w), XtWindow(w),
 382                         0, 0, 0, 0, True);
 383                   break;
 384           case 6: /* Normal cursor (not Origin mode) */
 385                   vtw->vt.td->originMode=False;
 386                   _DtTermPrimCursorMove(w, 0, 0);
 387                   break;
 388           case 7: /* Auto wrap (Off) */
 389                   vtw->term.tpd->autoWrapRight=False;
 390                   break;
 391           /* case 8: ** Auto repeat (Off)
 392            *      ** implemented in the server
 393            *      break;
 394            * case 18: ** Print form feed (Off)
 395            *      break;
 396            * case 19: ** Print extent (scrolling region)
 397            *      break;
 398            */
 399           case 25: /* Text cursor enable (Off) */
 400                   (void) _DtTermPrimSetCursorVisible(w, False);
 401                   break;
 402            /* from xterm */
 403           case 40: /*  80/132 mode  (disallow) */
 404                   vtw->vt.c132 = False;
 405                   break;
 406           case 41: /*  curses fix  */
 407                   vtw->vt.td->fixCursesMode = False;
 408                   break;
 409           case 44: /* margin bell (off) */
 410                   vtw->term.marginBell = False ;
 411                   break;
 412           case 45: /* Reverse-wraparound mode */
 413                   vtw->vt.td->reverseWrapMode=False;
 414                   break;
 415           case 46: /* logging (stop )  */
 416                   vtw->term.logging = False ;
 417                   _DtTermPrimCloseLog(w) ;
 418                   break;
 419           /* case 47: ** screen buffer  (normal)
 420            *      break;
 421            * case 1000: ** don't send mouse x and y
 422            *      break;
 423            * case 1001: ** don't use hilite mouse tracking
 424            *      break;
 425            */
 426       }
 427   }
 428 }
 429
 430 void
 431 _DtTermSetMode(Widget w)   /* SM CSIph */
 432 {
 433   ParserContext context ;
 434   DtTermWidget vtw = (DtTermWidget)w ;
 435   int i,cnt ;
 436   Debug('P', fprintf(stderr,">>In func _DtTermSetMode\n")) ;
 437   context = GetParserContext(w) ;
 438   STORELASTARG(context) ;
 439   cnt = PCOUNT(context) ;
 440   for (i=1;i<=cnt;i++) {
 441       switch ( context->parms[i]) {
 442           case 2: /* KAM Keyboard Action (locked) */
 443                   vtw->term.tpd->keyboardLocked.escape=True ;
 444                   (void) _DtTermPrimInvokeStatusChangeCallback(w);
 445                   break;
 446           case 4: /* Insert mode */
 447                   _DtTermPrimInsertCharUpdate(w, DtTERM_INSERT_CHAR_ON) ;
 448                   break;
 449           case 12: /* SRM Send/Receive (Off) */
 450                   vtw->term.tpd->halfDuplex = False;
 451                   break;
 452           case 20: /* Line feed/newline (new line) */
 453                   vtw->term.tpd->autoLineFeed=True ;
 454                   break;
 455            }
 456     }
 457 }
 458
 459 void
 460 _DtTermResetMode(Widget w)   /* RM CSIpl  */
 461 {
 462   ParserContext context ;
 463   DtTermWidget vtw = (DtTermWidget)w ;
 464   int i,cnt ;
 465   Debug('P', fprintf(stderr,">>In func _DtTermResetMode\n")) ;
 466   context = GetParserContext(w) ;
 467   STORELASTARG(context) ;
 468   cnt = PCOUNT(context) ;
 469   for (i=1;i<=cnt;i++) {
 470       switch ( context->parms[i]) {
 471           case 2: /* KAM Keyboard Action (unlocked) */
 472                   vtw->term.tpd->keyboardLocked.escape=False;
 473                   (void) _DtTermPrimInvokeStatusChangeCallback(w);
 474                   break;
 475           case 4: /* Replace mode */
 476                   _DtTermPrimInsertCharUpdate(w, DtTERM_INSERT_CHAR_OFF) ;
 477                   break;
 478           case 12: /* SRM Send/Receive (On) */
 479                   vtw->term.tpd->halfDuplex = True;
 480                   break;
 481           case 20: /* Line feed/newline (line feed) */
 482                   vtw->term.tpd->autoLineFeed=False ;
 483                   break;
 484            }
 485     }
 486 }
 487
 488 void
 489 _DtTermCursorPos(Widget w)   /* CUP CSIp;pH */
 490 {
 491   ParserContext context ;
 492   DtTermWidget vtw = (DtTermWidget) w;
 493   int row, col;
 494   Debug( 'P', fprintf(stderr,">>In func _DtTermCursorPos\n")) ;
 495   context = GetParserContext(w) ;
 496   STORELASTARG(context) ;
 497   row = context->parms[1] ;
 498   col = context->parms[2] ;
 499   if (row)row-=BASE ;
 500   if (col)col-=BASE ;
 501   if (vtw->vt.td->originMode) row += vtw->term.tpd->scrollLockTopRow ;
 502   if (row > FLOOR(vtw)) row = FLOOR(vtw) ;
 503   if (col > LASTCOLUMN(vtw)) col = LASTCOLUMN(vtw) ;
 504   vtw->term.tpd->cursorRow = row ;
 505   vtw->term.tpd->cursorColumn = col ;
 506 }
 507
 508 void
 509 _DtTermEraseDisplay(Widget w)    /* ED CSIpJ */
 510 {
 511   int cnt ;
 512   DtTermWidget vtw = (DtTermWidget) w;
 513   ParserContext context ;
 514   DtEraseMode   eraseMode;
 515   int  row, col;
 516
 517   Debug('P', fprintf(stderr,">>In func _DtTermEraseDisplay\n")) ;
 518   context = GetParserContext(w) ;
 519   KILLWRAP(vtw) ;
 520   STORELASTARG(context) ;
 521   row = vtw->term.tpd->cursorRow;
 522   col = vtw->term.tpd->cursorColumn ;
 523
 524   /*
 525   ** pick the correct erase mode...
 526   */
 527   switch (context->parms[1])
 528   {
 529     case 0:
 530       eraseMode = eraseToEOB;
 531       break;
 532     case 1:
 533       eraseMode = eraseFromRow0Col0;
 534       break;
 535     case 2:
 536       eraseMode = eraseBuffer;
 537       break ;
 538    }
 539    _DtTermFuncEraseInDisplay(w, (int)eraseMode, fromParser);
 540   vtw->term.tpd->cursorRow = row;
 541   vtw->term.tpd->cursorColumn = col;
 542 }
 543
 544 void
 545 _DtTermEraseChars(Widget w)   /* ECH  CSIpX */
 546 {
 547   ParserContext context ;
 548   DtTermWidget vtw = (DtTermWidget) w;
 549   int row,col,cnt ;
 550   Debug('P', fprintf(stderr,">>In func _DtTermEraseChars\n")) ;
 551   KILLWRAP(vtw) ;
 552   context = GetParserContext(w) ;
 553   row = vtw->term.tpd->cursorRow ;
 554   col = vtw->term.tpd->cursorColumn ;
 555   STORELASTARG(context) ;
 556   cnt = context->parms[1] ;
 557   if (!(cnt))cnt=1;
 558   else
 559     if ( cnt > LASTCOLUMN(vtw)-col+1 ) cnt = LASTCOLUMN(vtw)-col+1 ;
 560
 561   _DtTermFuncEraseCharacter(w, cnt, fromParser);
 562 }
 563
 564 void
 565 _DtTermInsertChars(Widget w)    /* ICH  CSIp@ */
 566 {
 567     DtTermWidget vtw = (DtTermWidget) w;
 568     ParserContext context ;
 569     int row, col, cnt ;
 570     DtTermInsertCharMode        saveInsertCharMode;
 571
 572     Debug('P', fprintf(stderr,">>In func _DtTermInsertChars\n")) ;
 573     KILLWRAP(vtw) ;
 574     context = GetParserContext(w) ;
 575     vtw->term.tpd->parserNotInStartState = False ;
 576     row = vtw->term.tpd->cursorRow ;
 577     col = vtw->term.tpd->cursorColumn ;
 578     STORELASTARG(context) ;
 579     cnt = context->parms[1] ;
 580     if (!cnt)
 581         cnt++;
 582     else
 583         if (cnt > LASTCOLUMN(vtw) - col + 1)
 584             cnt = LASTCOLUMN(vtw) - col + 1;
 585
 586     /* save away the insert char mode... */
 587     saveInsertCharMode = vtw->term.tpd->insertCharMode;
 588
 589     /* turn on insert char mode.  We don't want to invoke any status
 590      * change callbacks, so we will justs set it directly...
 591      */
 592     vtw->term.tpd->insertCharMode = DtTERM_INSERT_CHAR_ON;
 593
 594     /* insert blanks... */
 595     while (cnt--)
 596         (void) _DtTermPrimInsertText(w,(unsigned char *) " ", 1) ;
 597
 598     /* restore the insert char mode... */
 599     vtw->term.tpd->insertCharMode = saveInsertCharMode;
 600
 601     _DtTermPrimCursorMove(w,row,col) ;
 602 }
 603
 604 void
 605 _DtTermCursorUp(Widget w)    /* CUU  CISpA */
 606 {
 607   ParserContext context ;
 608   DtTermWidget vtw = (DtTermWidget) w;
 609   int trow, row, tmargin, cnt;
 610   Debug('P', fprintf(stderr,">>In func _DtTermCursorUp\n")) ;
 611   context = GetParserContext(w) ;
 612   KILLWRAP(vtw) ;
 613   tmargin = TOPMARGIN(vtw) ;
 614   trow = TOPROW(vtw) ;
 615   STORELASTARG(context) ;
 616   cnt = context->parms[1] ;
 617   if (!(cnt))cnt=1;
 618   else if (cnt>MAXSHORT) cnt=MAXSHORT-100;
 619   row = vtw->term.tpd->cursorRow-cnt;
 620   /* are we about the top margin and did we actually cross it? */
 621   /* This handles the case top margin == top row   */
 622   if (row < tmargin && row+cnt >= tmargin) row = tmargin;
 623   _DtTermPrimCursorMove(w, row, vtw->term.tpd->cursorColumn) ;
 624 }
 625
 626 void
 627 _DtTermCursorDown(Widget w)    /* CUD CISpB */
 628 {
 629   ParserContext context ;
 630   DtTermWidget vtw = (DtTermWidget) w;
 631   int  bmargin, row, cnt, brow ;
 632   Debug('P', fprintf(stderr,">>In func _DtTermCursorDown\n")) ;
 633   context = GetParserContext(w) ;
 634   KILLWRAP(vtw) ;
 635   bmargin = BOTTOMMARGIN(vtw) ;
 636   brow = BOTTOMROW(vtw) ;
 637   STORELASTARG(context) ;
 638   cnt = context->parms[1] ;
 639   if (!(cnt))cnt=1;
 640   row = vtw->term.tpd->cursorRow+cnt;
 641   /* are we below bottom margin and did we actually cross it? */
 642   /* NOTE that this also handles the case when bmargin == brow */
 643   if (row > bmargin && row-cnt <= bmargin) row = bmargin;
 644   /* did we start below bottom margin and cross bottom row?   */
 645   if (row > brow && bmargin < brow ) row = brow;
 646   _DtTermPrimCursorMove(w, row, vtw->term.tpd->cursorColumn) ;
 647 }
 648
 649 void
 650 _DtTermCursorForward(Widget w)    /* CUF CISpC */
 651 {
 652   ParserContext context ;
 653   DtTermWidget vtw = (DtTermWidget) w;
 654   int col,lcol,cnt ;
 655   Debug('P', fprintf(stderr,">>In func _DtTermCursorForward\n")) ;
 656   context = GetParserContext(w) ;
 657   KILLWRAP(vtw) ;
 658   lcol = LASTCOLUMN(vtw) ;
 659   STORELASTARG(context) ;
 660   cnt = context->parms[1] ;
 661   if (!cnt) cnt=1;
 662   col = vtw->term.tpd->cursorColumn+cnt;
 663   if (col>lcol) col=lcol;
 664   _DtTermPrimCursorMove(w,vtw->term.tpd->cursorRow,col);
 665 }
 666
 667 void
 668 _DtTermCursorBack(Widget w)    /* CUB CISpD */
 669 {
 670   ParserContext context ;
 671   DtTermWidget vtw = (DtTermWidget) w;
 672   int i,k,j,row,col,fcol,cnt ;
 673   Debug('P', fprintf(stderr,">>In func _DtTermCursorBack\n")) ;
 674   KILLWRAP(vtw) ;
 675   context = GetParserContext(w) ;
 676   STORELASTARG(context) ;
 677   cnt = context->parms[1] ;
 678   fcol = FIRSTCOLUMN(vtw) ;
 679   row = vtw->term.tpd->cursorRow;
 680   col = vtw->term.tpd->cursorColumn;
 681   if (!cnt) cnt=1;
 682   if ((col -= cnt) < 0) {
 683      if(vtw->vt.td->reverseWrapMode && vtw->term.tpd->autoWrapRight) {
 684         int lastrow = BOTTOMROW(vtw);
 685         if (vtw->vt.td->originMode) {
 686            row-=TOPMARGIN(vtw) ;
 687            lastrow = BOTTOMMARGIN(vtw)-TOPMARGIN(vtw);
 688          }
 689         if((i = (j = LASTCOLUMN(vtw) + 1) * row + col) < 0) {
 690               k = j * (lastrow + 1);
 691               i += ((-i) / k + 1) * k;
 692         }
 693         row = i / j;
 694         if (vtw->vt.td->originMode) row+=TOPMARGIN(vtw);
 695         col = i % j;
 696       } else
 697         col = 0;
 698   }
 699   _DtTermPrimCursorMove(w,row,col);
 700 }
 701
 702 void
 703 _DtTermCursorToLineUp(Widget w)   /* CPL  CSIpF */
 704 {
 705   DtTermWidget vtw = (DtTermWidget) w;
 706   ParserContext context ;
 707   Debug('P', fprintf(stderr,">>In func _DtTermCursorToLineUp\n")) ;
 708   KILLWRAP(vtw) ;
 709   context = GetParserContext(w) ;
 710   vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
 711   _DtTermCursorUp(w) ;
 712 }
 713
 714 void
 715 _DtTermCursorToCol(Widget w)    /* CHA CSIpG */
 716 {
 717   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
 718   ParserContext context ;
 719   context = GetParserContext(w) ;
 720   STORELASTARG(context) ;
 721   if (!context->parms[1] ) context->parms[1]=1;
 722   if (context->parms[1]>tw->term.columns) context->parms[1]=tw->term.columns;
 723   tw->term.tpd->cursorColumn = context->parms[1] - BASE ;
 724 }
 725
 726 void
 727 _DtTermEraseInLine(Widget w)  /* EL  ESC[pK */
 728 {
 729   DtTermWidget vtw = (DtTermWidget) w;
 730   ParserContext context ;
 731   DtEraseMode eraseMode;
 732
 733
 734   Debug('P', fprintf(stderr,">>In func _DtTermEraseInLine\n")) ;
 735   KILLWRAP(vtw) ;
 736   context = GetParserContext(w) ;
 737   STORELASTARG(context) ;
 738   /*
 739   ** pick the correct erase mode...
 740   */
 741   switch ( context->parms[1] )
 742   {
 743     case 0:
 744       eraseMode = eraseToEOL;
 745       break;
 746
 747     case 1:
 748       eraseMode = eraseFromCol0;
 749       break;
 750
 751     case 2:
 752       eraseMode = eraseLine;
 753       break;
 754
 755   }
 756   _DtTermFuncEraseInLine(w, (int)eraseMode, fromParser);
 757 }
 758
 759 void
 760 _DtTermInsertLines(Widget w)  /* IL CSIpL */
 761 {
 762   DtTermWidget vtw = (DtTermWidget) w;
 763   ParserContext context ;
 764   int lines , cnt ;
 765   Debug('P', fprintf(stderr,">>In func _DtTermInsertLines\n")) ;
 766   if ( vtw->term.tpd->cursorRow < TOPMARGIN(vtw) ||
 767       vtw->term.tpd->cursorRow > BOTTOMMARGIN(vtw) )/*outside scrolling region*/
 768      return ;
 769   context = GetParserContext(w) ;
 770   KILLWRAP((DtTermWidget)w) ;
 771   STORELASTARG(context) ;
 772   cnt=context->parms[1];
 773   if (!cnt)cnt++;
 774   lines  = BOTTOMMARGIN(vtw) -  vtw->term.tpd->cursorRow + 1;
 775   if (cnt > lines) cnt=lines ;
 776   _DtTermFuncInsertLine(w,cnt,fromParser) ;
 777 }
 778
 779 void
 780 _DtTermDeleteLines(Widget w)   /* DL CSIpM */
 781 {
 782   DtTermWidget vtw = (DtTermWidget) w;
 783   ParserContext context ;
 784   int cnt ;
 785   Debug('P', fprintf(stderr,">>In func _DtTermDeleteLines\n")) ;
 786
 787   if ( vtw->term.tpd->cursorRow < TOPMARGIN(vtw) ||
 788       vtw->term.tpd->cursorRow > BOTTOMMARGIN(vtw) )  /* outside scrolling region*/
 789      return ;
 790   KILLWRAP((DtTermWidget)w) ;
 791   context = GetParserContext(w) ;
 792   STORELASTARG(context) ;
 793   cnt = context->parms[1];
 794   if(!cnt)cnt++;
 795   _DtTermFuncDeleteLine(w,cnt,fromParser) ;
 796 }
 797
 798 void
 799 _DtTermDeleteChars(Widget w)   /* DCH CSIpP */
 800 {
 801   ParserContext context ;
 802   DtTermWidget vtw = (DtTermWidget) w;
 803   int cnt ;
 804   Debug('P', fprintf(stderr,">>In func _DtTermDeleteChars\n")) ;
 805   KILLWRAP(vtw) ;
 806   context = GetParserContext(w) ;
 807   STORELASTARG(context) ;
 808   cnt= context->parms[1];
 809   if (!cnt) cnt++;
 810   else if (cnt>MAXSHORT) cnt=MAXSHORT-100;
 811   _DtTermFuncDeleteChar(w,cnt,fromParser) ;
 812 }
 813
 814 void
 815 _DtTermNextLine(Widget w) /* NEL ESCE */
 816 {
 817   DtTermWidget vtw = (DtTermWidget) w;
 818   int brow;
 819   Debug('P', fprintf(stderr,">>In func _DtTermNextLine\n")) ;
 820   vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
 821   _DtTermIndex(w) ;  /* use IND */
 822 }
 823
 824 void
 825 _DtTermReverseIndex(Widget w) /* RI ESCM */
 826 {
 827   DtTermWidget vtw = (DtTermWidget) w;
 828   int tmargin, trow, col;
 829   Debug('P', fprintf(stderr,">>In func _DtTermReverseIndex\n")) ;
 830   KILLWRAP(vtw) ;
 831   trow = TOPROW(vtw) ;
 832   tmargin = TOPMARGIN(vtw) ;
 833   col = vtw->term.tpd->cursorColumn ;
 834   if ( vtw->term.tpd->cursorRow == tmargin) {
 835        _DtTermFuncInsertLine(w,1,fromParser) ;
 836        /* _DtTermFuncInsertLine sets column to first column */
 837        vtw->term.tpd->cursorColumn = col ;
 838    }
 839   else if (vtw->term.tpd->cursorRow > trow){
 840            vtw->term.tpd->cursorRow-- ;
 841    }
 842 }
 843
 844 void
 845 _DtTermIndex(Widget w) /* IND  ESCD */
 846 {
 847   DtTermWidget vtw = (DtTermWidget) w;
 848   int bmargin, brow ;
 849   Debug('P', fprintf(stderr,">>In func _DtTermIndex\n")) ;
 850   KILLWRAP(vtw) ;
 851   brow = BOTTOMROW(vtw) ;
 852   bmargin = BOTTOMMARGIN(vtw) ;
 853   if ( vtw->term.tpd->cursorRow == bmargin) {
 854        (void) _DtTermPrimScrollText(w, 1);
 855    }
 856   else if (vtw->term.tpd->cursorRow < brow){
 857          vtw->term.tpd->cursorRow++ ;
 858    }
 859   (void) _DtTermPrimFillScreenGap(w);
 860 }
 861
 862 void
 863 _DtTermScrollingRegion(Widget w)   /* DECSTBM  CSIp;pr */
 864 {
 865   DtTermWidget vtw = (DtTermWidget)w ;
 866   ParserContext context ;
 867   int row1,row2 ;
 868   Debug('P', fprintf(stderr,">>In func _DtTermScrollingRegion\n")) ;
 869   context = GetParserContext(w) ;
 870   STORELASTARG(context) ;
 871   row1 = context->parms[1] ;
 872   row2 = context->parms[2] ;
 873   if (!row1) row1 = 1 ;
 874   if (!row2 || row2>vtw->term.rows) row2 = vtw->term.rows ;
 875   row1-=BASE ;
 876   row2-=BASE ;
 877   if ( row1 < row2 ) {
 878     if ( row1 == TOPROW(vtw) && row2 == BOTTOMROW(vtw))
 879        vtw->term.tpd->memoryLockMode=SCROLL_LOCKoff ;
 880     else
 881        vtw->term.tpd->memoryLockMode=SCROLL_LOCKon ;
 882     vtw->term.tpd->scrollLockTopRow = row1 ;
 883     vtw->term.tpd->scrollLockBottomRow = row2 ;
 884     if (vtw->vt.td->originMode) _DtTermPrimCursorMove(w,row1,0) ;
 885     else  _DtTermPrimCursorMove(w,0,0) ;
 886   }
 887 }
 888
 889 void
 890 _DtTermCharAttributes(Widget w)   /* SGR CSIpm */
 891 {
 892   ParserContext context ;
 893   int i,cnt ;
 894   Debug('P', fprintf(stderr,">>In func _DtTermCharAttributes\n")) ;
 895   context = GetParserContext(w) ;
 896   STORELASTARG(context) ;
 897   cnt = PCOUNT(context) ;
 898   if(PCOUNT(context)) {
 899     for (cnt=1; cnt <= PCOUNT(context); cnt++)
 900        _DtTermVideoEnhancement(w,context->parms[cnt]) ;
 901    }
 902   else
 903    _DtTermVideoEnhancement(w,0) ;
 904 }
 905
 906 void
 907 _DtTermDeviceAttributes(Widget w)    /* DA CSIpc */
 908 {
 909   DtTermWidget vtw = (DtTermWidget) w;
 910   ParserContext context ;
 911   int cnt ;
 912   char buf[50];
 913   Debug('P', fprintf(stderr,">>In func _DtTermDeviceAttributes\n")) ;
 914   context = GetParserContext(w) ;
 915   STORELASTARG(context) ;
 916   switch(context->parms[1]) {
 917     case 0:
 918          switch(vtw->vt.td->terminalId ) {
 919             case 100:
 920                      sprintf(buf,"\033[?%d;%dc",1,2) ;
 921                      break;
 922             case 101:
 923                      sprintf(buf,"\033[?%d;%dc",1,0) ;
 924                      break;
 925             case 102:
 926                      sprintf(buf,"\033[?%dc",6) ;
 927                      break;
 928             case 220:
 929                 /*  class 2 terminal (62), 132 columns (1), printer port (2),
 930                  *  selective erase (6), DRCS (7), UDK (8),
 931                  *  national replacement char sets
 932                  */
 933                 sprintf(buf,"\033[?%d;%d;%d;%d;%d;%d;%dc",62,1,2,6,7,8,9) ;
 934                 break;
 935           }
 936         sendEscSequence(w,buf) ;
 937         break;
 938   }
 939 }
 940
 941 void
 942 _DtTermChangeTextParam(Widget w)  /* xterm  CSIp;pcCtrl-G  */
 943 {
 944   ParserContext context ;
 945   DtTermWidget tw = (DtTermWidget) w;
 946   DtTermData vtd = tw->vt.td;
 947   Widget sw;
 948   int i ;
 949   Arg arg[5];
 950   Debug('P', fprintf(stderr,">>In func _DtTermChangeTextParam\n")) ;
 951   context = GetParserContext(w) ;
 952   i=0;
 953   for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
 954   /*
 955    *  context->parms[1] is inited to 0, so if no numeric param was entered,
 956    *  we default appropriately to case 0.
 957    */
 958   switch(context->parms[1]) {
 959     case 0: /* change Icon name and Window title */
 960             XtSetArg(arg[i], XmNtitle, context->stringParms[0].str); i++;
 961             XtSetArg(arg[i], XmNiconName, context->stringParms[0].str); i++;
 962             XtSetValues(sw,arg,i) ;
 963             break;
 964     case 1: /* change Icon name */
 965             XtSetArg(arg[i], XmNiconName, context->stringParms[0].str); i++;
 966             XtSetValues(sw,arg,i) ;
 967             break;
 968     case 2: /* change Window title */
 969             XtSetArg(arg[i], XmNtitle, context->stringParms[0].str); i++;
 970             XtSetValues(sw,arg,i) ;
 971             break;
 972     case 3: /* change current working directory */
 973             tw->term.subprocessCWD = XtRealloc(tw->term.subprocessCWD,
 974                     strlen((char *) context->stringParms[0].str) + 1);
 975             (void) strcpy(tw->term.subprocessCWD,
 976                     (char *) context->stringParms[0].str);
 977             break;
 978    /*  These are handled by xterm but not by us.
 979     case 46:  Change log file to context->stringParms[0]
 980             break;
 981     case 50: ** change font to context->stringParms[0]
 982             break;
 983    */
 984   }
 985 }
 986
 987 void
 988 _DtTermTabClear(Widget w)    /*  TBC CSIpg */
 989 {
 990   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
 991   TermBuffer tb = tw->term.tpd->termBuffer ;
 992   ParserContext context ;
 993   int type ;
 994   Debug('P', fprintf(stderr,">>In func _DtTermTabClear\n")) ;
 995   context = GetParserContext(w) ;
 996   STORELASTARG(context) ;
 997   type = context->parms[1] ;
 998   switch ( type ) {
 999     case 0:(void)_DtTermPrimBufferClearTab(tb,tw->term.tpd->cursorColumn) ;
1000            break ;
1001     case 3: (void)_DtTermPrimBufferClearAllTabs(tb) ;
1002            break ;
1003    }
1004 }
1005
1006 void
1007 _DtTermRequestParam(Widget w) /* DECREQTPARM CSIpx */
1008 {
1009     ParserContext context ;
1010     int row ;
1011     char buf[100];
1012     Debug('P', fprintf(stderr,">>In func _DtTermRequestParam\n")) ;
1013     context = GetParserContext(w) ;
1014     STORELASTARG(context) ;
1015     row = context->parms[1] ;
1016     if ( row < 2) {
1017        row += 2;
1018
1019        /* row (?), 1 no parity, 1 eight bits, 112 xmit 9600 baud,
1020         * 112, receive 9600 baud, 1 clock multiplier (?),
1021         * 0 STP flags (?)   These are from xterm file 'charproc.c'.
1022         */
1023        sprintf(buf,"\033[%d;%d;%d;%d;%d;%d;%dx",row,1,1,112,112,1,0) ;
1024        sendEscSequence(w,buf) ;
1025      }
1026 }
1027
1028
1029 void
1030 _DtTermTabSet(Widget w) /* HTS ESCH */
1031 {
1032   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1033   TermBuffer tb = tw->term.tpd->termBuffer ;
1034   Debug('P', fprintf(stderr,">>In func _DtTermTabSet\n")) ;
1035   (void)_DtTermPrimBufferSetTab(tb,tw->term.tpd->cursorColumn) ;
1036 }
1037
1038 void
1039 _DtTermSaveCursor(Widget w) /* DECSC ESC7 */
1040 {
1041   DtTermWidget vtw = (DtTermWidget) w;
1042   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1043   DtTermBuffer tb = (DtTermBuffer)tw->term.tpd->termBuffer ;
1044   DtTermData vtd = vtw->vt.td;
1045
1046   Debug('P', fprintf(stderr,">>In func _DtTermSaveCursor\n")) ;
1047   vtd->saveCursor.cursorRow = vtw->term.tpd->cursorRow ;
1048   vtd->saveCursor.cursorColumn = vtw->term.tpd->cursorColumn ;
1049   vtd->saveCursor.originMode    = vtw->vt.td->originMode ;
1050   /* The following is save at the TermPrim level */
1051   /* vtw->vt.td->saveCursor.wrapMode    = */
1052   vtd->saveCursor.enhVideoState = vtd->enhVideoState ;
1053   vtd->saveCursor.enhFieldState = vtd->enhFieldState  ;
1054   vtd->saveCursor.enhFgColorState = vtd->enhFgColorState;
1055   vtd->saveCursor.enhBgColorState = vtd->enhBgColorState;
1056   vtd->saveCursor.GL = vtd->GL;
1057   vtd->saveCursor.GR = vtd->GR;
1058   vtd->saveCursor.G0 = vtd->G0;
1059   vtd->saveCursor.G1 = vtd->G1;
1060   vtd->saveCursor.G2 = vtd->G2;
1061   vtd->saveCursor.G3 = vtd->G3;
1062   vtd->saveCursor.singleShiftFont = vtd->singleShiftFont;
1063   vtd->saveCursor.singleShiftPending = vtd->singleShiftPending;
1064 }
1065
1066 void
1067 _DtTermRestoreCursor(Widget w) /* DECRC ESC8 */
1068 {
1069   DtTermPrimitiveWidget      tw        = (DtTermPrimitiveWidget) w;
1070   DtTermPrimData        tpd        = tw->term.tpd;
1071   DtTermWidget vtw = (DtTermWidget) w;
1072   DtTermData vtd = vtw->vt.td;
1073
1074   Debug('P', fprintf(stderr,">>In func _DtTermRestoreCursor\n")) ;
1075   tpd->cursorRow = vtd->saveCursor.cursorRow ;
1076   tpd->cursorColumn = vtd->saveCursor.cursorColumn ;
1077   vtw->vt.td->originMode = vtd->saveCursor.originMode    ;
1078   tpd->autoWrapRight = vtd->saveCursor.wrapMode ;
1079   vtd->enhVideoState  = vtd->saveCursor.enhVideoState ;
1080   vtd->enhFieldState  = vtd->saveCursor.enhFieldState ;
1081   vtd->enhFgColorState = vtd->saveCursor.enhFgColorState;
1082   vtd->enhBgColorState = vtd->saveCursor.enhBgColorState;
1083   vtd->GR = vtd->saveCursor.GR;
1084   vtd->GL = vtd->saveCursor.GL;
1085   vtd->G0 = vtd->saveCursor.G0;
1086   vtd->G1 = vtd->saveCursor.G1;
1087   vtd->G2 = vtd->saveCursor.G2;
1088   vtd->G3 = vtd->saveCursor.G3;
1089   vtd->singleShiftFont = vtd->saveCursor.singleShiftFont;
1090   vtd->singleShiftPending = vtd->saveCursor.singleShiftPending;
1091   (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1092               tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhVideo,
1093               vtd->enhVideoState);
1094   (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1095               tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhField,
1096               vtd->enhFieldState);
1097   (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1098               tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhFont,
1099               *(vtd->GL));
1100   (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1101               tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhBgColor,
1102               vtd->saveCursor.enhBgColorState);
1103   (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1104               tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhFgColor,
1105               vtd->saveCursor.enhFgColorState);
1106   if ( vtd->originMode ) {
1107      if (tpd->cursorRow < tpd->scrollLockTopRow )
1108         tpd->cursorRow = tpd->scrollLockTopRow ;
1109      else if (tpd->cursorRow > tpd->scrollLockBottomRow )
1110         tpd->cursorRow = tpd->scrollLockBottomRow ;
1111   }
1112 }
1113
1114 void
1115 _DtTermAppKeypad(Widget w)  /* DECPAM  ESC= */
1116 {
1117   DtTermWidget vtw = (DtTermWidget) w;
1118   Debug('P', fprintf(stderr,">>In func _DtTermAppKeypad\n")) ;
1119   vtw->vt.td->applicationKPMode=True;
1120 }
1121
1122 void
1123 _DtTermNormalKeypad(Widget w) /* DECPNM ESC> */
1124 {
1125   DtTermWidget vtw = (DtTermWidget) w;
1126   Debug('P', fprintf(stderr,">>In func _DtTermNormalKeypad\n")) ;
1127   vtw->vt.td->applicationKPMode=False;
1128 }
1129
1130 void
1131 _DtTermS8C1T(Widget w)   /* S8C1T  ESCG  */
1132 {
1133   DtTermWidget vtw = (DtTermWidget) w;
1134   Debug('P', fprintf(stderr,">>In func _vt8CIT\n")) ;
1135   vtw->vt.td->S8C1TMode=True;
1136 }
1137
1138 void
1139 _DtTermS7C1T(Widget w)   /* S7C1T  ESCF */
1140 {
1141   DtTermWidget vtw = (DtTermWidget) w;
1142   Debug('P', fprintf(stderr,">>In func _vt8CIT\n")) ;
1143   vtw->vt.td->S8C1TMode=False;
1144 }
1145
1146 void
1147 _DtTermSetCompatLevel(Widget w)   /* DECSCL CSI p;p"p (last p literal) */
1148 {
1149   ParserContext context ;
1150   DtTermWidget vtw = (DtTermWidget) w;
1151   Debug('P', fprintf(stderr,">>In func _DtTermSetCompatLevel\n")) ;
1152   context = GetParserContext(w) ;
1153   STORELASTARG(context) ;
1154   vtw->vt.td->compatLevel= 2;  /* assume vt200 mode */
1155   switch ( PCOUNT(context) )  {
1156       case 1: switch (context->parms[1]) {
1157                  case 61:  vtw->vt.td->compatLevel= 1;
1158                            vtw->vt.td->S8C1TMode=False;
1159                            break;
1160                  case 62:  vtw->vt.td->S8C1TMode=True;
1161                            break;
1162                }
1163               break;
1164       case 2: switch (context->parms[2]) {
1165                  case 0:
1166                  case 2: vtw->vt.td->S8C1TMode=True;
1167                          break;
1168                  case 1:
1169                          vtw->vt.td->S8C1TMode=False;
1170                          break;
1171                }
1172     }
1173 }
1174
1175 void
1176 _DtTermInvokeG3(Widget w)  /* LS3R  ESC| */
1177 {
1178   ParserContext context ;
1179   int cnt ;
1180   Debug('P', fprintf(stderr,">>In func _DtTermInvokeG3\n")) ;
1181   context = GetParserContext(w) ;
1182 }
1183
1184 void
1185 _DtTermInvokeG2(Widget w)  /* LS3R  ESC} */
1186 {
1187   ParserContext context ;
1188   int cnt ;
1189   Debug('P', fprintf(stderr,">>In func _DtTermInvokeG2\n")) ;
1190   context = GetParserContext(w) ;
1191 }
1192
1193 void
1194 _DtTermScrollUp(Widget w)    /* SU CSIpS */
1195 {
1196     ParserContext context ;
1197     DtTermWidget vtw = (DtTermWidget) w;
1198     int row,col,cnt ;
1199
1200     Debug('P', fprintf(stderr,">>In func _DtTermScrollUp\n")) ;
1201 #define  EXIT_IF_OUTSIDE_SR(w) if((w)->term.tpd->scrollLockTopRow >  \
1202                                    (w)->term.tpd->cursorRow  ||    \
1203                                    (w)->term.tpd->scrollLockBottomRow < \
1204                                    (w)->term.tpd->cursorRow)   \
1205                                    return;
1206     EXIT_IF_OUTSIDE_SR(vtw)
1207     KILLWRAP(vtw) ;
1208     context = GetParserContext(w) ;
1209     row = vtw->term.tpd->cursorRow;
1210     col = vtw->term.tpd->cursorColumn;
1211     STORELASTARG(context) ;
1212     if (!context->parms[1])
1213         context->parms[1] = 1;
1214     else if (context->parms[1] > MAXSHORT)
1215         context->parms[1] = MAXSHORT - 100;
1216
1217     /* clip the number of rows to the scroll region... */
1218     if (context->parms[1] > (vtw->term.tpd->scrollLockBottomRow -
1219             vtw->term.tpd->scrollLockTopRow + 1)) {
1220         context->parms[1] = vtw->term.tpd->scrollLockBottomRow -
1221                 vtw->term.tpd->scrollLockTopRow + 1;
1222     }
1223
1224     vtw->term.tpd->cursorRow = TOPMARGIN(vtw) ;
1225     _DtTermFuncDeleteLine(w, context->parms[1], fromParser);
1226     vtw->term.tpd->cursorRow = row;
1227     vtw->term.tpd->cursorColumn = col;
1228 }
1229
1230 void
1231 _DtTermScrollDown(Widget w)  /* SD CSIpT */
1232 {
1233     ParserContext context ;
1234     DtTermWidget vtw = (DtTermWidget) w;
1235     int row,col,cnt ;
1236
1237     Debug('P', fprintf(stderr,">>In func _DtTermScrollDown\n")) ;
1238     EXIT_IF_OUTSIDE_SR(vtw)
1239     KILLWRAP(vtw) ;
1240     context = GetParserContext(w) ;
1241     row = vtw->term.tpd->cursorRow;
1242     col = vtw->term.tpd->cursorColumn ;
1243     STORELASTARG(context) ;
1244     if (!context->parms[1])
1245         context->parms[1] = 1;
1246     else if (context->parms[1] > MAXSHORT)
1247         context->parms[1] = MAXSHORT - 100;
1248
1249     /* clip the number of rows to the scroll region... */
1250     if (context->parms[1] > (vtw->term.tpd->scrollLockBottomRow -
1251             vtw->term.tpd->scrollLockTopRow) + 1) {
1252         context->parms[1] = vtw->term.tpd->scrollLockBottomRow -
1253                 vtw->term.tpd->scrollLockTopRow + 1;
1254     }
1255
1256     vtw->term.tpd->cursorRow = TOPMARGIN(vtw) ;
1257     _DtTermFuncInsertLine(w, context->parms[1], fromParser) ;
1258     vtw->term.tpd->cursorRow = row;
1259     vtw->term.tpd->cursorColumn = col;
1260 }
1261
1262 void
1263 _DtTermRestoreModeValues(Widget w)  /* xterm - Restore DEC mode values CSI?pr */
1264 {
1265   ParserContext context ;
1266   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1267   DtTermWidget vtw = (DtTermWidget)w;
1268   DtTermData vtd = vtw->vt.td;
1269   int i,cnt ;
1270   Debug ('P', fprintf(stderr,">>In func _DtTermPModeReset\n")) ;
1271   context = GetParserContext(w) ;
1272   STORELASTARG(context) ;
1273   cnt = PCOUNT(context) ;
1274   for (i=1;i<=cnt;i++) {
1275       switch ( context->parms[i]) {
1276           /* from vt220 */
1277           case 1: /* Cursor key (Normal/Application) */
1278                   vtd->applicationMode = vtd->saveDECMode.applicationMode ;
1279                   break;
1280 #ifdef  NOT_SUPPORTED
1281           case 2:  /* set vt52 mode */
1282                   break;
1283 #endif  /* NOT_SUPPORTED */
1284           case 3: /* Columns (80/132) */
1285                   vtd->col132Mode = vtd->saveDECMode.col132Mode ;
1286                   break;
1287           case 4: /* Scroll Mode ( jump/smooth ) */
1288                   _DtTermPrimScrollComplete(w, True) ;
1289                   vtw->term.jumpScroll = vtd->saveDECMode.jumpScrollMode ;
1290                   break;
1291           case 5: /* Screen mode */
1292                   vtw->term.reverseVideo = vtd->saveDECMode.inverseVideoMode ;
1293                   break;
1294           case 6: /*  Origin mode (on/off)*/
1295                   vtd->originMode = vtd->saveDECMode.originMode ;
1296                   break;
1297           case 7: /* Auto wrap (On/Off) */
1298                   vtw->term.tpd->autoWrapRight = vtd->saveDECMode.wrapMode ;
1299                   break;
1300           case 8: /* Auto repeat (Off) */
1301                   /* implemented in the server */
1302                   break;
1303 #ifdef  NOT_SUPPORTED
1304           case 18: /* Print form feed (Off) */
1305                   break;
1306           case 19: /* Print extent (scrolling region) */
1307                   break;
1308 #endif  /* NOT_SUPPORTED */
1309           case 25: /* Text cursor enable (Off) */
1310                   _DtTermPrimSetCursorVisible(w,
1311                         vtd->saveDECMode.cursorVisible);
1312                   break;
1313
1314            /* from xterm */
1315           case 40: /*  80/132 mode  (disallow/allow) */
1316                   vtw->vt.c132 = vtd->saveDECMode.allow80_132ColMode;
1317                   break;
1318           case 41: /*  curses fix  (off/on) */
1319                   vtd->fixCursesMode = vtd->saveDECMode.fixCursesMode;
1320                   break;
1321           case 44: /* margin bell (off/on) */
1322                   vtw->term.marginBell = vtd->saveDECMode.marginBellMode;
1323                   break;
1324           case 45: /* Reverse-wraparound mode */
1325                   vtd->reverseWrapMode = vtd->saveDECMode.reverseWrapMode ;
1326                   break;
1327           case 46: /* logging (stop/start )  */
1328                   if (vtd->saveDECMode.logging) {
1329                       vtw->term.logging = True ;
1330                       _DtTermPrimStartLog(w);
1331                   } else {
1332                       vtw->term.logging = False ;
1333                       _DtTermPrimCloseLog(w) ;
1334                   }
1335                   break;
1336 #ifdef  NOT_SUPPORTED
1337           case 47: /* screen buffer  (normal) */
1338                   break;
1339           case 1000: /* don't send mouse x and y */
1340                   break;
1341           case 1001: /* don't use hilite mouse tracking */
1342                   break;
1343 #endif  /* NOT_SUPPORTED */
1344       }
1345    }
1346 }
1347
1348 void
1349 _DtTermSaveModeValues(Widget w)  /* xterm - Save DEC mode values CSI?ps  */
1350 {
1351   ParserContext context ;
1352   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1353   DtTermWidget vtw = (DtTermWidget)w;
1354   DtTermData vtd = vtw->vt.td;
1355   int i,cnt ;
1356   Debug ('P', fprintf(stderr,">>In func _DtTermPModeReset\n")) ;
1357   context = GetParserContext(w) ;
1358   STORELASTARG(context) ;
1359   cnt = PCOUNT(context) ;
1360   for (i=1;i<=cnt;i++) {
1361       switch ( context->parms[i]) {
1362           /* from vt220 */
1363           case 1: /* Cursor key (Normal/Application) */
1364                   vtd->saveDECMode.applicationMode = vtd->applicationMode ;
1365                   break;
1366 #ifdef  NOT_SUPPORTED
1367           case 2:  /* set vt52 mode */
1368                   break;
1369 #endif  /* NOT_SUPPORTED */
1370           case 3: /* Columns (80/132) */
1371                   vtd->saveDECMode.col132Mode = vtd->col132Mode ;
1372                   break;
1373           case 4: /* Scroll Mode ( jump/smooth ) */
1374                   vtd->saveDECMode.jumpScrollMode = vtw->term.jumpScroll ;
1375                   break;
1376           case 5: /* Screen mode */
1377                   vtd->saveDECMode.inverseVideoMode = vtw->term.reverseVideo ;
1378                   break;
1379           case 6: /*  Origin mode (on/off)*/
1380                   vtd->saveDECMode.originMode = vtd->originMode ;
1381                   break;
1382           case 7: /* Auto wrap (On/Off) */
1383                   vtd->saveDECMode.wrapMode = vtw->term.tpd->autoWrapRight ;
1384                   break;
1385           case 8: /* Auto repeat (Off) */
1386                   /* implemented in the server */
1387                   break;
1388 #ifdef  NOT_SUPPORTED
1389           case 18: /* Print form feed (Off) */
1390                   break;
1391           case 19: /* Print extent (scrolling region) */
1392                   break;
1393 #endif  /* NOT_SUPPORTED */
1394           case 25: /* Text cursor enable (Off) */
1395                   vtd->saveDECMode.cursorVisible =
1396                             _DtTermPrimGetCursorVisible(w);
1397                   break;
1398            /* from xterm */
1399           case 40: /*  80/132 mode  (disallow/allow) */
1400                   vtd->saveDECMode.allow80_132ColMode = vtw->vt.c132;
1401                   break;
1402           case 41: /*  curses fix  (off/on) */
1403                   vtd->saveDECMode.fixCursesMode = vtd->fixCursesMode ;
1404                   break;
1405           case 44: /* margin bell (off/on) */
1406                   vtd->saveDECMode.marginBellMode = vtw->term.marginBell ;
1407                   break;
1408           case 45: /* Reverse-wraparound mode */
1409                   vtd->saveDECMode.reverseWrapMode = vtd->reverseWrapMode ;
1410                   break;
1411           case 46: /* logging (stop/start ) */
1412                   vtd->saveDECMode.logging = vtw->term.logging;
1413                   break;
1414 #ifdef  NOT_SUPPORTED
1415           case 47: /* screen buffer  (normal) */
1416                   break;
1417           case 1000: /* don't send mouse x and y */
1418                   break;
1419           case 1001: /* don't use hilite mouse tracking */
1420                   break;
1421 #endif  /* NOT_SUPPORTED */
1422       }
1423    }
1424 }
1425
1426
1427 void
1428 _DtTermAlignTest(Widget w)     /* DECALN ESC#8 */
1429 {
1430   DtTermWidget vtw = (DtTermWidget) w;
1431   int tlrow, blrow, cnt ;
1432   Debug('P', fprintf(stderr,">>In func _DtTermAlignTest\n")) ;
1433   vtw->term.tpd->parserNotInStartState = False ;
1434   tlrow =  vtw->term.tpd->scrollLockTopRow ;
1435   blrow =  vtw->term.tpd->scrollLockBottomRow ;
1436   vtw->term.tpd->scrollLockTopRow = TOPROW(w) ; ;
1437   vtw->term.tpd->scrollLockBottomRow = BOTTOMROW(vtw) ;
1438   cnt = (BOTTOMROW(vtw)+BASE)*(LASTCOLUMN(vtw)+BASE);
1439   vtw->term.tpd->cursorColumn = FIRSTCOLUMN(w) ;
1440   vtw->term.tpd->cursorRow    = TOPROW(w) ;
1441   while(cnt--) _DtTermPrimInsertText(w,(unsigned char *) "E", 1) ;
1442   vtw->term.tpd->scrollLockTopRow = tlrow ;
1443   vtw->term.tpd->scrollLockBottomRow = blrow ;
1444   vtw->term.tpd->cursorRow = CEILING(vtw) ;
1445   vtw->term.tpd->cursorColumn = FIRSTCOLUMN(w) ;
1446 }
1447
1448 void
1449 _DtTermInvokeG1(Widget w)     /* ESC~ESC */
1450 {
1451   ParserContext context ;
1452   int cnt ;
1453   Debug('P', fprintf(stderr,">>In func _DtTermInvokeG1\n")) ;
1454   context = GetParserContext(w) ;
1455 }
1456
1457 void
1458 _DtTermSelEraseInLine(Widget w) /* DECSEL ESC?pK */
1459 {
1460     DtTermWidget vtw = (DtTermWidget) w;
1461     DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1462     TermBuffer tb = tw->term.tpd->termBuffer ;
1463     DtTermPrimData  tpd = tw->term.tpd;
1464     DtTermData  td = vtw->vt.td;
1465     ParserContext context ;
1466     enhValues evalues;
1467     int c,col1,col2,col,row ;
1468     short cnt ;
1469     DtTermInsertCharMode        saveInsertCharMode;
1470
1471     Debug('P', fprintf(stderr,">>In func _DtTermSelEraseInLine\n")) ;
1472     KILLWRAP(vtw) ;
1473     context = GetParserContext(w) ;
1474     STORELASTARG(context) ;
1475     col1 = FIRSTCOLUMN(vtw) ;
1476     col2 = LASTCOLUMN(vtw) ;
1477     switch ( context->parms[1] )  {
1478     case 0:
1479         col1= tpd->cursorColumn;
1480         break;
1481     case 1:
1482         col2 = tpd->cursorColumn;
1483         break;
1484     case 2:
1485         break ;
1486     default:
1487         return ;
1488     }
1489     /* save away the current cursor position... */
1490     col = tpd->cursorColumn ;
1491     row = tpd->cursorRow    ;
1492
1493     /* save away the current insert mode... */
1494     saveInsertCharMode = vtw->term.tpd->insertCharMode;
1495
1496     /* insert char needs to be off... */
1497     tpd->insertCharMode = DtTERM_INSERT_CHAR_OFF;
1498
1499     tpd->parserNotInStartState = False ;
1500     c = col1;
1501
1502     while (c <= col2) {
1503         (void)_DtTermPrimBufferGetEnhancement(tb, tpd->cursorRow,
1504                     c, &evalues, &cnt, countAll);
1505         if (!cnt)
1506             break ;
1507         if (evalues[(int)enhField] == FIELD_UNPROTECT) {
1508             (void) _DtTermPrimBufferSetEnhancement(tb, tpd->cursorRow,
1509                     c, enhVideo, evalues[(int)enhVideo]);
1510             (void) _DtTermPrimBufferSetEnhancement(tb, tpd->cursorRow,
1511                     c, enhFgColor, evalues[(int)enhFgColor]);
1512             (void) _DtTermPrimBufferSetEnhancement(tb, tpd->cursorRow,
1513                     c, enhBgColor, evalues[(int)enhBgColor]);
1514             while ((c <= col2) && cnt--) {
1515                 tpd->cursorColumn = c;
1516                 (void) _DtTermPrimInsertText(w, (unsigned char *) " ", 1);
1517                 c++;
1518             }
1519         } else {
1520             c += cnt;
1521         }
1522     }
1523
1524     /* restore the insert char mode... */
1525     tpd->insertCharMode = saveInsertCharMode;
1526
1527     /* restore the cursor position... */
1528     tpd->cursorColumn = col;
1529     tpd->cursorRow = row;
1530
1531     /* restore the current enhancement state... */
1532     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1533               tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhVideo,
1534               td->enhVideoState);
1535     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1536               tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhFgColor,
1537               td->enhFgColorState);
1538     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1539               tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhBgColor,
1540               td->enhBgColorState);
1541 }
1542
1543 void
1544 _DtTermSelEraseInDisplay(Widget w) /* DECSED ESC?pJ */
1545 {
1546   DtTermWidget vtw = (DtTermWidget) w;
1547   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1548   TermBuffer tb = tw->term.tpd->termBuffer ;
1549   ParserContext context ;
1550   enhValues evalues;
1551   int r,col1,col2,row1,row2,col,row ;
1552   int   cnt ;
1553   Debug('P', fprintf(stderr,">>In func _DtTermSelEraseInDisplay\n")) ;
1554   KILLWRAP(vtw) ;
1555   context = GetParserContext(w) ;
1556   STORELASTARG(context) ;
1557   col1 = FIRSTCOLUMN(vtw) ;
1558   row1 = TOPROW(vtw) ;
1559   col2 = LASTCOLUMN(vtw) ;
1560   row2 = BOTTOMROW(vtw) ;
1561   switch ( context->parms[1] )  {
1562       case 0: col1= vtw->term.tpd->cursorColumn;
1563               row1 = vtw->term.tpd->cursorRow;
1564               break;
1565       case 1: col2 = vtw->term.tpd->cursorColumn;
1566               row2 = vtw->term.tpd->cursorRow;
1567               break;
1568       case 2: break ;
1569       default: return ;
1570     }
1571   col = vtw->term.tpd->cursorColumn;
1572   row = vtw->term.tpd->cursorRow;
1573   vtw->term.tpd->cursorColumn = col1 ;
1574   vtw->term.tpd->cursorRow = row1;
1575   context->workingNum  = 0 ;  /* erase to the end of line */
1576   _DtTermSelEraseInLine(w) ;
1577   context->workingNum  = 2 ;  /* erase the whole row */
1578   for ( r=row1+1; r<row2; r++) {
1579      vtw->term.tpd->cursorRow = r;
1580      _DtTermSelEraseInLine(w) ;
1581    }
1582   vtw->term.tpd->cursorColumn = col2 ;
1583   vtw->term.tpd->cursorRow = row2;
1584   context->workingNum  = 2 ;  /* erase the beginning of the line */
1585   _DtTermSelEraseInLine(w) ;
1586   vtw->term.tpd->cursorColumn = col ;
1587   vtw->term.tpd->cursorRow = row;
1588 }
1589
1590
1591 void
1592 _DtTermSingleShiftG2(Widget w) /* SS2  ESCN */
1593 {
1594   DtTermWidget vtw = (DtTermWidget) w;
1595   DtTermData vtd =      vtw->vt.td;
1596
1597   Debug('P', fprintf(stderr,">>In func _DtTermSingleShiftG2\n")) ;
1598   vtd->singleShiftPending = True;
1599   vtd->singleShiftFont = vtd->G2;
1600 }
1601
1602 void
1603 _DtTermSingleShiftG3(Widget w) /* SS3  ESCO */
1604 {
1605   DtTermWidget vtw = (DtTermWidget) w;
1606   DtTermData vtd =      vtw->vt.td;
1607
1608   Debug('P', fprintf(stderr,">>In func _DtTermSingleShiftG3\n")) ;
1609   vtd->singleShiftPending = True;
1610   vtd->singleShiftFont = vtd->G3;
1611 }
1612
1613 void
1614 _DtTermLoadCharSet(Widget w) /* vt220 DCS - download char set ESCPpST  */
1615 {
1616   /* we're not implementing this */
1617 }
1618
1619 /*********************************************************************
1620  *  The next 3 functions handle the user key string loading
1621  *    DCS Pc;Pl | Ky1/st1;ky2/st2;...kyn/stn ST
1622  */
1623 void
1624 _DtTermParseUserKeyClear(Widget w) /* vt220 DECUDK clear function keys*/
1625 {
1626   DtTermWidget vtw = (DtTermWidget) w;
1627   DtTermData vtd =      vtw->vt.td;
1628   ParserContext context ;
1629   Debug('P', fprintf(stderr,">>In func _DtTermLoadSoftKey\n")) ;
1630   context = GetParserContext(w) ;
1631   STORELASTARG(context) ;
1632   if ( !vtd->userKeysLocked )
1633   {
1634      vtd->needToLockUserKeys = False ;
1635      if (context->parms[1] == 0)
1636         _DtTermFunctionKeyClear(w) ;
1637      if (context->parms[0] == 2 && context->parms[2] == 0)
1638                                       vtd->needToLockUserKeys = True ;
1639   }
1640   _DtTermClearParam(w) ;
1641 }
1642 void
1643 _DtTermParseUserKeyLoad(Widget w) /* vt220 DECUDK load function string */
1644 {
1645   DtTermWidget vtw = (DtTermWidget) w;
1646   DtTermData vtd =      vtw->vt.td;
1647   ParserContext context ;
1648   Debug('P', fprintf(stderr,">>In func _DtTermLoadSoftKey\n")) ;
1649   context = GetParserContext(w) ;
1650   STORELASTARG(context) ;
1651   if ( !vtd->userKeysLocked)
1652   {
1653      context->stringParms[0].str[context->stringParms[0].length/2] =
1654                           (unsigned char)0 ;  /* Null terminate */
1655      _DtTermFunctionKeyStringStore(w,context->parms[1],
1656                                            (char *)context->stringParms[0].str);
1657   }
1658   _DtTermClearParam(w) ;
1659 }
1660
1661 void
1662 _DtTermParseUserKeyLoadLast(Widget w) /* vt220 DECUDK load function string */
1663 {
1664   DtTermWidget vtw = (DtTermWidget) w;
1665   DtTermData vtd =      vtw->vt.td;
1666    _DtTermParseUserKeyLoad(w);
1667   if (vtd->needToLockUserKeys) vtd->userKeysLocked = True ;
1668   vtd->needToLockUserKeys = False ;
1669 }
1670
1671 void
1672 _DtTermParseHexDigit(Widget w) /* vt220 DECUDK store hex digit*/
1673 {
1674   ParserContext context ;
1675   int ci, left_byte, i;
1676   char c, cbuf[2] ;
1677   Debug('P', fprintf(stderr,">>In func _DtTermLoadSoftKey\n")) ;
1678   context = GetParserContext(w) ;
1679   if ( (int)context->stringParms[0].length < 2*STR_SIZE-1 ) {
1680       /* fold the hex digits into characters */
1681       i = context->stringParms[0].length ;
1682       cbuf[0] = *context->inputChar ;
1683       cbuf[1] = (char)0 ;
1684       sscanf(cbuf,"%x",&ci)   ;
1685       c = (char)ci ;
1686       left_byte  = (i+1)%2 ;
1687       i /= 2 ;
1688       if ( left_byte  )
1689            context->stringParms[0].str[i] = c<<4 ;
1690       else
1691            context->stringParms[0].str[i] |= c & 0x0F ;
1692       context->stringParms[0].length++ ;
1693    }
1694 }
1695
1696 void
1697 _DtTermReset(Widget w) /* RIS  ESCc */
1698 {
1699   ParserContext context ;
1700   int cnt ;
1701   Debug('P', fprintf(stderr,">>In func _DtTermReset\n")) ;
1702   context = GetParserContext(w) ;
1703   _DtTermFuncHardReset(w,0 ,fromParser) ;
1704 }
1705
1706 void
1707 _DtTermSelectG2(Widget w) /* LS2  ESCn */
1708 {
1709     DtTermWidget vtw = (DtTermWidget)w ;
1710     DtTermData vtd =      vtw->vt.td;
1711     DtTermPrimitiveWidget tw         = (DtTermPrimitiveWidget) w;
1712     DtTermPrimData        tpd        = tw->term.tpd;
1713
1714     Debug('P', fprintf(stderr,">>In func _DtTermSelectG2\n")) ;
1715     vtd->GL = &vtd->G2;
1716
1717     vtd->enhFontState = *vtd->GL;
1718     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1719             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1720             enhFont, vtd->enhFontState);
1721 }
1722
1723 void
1724 _DtTermSelectG3(Widget w) /* LS3 ESCo */
1725 {
1726     DtTermWidget vtw = (DtTermWidget)w ;
1727     DtTermData vtd =      vtw->vt.td;
1728     DtTermPrimitiveWidget tw         = (DtTermPrimitiveWidget) w;
1729     DtTermPrimData        tpd        = tw->term.tpd;
1730
1731     Debug('P', fprintf(stderr,">>In func _DtTermSelectG3\n")) ;
1732     vtd->GL = &vtd->G3;
1733     vtd->enhFontState = *vtd->GL;
1734     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1735             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1736             enhFont, vtd->enhFontState);
1737 }
1738
1739 void
1740 _DtTermParseStatus(Widget w)  /* DECID (same as DA)  ESCZ */
1741 {
1742    _DtTermDeviceAttributes(w) ;
1743 }
1744
1745 void
1746 _DtTermSetCharEraseMode(Widget w) /* DECSCA ESCp"q */
1747 {
1748   DtTermWidget vtw = (DtTermWidget) w;
1749   DtTermPrimitiveWidget tw         = (DtTermPrimitiveWidget) w;
1750   DtTermPrimData        tpd        = tw->term.tpd;
1751   ParserContext context ;
1752   Debug('P', fprintf(stderr,">>In func _DtTermSetCharEraseMode\n")) ;
1753   context = GetParserContext(w) ;
1754   STORELASTARG(context) ;
1755   switch ( context->parms[1] ) {
1756      case 0:  /* set back to default which is unprotect  */
1757               /* fall through */
1758      case 2:
1759              vtw->vt.td->enhFieldState = FIELD_UNPROTECT;
1760              (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1761                       tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1762                       enhField, vtw->vt.td->enhFieldState);
1763              break;
1764      case 1:
1765              vtw->vt.td->enhFieldState = FIELD_PROTECT;
1766              (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1767                       tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1768                       enhField, vtw->vt.td->enhFieldState);
1769              break;
1770    }
1771 }
1772
1773 void
1774 _DtTermSingleWide(Widget w) /* DECSWL ESC#5 */
1775 {
1776   ParserContext context ;
1777   int cnt ;
1778   Debug('P', fprintf(stderr,">>In func _DtTermSingleWide\n")) ;
1779   context = GetParserContext(w) ;
1780 }
1781
1782 void
1783 _DtTermDoubleWide(Widget w) /* DECDWL ESC#6  */
1784 {
1785   ParserContext context ;
1786   int cnt ;
1787   Debug('P', fprintf(stderr,">>In func _DtTermDoubleWide\n")) ;
1788   context = GetParserContext(w) ;
1789 }
1790
1791 void
1792 _DtTermDoubleHigh(Widget w) /* DECWHL ESC#4 */
1793 {
1794   ParserContext context ;
1795   int cnt ;
1796   Debug('P', fprintf(stderr,">>In func _DtTermDoubleHigh\n")) ;
1797   context = GetParserContext(w) ;
1798 }
1799
1800 void
1801 _DtTermParseFontG0(Widget w)
1802 {
1803     DtTermWidget vtw = (DtTermWidget)w ;
1804     DtTermData vtd =      vtw->vt.td;
1805     DtTermPrimitiveWidget tw         = (DtTermPrimitiveWidget) w;
1806     DtTermPrimData        tpd        = tw->term.tpd;
1807     ParserContext context ;
1808     context = GetParserContext(w) ;
1809
1810     Debug('P', fprintf(stderr,">>In func _DtTermParseFontG0\n")) ;
1811     switch (*context->inputChar) {
1812     case 'B':
1813         vtd->G0 = FONT_NORMAL;
1814         break;
1815
1816     case '0':
1817         vtd->G0 = FONT_LINEDRAW;
1818         break;
1819     }
1820
1821     vtd->enhFontState = *vtd->GL;
1822     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1823             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1824             enhFont, vtd->enhFontState);
1825 }
1826
1827 void
1828 _DtTermParseFontG1(Widget w)
1829 {
1830     DtTermWidget vtw = (DtTermWidget)w ;
1831     DtTermData vtd =      vtw->vt.td;
1832     DtTermPrimitiveWidget tw         = (DtTermPrimitiveWidget) w;
1833     DtTermPrimData        tpd        = tw->term.tpd;
1834     ParserContext context ;
1835     context = GetParserContext(w) ;
1836
1837     Debug('P', fprintf(stderr,">>In func _DtTermParseFontG1\n")) ;
1838     switch (*context->inputChar) {
1839     case 'B':
1840         vtd->G1 = FONT_NORMAL;
1841         break;
1842
1843     case '0':
1844         vtd->G1 = FONT_LINEDRAW;
1845         break;
1846     }
1847
1848     vtd->enhFontState = *vtd->GL;
1849     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1850             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1851             enhFont, vtd->enhFontState);
1852 }
1853
1854 void
1855 _DtTermParseFontG2(Widget w)
1856 {
1857     DtTermWidget vtw = (DtTermWidget)w ;
1858     DtTermData vtd =      vtw->vt.td;
1859     DtTermPrimitiveWidget tw         = (DtTermPrimitiveWidget) w;
1860     DtTermPrimData        tpd        = tw->term.tpd;
1861     ParserContext context ;
1862     context = GetParserContext(w) ;
1863
1864     Debug('P', fprintf(stderr,">>In func _DtTermParseFontG1\n")) ;
1865     switch (*context->inputChar) {
1866     case 'B':
1867         vtd->G2 = FONT_NORMAL;
1868         break;
1869
1870     case '0':
1871         vtd->G2 = FONT_LINEDRAW;
1872         break;
1873     }
1874
1875     vtd->enhFontState = *vtd->GL;
1876     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1877             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1878             enhFont, vtd->enhFontState);
1879 }
1880
1881 void
1882 _DtTermParseFontG3(Widget w)
1883 {
1884     DtTermWidget vtw = (DtTermWidget)w ;
1885     DtTermData vtd =      vtw->vt.td;
1886     DtTermPrimitiveWidget tw         = (DtTermPrimitiveWidget) w;
1887     DtTermPrimData        tpd        = tw->term.tpd;
1888     ParserContext context ;
1889     context = GetParserContext(w) ;
1890
1891     Debug('P', fprintf(stderr,">>In func _DtTermParseFontG1\n")) ;
1892     switch (*context->inputChar) {
1893     case 'B':
1894         vtd->G3 = FONT_NORMAL;
1895         break;
1896
1897     case '0':
1898         vtd->G3 = FONT_LINEDRAW;
1899         break;
1900     }
1901
1902     vtd->enhFontState = *vtd->GL;
1903     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1904             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1905             enhFont, vtd->enhFontState);
1906 }
1907
1908 void
1909 _DtTermParseFontShift(Widget w)  /* Ctrl-E  Ctrl-F  */
1910 {
1911     DtTermWidget vtw = (DtTermWidget)w ;
1912     DtTermData vtd =      vtw->vt.td;
1913     DtTermPrimitiveWidget tw         = (DtTermPrimitiveWidget) w;
1914     DtTermPrimData        tpd        = tw->term.tpd;
1915     ParserContext context ;
1916     context = GetParserContext(w) ;
1917
1918     Debug('P', fprintf(stderr,">>In func _DtTermParseFontShift\n")) ;
1919     switch (*context->inputChar) {
1920     case 'O' & 0x1f:
1921         /* SHIFT OUT */
1922         vtd->GL = &vtd->G0;
1923         break;
1924
1925     case 'N' & 0x1f:
1926         /* SHIFT OUT */
1927         vtd->GL = &vtd->G1;
1928         break;
1929     }
1930
1931     vtd->enhFontState = *vtd->GL;
1932     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1933             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1934             enhFont, vtd->enhFontState);
1935 }
1936
1937 void
1938 _DtTermParseTab(Widget w)    /* Crtl-I */
1939 {
1940     DtTermWidget vtw = (DtTermWidget)w ;
1941     Debug('P', fprintf(stderr,">>In func _DtTermParseTab\n")) ;
1942     if (vtw->term.tpd->cursorColumn > LASTCOLUMN(vtw)) {
1943         if (vtw->vt.td->fixCursesMode) {
1944             (void) _DtTermNextLine(w);
1945             (void) _DtTermFuncTab(w, 1, fromParser);
1946         } else {
1947             /* we already tabbed to the end of the line, so do nothing... */
1948         }
1949     } else {
1950         (void) _DtTermFuncTab(w, 1, fromParser);
1951     }
1952     return;
1953 }
1954
1955 void
1956 _DtTermParseLF    /* LineFeed (LF) or newline (NL) Ctrl-J,
1957                      Vertical Tab Ctrl-K, Form Feed (NP) Ctrl-L */
1958 (
1959     Widget w
1960 )
1961 {
1962   DtTermWidget vtw = (DtTermWidget)w ;
1963   Debug('P', fprintf(stderr,">>In func _vtParseLR\n")) ;
1964   KILLWRAP(vtw) ;
1965   if (vtw->term.tpd->cursorRow == BOTTOMMARGIN(vtw))
1966    {
1967      /*
1968         ** scroll one line...
1969         */
1970         (void) _DtTermPrimScrollText(w, 1);
1971         vtw->term.tpd->cursorRow = BOTTOMMARGIN(vtw);
1972     }
1973    else {
1974     if (!(vtw->term.tpd->cursorRow == BOTTOMROW(vtw))) {
1975        vtw->term.tpd->cursorRow++ ;
1976      }
1977    }
1978    (void) _DtTermPrimFillScreenGap(w);
1979
1980    if (vtw->term.tpd->autoLineFeed )
1981         _DtTermPrimParseCR(w);
1982 }
1983
1984 void
1985 _DtTermSoftReset   /* DECSTR  ESC!p  */
1986 (
1987     Widget w
1988 )
1989 {
1990   Debug('P', fprintf(stderr,">>In func _DtTermSoftReset\n")) ;
1991    _DtTermFuncSoftReset(w,0 ,fromParser) ;
1992 }
1993
1994 void
1995 _DtTermParseBackspace  /*  Ctrl-H  */
1996 (
1997     Widget w
1998 )
1999 {
2000   ParserContext context ;
2001   DtTermWidget vtw = (DtTermWidget) w;
2002   int row,col,fcol,cnt ;
2003   Debug('P', fprintf(stderr,">>In func  _DtTermParseBackspace\n")) ;
2004   context = GetParserContext(w) ;
2005   fcol = FIRSTCOLUMN(vtw) ;
2006   row = vtw->term.tpd->cursorRow;
2007   col = vtw->term.tpd->cursorColumn;
2008     (void) col--;
2009     if (col<fcol) {
2010       if (vtw->vt.td->reverseWrapMode) {
2011          if ( --row < TOPROW(vtw)) row = BOTTOMROW(vtw);
2012          if (vtw->vt.td->originMode && row < TOPMARGIN(vtw))
2013               row =BOTTOMMARGIN(vtw);
2014          col = LASTCOLUMN(vtw) ;
2015        }
2016       else {
2017          col=fcol;
2018       }
2019     }
2020   vtw->term.tpd->cursorRow = row;
2021   vtw->term.tpd->cursorColumn = col;
2022 }
2023
2024 static void
2025 GetWindowOffsets
2026 (
2027     Widget                        w,
2028     int                          *xOffset,
2029     int                          *yOffset,
2030     int                          *widthOffset,
2031     int                          *heightOffset
2032 )
2033 {
2034     Display                      *display;
2035     Window                        parentReturn;
2036     Window                       *childrenReturn;
2037     unsigned int                  nChildrenReturn;
2038     Window                        rootWindow;
2039     Window                        topWindow;
2040     Window                        childReturn;
2041     int                           destXReturn;
2042     int                           destYReturn;
2043     unsigned int                  widthReturn;
2044     unsigned int                  heightReturn;
2045     unsigned int                  topWidthReturn;
2046     unsigned int                  topHeightReturn;
2047     unsigned int                  borderWidthReturn;
2048     unsigned int                  depthReturn;
2049
2050     *xOffset = 0;
2051     *yOffset = 0;
2052     *widthOffset = 0;
2053     *heightOffset = 0;
2054
2055     if (XmIsMotifWMRunning(w)) {
2056         /* get the window we want to figure the offsets for... */
2057         topWindow = XtWindow(w);
2058
2059         /* and the display involved... */
2060         display = XtDisplay(w);
2061
2062         (void) XQueryTree(display, topWindow, &rootWindow, &parentReturn,
2063                 &childrenReturn, &nChildrenReturn);
2064         (void) XFree(childrenReturn);
2065
2066         /* walk up the tree until the parent window is root... */
2067         while (parentReturn != rootWindow) {
2068             topWindow = parentReturn;
2069             (void) XQueryTree(display, topWindow, &rootWindow,
2070                     &parentReturn, &childrenReturn, &nChildrenReturn);
2071             (void) XFree(childrenReturn);
2072         }
2073
2074         /* we now know what our top window is.  translate our upper
2075          * left corner relative to its upper left corner...
2076          */
2077         (void) XTranslateCoordinates(display, XtWindow(w), topWindow,
2078                 0, 0, &destXReturn, &destYReturn, &childReturn);
2079         *xOffset = destXReturn;
2080         *yOffset = destYReturn;
2081
2082         /* now that we know the top window, we can figure out the size
2083          * difference between the two windows...
2084          */
2085         (void) XGetGeometry(display, topWindow, &rootWindow,
2086                 &destXReturn, &destYReturn, &topWidthReturn,
2087                 &topHeightReturn, &borderWidthReturn, &depthReturn);
2088
2089         (void) XGetGeometry(display, XtWindow(w), &rootWindow,
2090                 &destXReturn, &destYReturn, &widthReturn, &heightReturn,
2091                 &borderWidthReturn, &depthReturn);
2092
2093         *widthOffset = topWidthReturn - widthReturn;
2094         *heightOffset = topHeightReturn - heightReturn;
2095     }
2096 }
2097
2098 void
2099 _DtTermParseSunMisc  /*  Misc sun esc seqs  */
2100 (
2101     Widget w
2102 )
2103 {
2104   ParserContext context ;
2105   DtTermWidget vtw = (DtTermWidget) w;
2106   Display *display = XtDisplay(w);
2107   int i, scr_num = XScreenNumberOfScreen(XtScreen(w));
2108   Window win = XtWindow(w);
2109   Window sh_win;
2110   Widget sw;
2111   XWindowChanges values;
2112   Arg arg[5];
2113   char buf[BUFSIZ];
2114   Position x,y;
2115   short   rows,columns;
2116   Dimension height,width;
2117   char *fmt,*s,*title,*icon;
2118   int xOffset;
2119   int yOffset;
2120   int widthOffset;
2121   int heightOffset;
2122
2123   context = GetParserContext(w) ;
2124   STORELASTARG(context) ;
2125
2126   for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2127   sh_win = XtWindow(sw) ;
2128   switch (context->parms[1])
2129   {
2130     case 1:
2131       XMapWindow(display,sh_win);
2132       break;
2133     case 2:
2134       XIconifyWindow(display,sh_win,scr_num);
2135       break;
2136     case 3:
2137         (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2138                 &heightOffset);
2139         /* DKS
2140         (void) XMoveWindow(display, sh_win,
2141                 context->parms[2] + xOffset, context->parms[3] + yOffset);
2142                 DKS */
2143         (void) XtVaSetValues(sw, XmNx, context->parms[2] + xOffset,
2144                 XmNy, context->parms[3] + yOffset, NULL);
2145         break ;
2146     case 4:
2147         (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2148                 &heightOffset);
2149         (void) XtVaSetValues(sw, XmNwidth, context->parms[3] - widthOffset,
2150                        XmNheight,context->parms[2] - heightOffset, NULL);
2151       break ;
2152     case 5:
2153       XRaiseWindow(display,sh_win);
2154       break ;
2155     case 6:
2156       XLowerWindow(display,sh_win);
2157       break ;
2158     case 7:
2159       _DtTermPrimFuncRedrawDisplay(w, 1, fromParser);
2160       break ;
2161     case 8:
2162         rows = context->parms[2];
2163         columns = context->parms[3];
2164         (void) XtVaSetValues(w, DtNrows, rows, DtNcolumns, columns, NULL);
2165         break ;
2166     case 11:
2167       if (vtw->term.tpd->windowMapped)
2168          sendEscSequence(w,"\033[1t") ;
2169       else
2170          sendEscSequence(w,"\033[2t") ;
2171       break ;
2172     case 13:
2173         (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2174                 &heightOffset);
2175         (void) XtVaGetValues(sw, XtNx, &x, XtNy, &y, NULL);
2176         (void) sprintf(buf, "\033[3;%d;%dt", x - xOffset, y - yOffset);
2177         (void) sendEscSequence(w, buf);
2178         break;
2179     case 14:
2180         (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2181                 &heightOffset);
2182         (void) XtVaGetValues(sw, XtNheight, &height, XtNwidth, &width, NULL);
2183         (void) sprintf(buf,"\033[4;%d;%dt", height + heightOffset,
2184                 width + widthOffset);
2185         (void) sendEscSequence(w, buf);
2186         break;
2187     case 18:
2188         (void) XtVaGetValues(w, DtNrows, &rows, DtNcolumns, &columns, NULL);
2189         (void) sprintf(buf, "\033[8;%hd;%hdt", rows, columns);
2190         (void) sendEscSequence(w, buf);
2191         break;
2192     case 20:
2193       XtVaGetValues(sw,XmNiconName, &icon, NULL);
2194       fmt = "\033]L%s\033\\";
2195       if (strlen(icon) + strlen(fmt) + 1 >= sizeof(buf))
2196         s = XtMalloc(strlen(icon) + strlen(fmt) + 1);
2197       else
2198         s = buf;
2199       sprintf(s, "%s", fmt);
2200       sendEscSequence(w,s) ;
2201       if (s != buf) XtFree(s);
2202       break ;
2203     case 21:
2204       XtVaGetValues(sw,XmNtitle, &title, NULL);
2205       fmt = "\033]l%s\033\\";
2206       if (strlen(icon) + strlen(fmt) + 1 >= sizeof(buf))
2207         s = XtMalloc(strlen(icon) + strlen(fmt) + 1);
2208       else
2209         s = buf;
2210       sprintf(s, "%s", fmt);
2211       sendEscSequence(w,s) ;
2212       if (s != buf) XtFree(s);
2213       break ;
2214    }
2215 }
2216
2217 void
2218 _DtTermParserSunWindowIcon( Widget w)   /* sun set icon label */
2219 {
2220   ParserContext context ;
2221   Widget sw;
2222   context = GetParserContext(w) ;
2223   for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2224   XtVaSetValues(sw, XmNiconName, context->stringParms[0].str, NULL) ;
2225 }
2226
2227 void
2228 _DtTermParserSunWindowTitle     /* Sun set title name */
2229 (
2230 Widget w
2231 )
2232 {
2233   ParserContext context ;
2234   Widget sw;
2235   context = GetParserContext(w) ;
2236   for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2237   XtVaSetValues(sw,XmNtitle, context->stringParms[0].str, NULL) ;
2238 }
2239
2240 void
2241 _DtTermParserSunIconFile(Widget w)   /* Sun set icon to pixmap in file */
2242 {
2243   DtTermBuffer tb =
2244             (DtTermBuffer)((DtTermPrimitiveWidget)w)->term.tpd->termBuffer ;
2245   ParserContext context ;
2246   int fg, bg;
2247   Widget sw;
2248   Pixmap icon;
2249
2250   context = GetParserContext(w) ;
2251   for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2252   XtVaGetValues(sw, XtNforeground, &fg, XtNbackground, &bg, NULL);
2253   icon = XmGetPixmap(XtScreen(sw),(char *)context->stringParms[0].str,fg,bg);
2254   if (icon != XmUNSPECIFIED_PIXMAP)
2255      XtVaSetValues(sw, XmNiconPixmap,  icon, NULL);
2256 }
2257