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