home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / X / mit / clients / xterm / charproc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-21  |  88.1 KB  |  3,232 lines
  1. /*
  2.  * $XConsortium: charproc.c,v 1.176 92/03/13 18:00:30 gildea Exp $
  3.  */
  4.  
  5. /*
  6.  * Copyright 1988 Massachusetts Institute of Technology
  7.  * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
  8.  *
  9.  *                         All Rights Reserved
  10.  *
  11.  * Permission to use, copy, modify, and distribute this software and its
  12.  * documentation for any purpose and without fee is hereby granted,
  13.  * provided that the above copyright notice appear in all copies and that
  14.  * both that copyright notice and this permission notice appear in
  15.  * supporting documentation, and that the name of Digital Equipment
  16.  * Corporation not be used in advertising or publicity pertaining to
  17.  * distribution of the software without specific, written prior permission.
  18.  *
  19.  *
  20.  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  21.  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  22.  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  23.  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  24.  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  25.  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  26.  * SOFTWARE.
  27.  */
  28.  
  29. /* charproc.c */
  30.  
  31. #include "ptyx.h"
  32. #include "VTparse.h"
  33. #include "data.h"
  34. #include "error.h"
  35. #include "menu.h"
  36. #include "main.h"
  37. #include <X11/Xos.h>
  38. #include <X11/Xatom.h>
  39. #include <X11/Xutil.h>
  40. #include <X11/cursorfont.h>
  41. #include <X11/StringDefs.h>
  42. #include <X11/Xmu/Atoms.h>
  43. #include <X11/Xmu/CharSet.h>
  44. #include <X11/Xmu/Converters.h>
  45. #include <stdio.h>
  46. #include <errno.h>
  47. #include <setjmp.h>
  48. #include <ctype.h>
  49.  
  50. /*
  51.  * Check for both EAGAIN and EWOULDBLOCK, because some supposedly POSIX
  52.  * systems are broken and return EWOULDBLOCK when they should return EAGAIN.
  53.  * Note that this macro may evaluate its argument more than once.
  54.  */
  55. #if defined(EAGAIN) && defined(EWOULDBLOCK)
  56. #define E_TEST(err) ((err) == EAGAIN || (err) == EWOULDBLOCK)
  57. #else
  58. #ifdef EAGAIN
  59. #define E_TEST(err) ((err) == EAGAIN)
  60. #else
  61. #define E_TEST(err) ((err) == EWOULDBLOCK)
  62. #endif
  63. #endif
  64.  
  65. extern jmp_buf VTend;
  66.  
  67. extern Widget toplevel;
  68. extern void exit();
  69. extern char *malloc();
  70. extern char *realloc();
  71.  
  72. static void VTallocbuf();
  73. static int finput();
  74. static void dotext();
  75. static void WriteText();
  76.  
  77. static void bitset(), bitclr();
  78.     
  79. #define    DEFAULT        -1
  80. #define    TEXT_BUF_SIZE    256
  81. #define TRACKTIMESEC    4L
  82. #define TRACKTIMEUSEC    0L
  83. #define BELLSUPPRESSMSEC 200
  84.  
  85. #define XtNalwaysHighlight "alwaysHighlight"
  86. #define XtNappcursorDefault "appcursorDefault"
  87. #define XtNappkeypadDefault "appkeypadDefault"
  88. #define XtNbellSuppressTime "bellSuppressTime"
  89. #define XtNboldFont "boldFont"
  90. #define XtNc132 "c132"
  91. #define XtNcharClass "charClass"
  92. #define XtNcurses "curses"
  93. #define XtNcursorColor "cursorColor"
  94. #define XtNcutNewline "cutNewline"
  95. #define XtNcutToBeginningOfLine "cutToBeginningOfLine"
  96. #define XtNeightBitInput "eightBitInput"
  97. #define XtNeightBitOutput "eightBitOutput"
  98. #define XtNgeometry "geometry"
  99. #define XtNtekGeometry "tekGeometry"
  100. #define XtNinternalBorder "internalBorder"
  101. #define XtNjumpScroll "jumpScroll"
  102. #define XtNlogFile "logFile"
  103. #define XtNlogging "logging"
  104. #define XtNlogInhibit "logInhibit"
  105. #define XtNloginShell "loginShell"
  106. #define XtNmarginBell "marginBell"
  107. #define XtNpointerColor "pointerColor"
  108. #define XtNpointerColorBackground "pointerColorBackground"
  109. #define XtNpointerShape "pointerShape"
  110. #define XtNmultiClickTime "multiClickTime"
  111. #define XtNmultiScroll "multiScroll"
  112. #define XtNnMarginBell "nMarginBell"
  113. #define XtNresizeGravity "resizeGravity"
  114. #define XtNreverseWrap "reverseWrap"
  115. #define XtNautoWrap "autoWrap"
  116. #define XtNsaveLines "saveLines"
  117. #define XtNscrollBar "scrollBar"
  118. #define XtNscrollTtyOutput "scrollTtyOutput"
  119. #define XtNscrollKey "scrollKey"
  120. #define XtNscrollLines "scrollLines"
  121. #define XtNscrollPos "scrollPos"
  122. #define XtNsignalInhibit "signalInhibit"
  123. #define XtNtekInhibit "tekInhibit"
  124. #define XtNtekSmall "tekSmall"
  125. #define XtNtekStartup "tekStartup"
  126. #define XtNtiteInhibit "titeInhibit"
  127. #define XtNvisualBell "visualBell"
  128. #define XtNallowSendEvents "allowSendEvents"
  129.  
  130. #define XtCAlwaysHighlight "AlwaysHighlight"
  131. #define XtCAppcursorDefault "AppcursorDefault"
  132. #define XtCAppkeypadDefault "AppkeypadDefault"
  133. #define XtCBellSuppressTime "BellSuppressTime"
  134. #define XtCBoldFont "BoldFont"
  135. #define XtCC132 "C132"
  136. #define XtCCharClass "CharClass"
  137. #define XtCCurses "Curses"
  138. #define XtCCutNewline "CutNewline"
  139. #define XtCCutToBeginningOfLine "CutToBeginningOfLine"
  140. #define XtCEightBitInput "EightBitInput"
  141. #define XtCEightBitOutput "EightBitOutput"
  142. #define XtCGeometry "Geometry"
  143. #define XtCJumpScroll "JumpScroll"
  144. #define XtCLogfile "Logfile"
  145. #define XtCLogging "Logging"
  146. #define XtCLogInhibit "LogInhibit"
  147. #define XtCLoginShell "LoginShell"
  148. #define XtCMarginBell "MarginBell"
  149. #define XtCMultiClickTime "MultiClickTime"
  150. #define XtCMultiScroll "MultiScroll"
  151. #define XtCColumn "Column"
  152. #define XtCResizeGravity "ResizeGravity"
  153. #define XtCReverseWrap "ReverseWrap"
  154. #define XtCAutoWrap "AutoWrap"
  155. #define XtCSaveLines "SaveLines"
  156. #define XtCScrollBar "ScrollBar"
  157. #define XtCScrollLines "ScrollLines"
  158. #define XtCScrollPos "ScrollPos"
  159. #define XtCScrollCond "ScrollCond"
  160. #define XtCSignalInhibit "SignalInhibit"
  161. #define XtCTekInhibit "TekInhibit"
  162. #define XtCTekSmall "TekSmall"
  163. #define XtCTekStartup "TekStartup"
  164. #define XtCTiteInhibit "TiteInhibit"
  165. #define XtCVisualBell "VisualBell"
  166. #define XtCAllowSendEvents "AllowSendEvents"
  167.  
  168. #define    doinput()        (bcnt-- > 0 ? *bptr++ : in_put())
  169.  
  170. static int nparam;
  171. static ANSI reply;
  172. static int param[NPARAM];
  173.  
  174. static unsigned long ctotal;
  175. static unsigned long ntotal;
  176. static jmp_buf vtjmpbuf;
  177.  
  178. extern int groundtable[];
  179. extern int csitable[];
  180. extern int dectable[];
  181. extern int eigtable[];
  182. extern int esctable[];
  183. extern int iestable[];
  184. extern int igntable[];
  185. extern int scrtable[];
  186. extern int scstable[];
  187.  
  188.  
  189. /* event handlers */
  190. extern void HandleKeyPressed(), HandleEightBitKeyPressed();
  191. extern void HandleStringEvent();
  192. extern void HandleEnterWindow();
  193. extern void HandleLeaveWindow();
  194. extern void HandleBellPropertyChange();
  195. extern void HandleFocusChange();
  196. static void HandleKeymapChange();
  197. extern void HandleInsertSelection();
  198. extern void HandleSelectStart(), HandleKeyboardSelectStart();
  199. extern void HandleSelectExtend(), HandleSelectSet();
  200. extern void HandleSelectEnd(), HandleKeyboardSelectEnd();
  201. extern void HandleStartExtend(), HandleKeyboardStartExtend();
  202. static void HandleBell();
  203. static void HandleVisualBell();
  204. static void HandleIgnore();
  205. extern void HandleSecure();
  206. extern void HandleScrollForward();
  207. extern void HandleScrollBack();
  208. extern void HandleCreateMenu(), HandlePopupMenu();
  209. extern void HandleSetFont();
  210. extern void SetVTFont();
  211.  
  212. extern Boolean SendMousePosition();
  213. extern void ScrnSetAttributes();
  214.  
  215. /*
  216.  * NOTE: VTInitialize zeros out the entire ".screen" component of the 
  217.  * XtermWidget, so make sure to add an assignment statement in VTInitialize() 
  218.  * for each new ".screen" field added to this resource list.
  219.  */
  220.  
  221. /* Defaults */
  222. static  Boolean    defaultFALSE       = FALSE;
  223. static  Boolean    defaultTRUE       = TRUE;
  224. static  int    defaultBorderWidth = DEFBORDERWIDTH;
  225. static  int    defaultIntBorder   = DEFBORDER;
  226. static  int    defaultSaveLines   = SAVELINES;
  227. static    int    defaultScrollLines = SCROLLLINES;
  228. static  int    defaultNMarginBell = N_MARGINBELL;
  229. static  int    defaultMultiClickTime = MULTICLICKTIME;
  230. static  int    defaultBellSuppressTime = BELLSUPPRESSMSEC;
  231. static    char *    _Font_Selected_ = "yes";  /* string is arbitrary */
  232.  
  233. /*
  234.  * Warning, the following must be kept under 1024 bytes or else some 
  235.  * compilers (particularly AT&T 6386 SVR3.2) will barf).  Workaround is to
  236.  * declare a static buffer and copy in at run time (the the Athena text widget
  237.  * does).  Yuck.
  238.  */
  239. static char defaultTranslations[] =
  240. "\
  241.  Shift <KeyPress> Prior:scroll-back(1,halfpage) \n\
  242.   Shift <KeyPress> Next:scroll-forw(1,halfpage) \n\
  243. Shift <KeyPress> Select:select-cursor-start() select-cursor-end(PRIMARY, CUT_BUFFER0) \n\
  244. Shift <KeyPress> Insert:insert-selection(PRIMARY, CUT_BUFFER0) \n\
  245.        ~Meta <KeyPress>:insert-seven-bit() \n\
  246.         Meta <KeyPress>:insert-eight-bit() \n\
  247.        !Ctrl <Btn1Down>:popup-menu(mainMenu) \n\
  248.   !Lock Ctrl <Btn1Down>:popup-menu(mainMenu) \n\
  249.        ~Meta <Btn1Down>:select-start() \n\
  250.      ~Meta <Btn1Motion>:select-extend() \n\
  251.        !Ctrl <Btn2Down>:popup-menu(vtMenu) \n\
  252.   !Lock Ctrl <Btn2Down>:popup-menu(vtMenu) \n\
  253.  ~Ctrl ~Meta <Btn2Down>:ignore() \n\
  254.    ~Ctrl ~Meta <Btn2Up>:insert-selection(PRIMARY, CUT_BUFFER0) \n\
  255.        !Ctrl <Btn3Down>:popup-menu(fontMenu) \n\
  256.   !Lock Ctrl <Btn3Down>:popup-menu(fontMenu) \n\
  257.  ~Ctrl ~Meta <Btn3Down>:start-extend() \n\
  258.      ~Meta <Btn3Motion>:select-extend()    \n\
  259.                 <BtnUp>:select-end(PRIMARY, CUT_BUFFER0) \n\
  260.           <BtnDown>:bell(0) \
  261. ";
  262.  
  263. static XtActionsRec actionsList[] = { 
  264.     { "bell",          HandleBell },
  265.     { "create-menu",      HandleCreateMenu },
  266.     { "ignore",          HandleIgnore },
  267.     { "insert",          HandleKeyPressed },  /* alias for insert-seven-bit */
  268.     { "insert-seven-bit", HandleKeyPressed },
  269.     { "insert-eight-bit", HandleEightBitKeyPressed },
  270.     { "insert-selection", HandleInsertSelection },
  271.     { "keymap",       HandleKeymapChange },
  272.     { "popup-menu",      HandlePopupMenu },
  273.     { "secure",          HandleSecure },
  274.     { "select-start",      HandleSelectStart },
  275.     { "select-extend",      HandleSelectExtend },
  276.     { "select-end",      HandleSelectEnd },
  277.     { "select-set",      HandleSelectSet },
  278.     { "select-cursor-start",      HandleKeyboardSelectStart },
  279.     { "select-cursor-end",      HandleKeyboardSelectEnd },
  280.     { "set-vt-font",      HandleSetFont },
  281.     { "start-extend",      HandleStartExtend },
  282.     { "start-cursor-extend",      HandleKeyboardStartExtend },
  283.     { "string",          HandleStringEvent },
  284.     { "scroll-forw",      HandleScrollForward },
  285.     { "scroll-back",      HandleScrollBack },
  286.     /* menu actions */
  287.     { "allow-send-events",    HandleAllowSends },
  288.     { "set-visual-bell",    HandleSetVisualBell },
  289.     { "set-logging",        HandleLogging },
  290.     { "redraw",            HandleRedraw },
  291.     { "send-signal",        HandleSendSignal },
  292.     { "quit",            HandleQuit },
  293.     { "set-scrollbar",        HandleScrollbar },
  294.     { "set-jumpscroll",        HandleJumpscroll },
  295.     { "set-reverse-video",    HandleReverseVideo },
  296.     { "set-autowrap",        HandleAutoWrap },
  297.     { "set-reversewrap",    HandleReverseWrap },
  298.     { "set-autolinefeed",    HandleAutoLineFeed },
  299.     { "set-appcursor",        HandleAppCursor },
  300.     { "set-appkeypad",        HandleAppKeypad },
  301.     { "set-scroll-on-key",    HandleScrollKey },
  302.     { "set-scroll-on-tty-output",    HandleScrollTtyOutput },
  303.     { "set-allow132",        HandleAllow132 },
  304.     { "set-cursesemul",        HandleCursesEmul },
  305.     { "set-marginbell",        HandleMarginBell },
  306.     { "set-altscreen",        HandleAltScreen },
  307.     { "soft-reset",        HandleSoftReset },
  308.     { "hard-reset",        HandleHardReset },
  309.     { "clear-saved-lines",    HandleClearSavedLines },
  310.     { "set-terminal-type",    HandleSetTerminalType },
  311.     { "set-visibility",        HandleVisibility },
  312.     { "set-tek-text",        HandleSetTekText },
  313.     { "tek-page",        HandleTekPage },
  314.     { "tek-reset",        HandleTekReset },
  315.     { "tek-copy",        HandleTekCopy },
  316.     { "visual-bell",        HandleVisualBell },
  317. };
  318.  
  319. static XtResource resources[] = {
  320. {XtNfont, XtCFont, XtRString, sizeof(char *),
  321.     XtOffsetOf(XtermWidgetRec, misc.f_n), XtRString,
  322.     DEFFONT},
  323. {XtNboldFont, XtCBoldFont, XtRString, sizeof(char *),
  324.     XtOffsetOf(XtermWidgetRec, misc.f_b), XtRString,
  325.     DEFBOLDFONT},
  326. {XtNc132, XtCC132, XtRBoolean, sizeof(Boolean),
  327.     XtOffsetOf(XtermWidgetRec, screen.c132),
  328.     XtRBoolean, (caddr_t) &defaultFALSE},
  329. {XtNcharClass, XtCCharClass, XtRString, sizeof(char *),
  330.     XtOffsetOf(XtermWidgetRec, screen.charClass),
  331.     XtRString, (caddr_t) NULL},
  332. {XtNcurses, XtCCurses, XtRBoolean, sizeof(Boolean),
  333.     XtOffsetOf(XtermWidgetRec, screen.curses),
  334.     XtRBoolean, (caddr_t) &defaultFALSE},
  335. {XtNcutNewline, XtCCutNewline, XtRBoolean, sizeof(Boolean),
  336.     XtOffsetOf(XtermWidgetRec, screen.cutNewline),
  337.     XtRBoolean, (caddr_t) &defaultTRUE},
  338. {XtNcutToBeginningOfLine, XtCCutToBeginningOfLine, XtRBoolean, sizeof(Boolean),
  339.     XtOffsetOf(XtermWidgetRec, screen.cutToBeginningOfLine),
  340.     XtRBoolean, (caddr_t) &defaultTRUE},
  341. {XtNbackground, XtCBackground, XtRPixel, sizeof(Pixel),
  342.     XtOffsetOf(XtermWidgetRec, core.background_pixel),
  343.     XtRString, "XtDefaultBackground"},
  344. {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
  345.     XtOffsetOf(XtermWidgetRec, screen.foreground),
  346.     XtRString, "XtDefaultForeground"},
  347. {XtNcursorColor, XtCForeground, XtRPixel, sizeof(Pixel),
  348.     XtOffsetOf(XtermWidgetRec, screen.cursorcolor),
  349.     XtRString, "XtDefaultForeground"},
  350. {XtNeightBitInput, XtCEightBitInput, XtRBoolean, sizeof(Boolean),
  351.     XtOffsetOf(XtermWidgetRec, screen.input_eight_bits), 
  352.     XtRBoolean, (caddr_t) &defaultTRUE},
  353. {XtNeightBitOutput, XtCEightBitOutput, XtRBoolean, sizeof(Boolean),
  354.     XtOffsetOf(XtermWidgetRec, screen.output_eight_bits), 
  355.     XtRBoolean, (caddr_t) &defaultTRUE},
  356. {XtNgeometry,XtCGeometry, XtRString, sizeof(char *),
  357.     XtOffsetOf(XtermWidgetRec, misc.geo_metry),
  358.     XtRString, (caddr_t) NULL},
  359. {XtNalwaysHighlight,XtCAlwaysHighlight,XtRBoolean,
  360.         sizeof(Boolean),XtOffsetOf(XtermWidgetRec, screen.always_highlight),
  361.         XtRBoolean, (caddr_t) &defaultFALSE},
  362. {XtNappcursorDefault,XtCAppcursorDefault,XtRBoolean,
  363.         sizeof(Boolean),XtOffsetOf(XtermWidgetRec, misc.appcursorDefault),
  364.         XtRBoolean, (XtPointer) &defaultFALSE},
  365. {XtNappkeypadDefault,XtCAppkeypadDefault,XtRBoolean,
  366.         sizeof(Boolean),XtOffsetOf(XtermWidgetRec, misc.appkeypadDefault),
  367.         XtRBoolean, (XtPointer) &defaultFALSE},
  368. {XtNbellSuppressTime, XtCBellSuppressTime, XtRInt, sizeof(int),
  369.         XtOffsetOf(XtermWidgetRec, screen.bellSuppressTime),
  370.         XtRInt, (XtPointer) &defaultBellSuppressTime},
  371. {XtNtekGeometry,XtCGeometry, XtRString, sizeof(char *),
  372.     XtOffsetOf(XtermWidgetRec, misc.T_geometry),
  373.     XtRString, (caddr_t) NULL},
  374. {XtNinternalBorder,XtCBorderWidth,XtRInt, sizeof(int),
  375.     XtOffsetOf(XtermWidgetRec, screen.border),
  376.     XtRInt, (caddr_t) &defaultIntBorder},
  377. {XtNjumpScroll, XtCJumpScroll, XtRBoolean, sizeof(Boolean),
  378.     XtOffsetOf(XtermWidgetRec, screen.jumpscroll),
  379.     XtRBoolean, (caddr_t) &defaultTRUE},
  380. {XtNlogFile, XtCLogfile, XtRString, sizeof(char *),
  381.     XtOffsetOf(XtermWidgetRec, screen.logfile),
  382.     XtRString, (caddr_t) NULL},
  383. {XtNlogging, XtCLogging, XtRBoolean, sizeof(Boolean),
  384.     XtOffsetOf(XtermWidgetRec, misc.log_on),
  385.     XtRBoolean, (caddr_t) &defaultFALSE},
  386. {XtNlogInhibit, XtCLogInhibit, XtRBoolean, sizeof(Boolean),
  387.     XtOffsetOf(XtermWidgetRec, misc.logInhibit),
  388.     XtRBoolean, (caddr_t) &defaultFALSE},
  389. {XtNloginShell, XtCLoginShell, XtRBoolean, sizeof(Boolean),
  390.     XtOffsetOf(XtermWidgetRec, misc.login_shell),
  391.     XtRBoolean, (caddr_t) &defaultFALSE},
  392. {XtNmarginBell, XtCMarginBell, XtRBoolean, sizeof(Boolean),
  393.     XtOffsetOf(XtermWidgetRec, screen.marginbell),
  394.     XtRBoolean, (caddr_t) &defaultFALSE},
  395. {XtNpointerColor, XtCForeground, XtRPixel, sizeof(Pixel),
  396.     XtOffsetOf(XtermWidgetRec, screen.mousecolor),
  397.     XtRString, "XtDefaultForeground"},
  398. {XtNpointerColorBackground, XtCBackground, XtRPixel, sizeof(Pixel),
  399.     XtOffsetOf(XtermWidgetRec, screen.mousecolorback),
  400.     XtRString, "XtDefaultBackground"},
  401. {XtNpointerShape,XtCCursor, XtRCursor, sizeof(Cursor),
  402.     XtOffsetOf(XtermWidgetRec, screen.pointer_cursor),
  403.     XtRString, (caddr_t) "xterm"},
  404. {XtNmultiClickTime,XtCMultiClickTime, XtRInt, sizeof(int),
  405.     XtOffsetOf(XtermWidgetRec, screen.multiClickTime),
  406.     XtRInt, (caddr_t) &defaultMultiClickTime},
  407. {XtNmultiScroll,XtCMultiScroll, XtRBoolean, sizeof(Boolean),
  408.     XtOffsetOf(XtermWidgetRec, screen.multiscroll),
  409.     XtRBoolean, (caddr_t) &defaultFALSE},
  410. {XtNnMarginBell,XtCColumn, XtRInt, sizeof(int),
  411.     XtOffsetOf(XtermWidgetRec, screen.nmarginbell),
  412.     XtRInt, (caddr_t) &defaultNMarginBell},
  413. {XtNreverseVideo,XtCReverseVideo,XtRBoolean, sizeof(Boolean),
  414.     XtOffsetOf(XtermWidgetRec, misc.re_verse),
  415.     XtRBoolean, (caddr_t) &defaultFALSE},
  416. {XtNresizeGravity, XtCResizeGravity, XtRGravity, sizeof(XtGravity),
  417.     XtOffsetOf(XtermWidgetRec, misc.resizeGravity),
  418.     XtRImmediate, (XtPointer) SouthWestGravity},
  419. {XtNreverseWrap,XtCReverseWrap, XtRBoolean, sizeof(Boolean),
  420.     XtOffsetOf(XtermWidgetRec, misc.reverseWrap),
  421.     XtRBoolean, (caddr_t) &defaultFALSE},
  422. {XtNautoWrap,XtCAutoWrap, XtRBoolean, sizeof(Boolean),
  423.     XtOffsetOf(XtermWidgetRec, misc.autoWrap),
  424.     XtRBoolean, (caddr_t) &defaultTRUE},
  425. {XtNsaveLines, XtCSaveLines, XtRInt, sizeof(int),
  426.     XtOffsetOf(XtermWidgetRec, screen.savelines),
  427.     XtRInt, (caddr_t) &defaultSaveLines},
  428. {XtNscrollBar, XtCScrollBar, XtRBoolean, sizeof(Boolean),
  429.     XtOffsetOf(XtermWidgetRec, misc.scrollbar),
  430.     XtRBoolean, (caddr_t) &defaultFALSE},
  431. {XtNscrollTtyOutput,XtCScrollCond, XtRBoolean, sizeof(Boolean),
  432.     XtOffsetOf(XtermWidgetRec, screen.scrollttyoutput),
  433.     XtRBoolean, (caddr_t) &defaultTRUE},
  434. {XtNscrollKey, XtCScrollCond, XtRBoolean, sizeof(Boolean),
  435.     XtOffsetOf(XtermWidgetRec, screen.scrollkey),
  436.     XtRBoolean, (caddr_t) &defaultFALSE},
  437. {XtNscrollLines, XtCScrollLines, XtRInt, sizeof(int),
  438.     XtOffsetOf(XtermWidgetRec, screen.scrolllines),
  439.     XtRInt, (caddr_t) &defaultScrollLines},
  440. {XtNsignalInhibit,XtCSignalInhibit,XtRBoolean, sizeof(Boolean),
  441.     XtOffsetOf(XtermWidgetRec, misc.signalInhibit),
  442.     XtRBoolean, (caddr_t) &defaultFALSE},
  443. {XtNtekInhibit, XtCTekInhibit, XtRBoolean, sizeof(Boolean),
  444.     XtOffsetOf(XtermWidgetRec, misc.tekInhibit),
  445.     XtRBoolean, (caddr_t) &defaultFALSE},
  446. {XtNtekSmall, XtCTekSmall, XtRBoolean, sizeof(Boolean),
  447.     XtOffsetOf(XtermWidgetRec, misc.tekSmall),
  448.     XtRBoolean, (caddr_t) &defaultFALSE},
  449. {XtNtekStartup, XtCTekStartup, XtRBoolean, sizeof(Boolean),
  450.     XtOffsetOf(XtermWidgetRec, screen.TekEmu),
  451.     XtRBoolean, (caddr_t) &defaultFALSE},
  452. {XtNtiteInhibit, XtCTiteInhibit, XtRBoolean, sizeof(Boolean),
  453.     XtOffsetOf(XtermWidgetRec, misc.titeInhibit),
  454.     XtRBoolean, (caddr_t) &defaultFALSE},
  455. {XtNvisualBell, XtCVisualBell, XtRBoolean, sizeof(Boolean),
  456.     XtOffsetOf(XtermWidgetRec, screen.visualbell),
  457.     XtRBoolean, (caddr_t) &defaultFALSE},
  458. {XtNallowSendEvents, XtCAllowSendEvents, XtRBoolean, sizeof(Boolean),
  459.     XtOffsetOf(XtermWidgetRec, screen.allowSendEvents),
  460.     XtRBoolean, (caddr_t) &defaultFALSE},
  461. {"font1", "Font1", XtRString, sizeof(String),
  462.     XtOffsetOf(XtermWidgetRec, screen.menu_font_names[fontMenu_font1]),
  463.     XtRString, (caddr_t) NULL},
  464. {"font2", "Font2", XtRString, sizeof(String),
  465.     XtOffsetOf(XtermWidgetRec, screen.menu_font_names[fontMenu_font2]),
  466.     XtRString, (caddr_t) NULL},
  467. {"font3", "Font3", XtRString, sizeof(String),
  468.     XtOffsetOf(XtermWidgetRec, screen.menu_font_names[fontMenu_font3]),
  469.     XtRString, (caddr_t) NULL},
  470. {"font4", "Font4", XtRString, sizeof(String),
  471.     XtOffsetOf(XtermWidgetRec, screen.menu_font_names[fontMenu_font4]),
  472.     XtRString, (caddr_t) NULL},
  473. {"font5", "Font5", XtRString, sizeof(String),
  474.     XtOffsetOf(XtermWidgetRec, screen.menu_font_names[fontMenu_font5]),
  475.     XtRString, (caddr_t) NULL},
  476. {"font6", "Font6", XtRString, sizeof(String),
  477.     XtOffsetOf(XtermWidgetRec, screen.menu_font_names[fontMenu_font6]),
  478.     XtRString, (caddr_t) NULL},
  479. };
  480.  
  481. static void VTClassInit();
  482. static void VTInitialize();
  483. static void VTRealize();
  484. static void VTExpose();
  485. static void VTResize();
  486. static void VTDestroy();
  487. static Boolean VTSetValues();
  488.  
  489. static WidgetClassRec xtermClassRec = {
  490.   {
  491. /* core_class fields */    
  492.     /* superclass      */    (WidgetClass) &widgetClassRec,
  493.     /* class_name      */    "VT100",
  494.     /* widget_size      */    sizeof(XtermWidgetRec),
  495.     /* class_initialize   */    VTClassInit,
  496.     /* class_part_initialize */ NULL,
  497.     /* class_inited       */    FALSE,
  498.     /* initialize      */    VTInitialize,
  499.     /* initialize_hook    */    NULL,                
  500.     /* realize          */    VTRealize,
  501.     /* actions          */    actionsList,
  502.     /* num_actions      */    XtNumber(actionsList),
  503.     /* resources      */    resources,
  504.     /* num_resources      */    XtNumber(resources),
  505.     /* xrm_class      */    NULLQUARK,
  506.     /* compress_motion      */    TRUE,
  507.     /* compress_exposure  */    FALSE,
  508.     /* compress_enterleave */   TRUE,
  509.     /* visible_interest      */    FALSE,
  510.     /* destroy          */    VTDestroy,
  511.     /* resize          */    VTResize,
  512.     /* expose          */    VTExpose,
  513.     /* set_values      */    VTSetValues,
  514.     /* set_values_hook    */    NULL,
  515.     /* set_values_almost  */    NULL,
  516.     /* get_values_hook    */    NULL,
  517.     /* accept_focus      */    NULL,
  518.     /* version            */    XtVersion,
  519.     /* callback_offsets   */    NULL,
  520.     /* tm_table           */    defaultTranslations,
  521.     /* query_geometry     */    XtInheritQueryGeometry,
  522.     /* display_accelerator*/    XtInheritDisplayAccelerator,
  523.     /* extension          */    NULL
  524.   }
  525. };
  526.  
  527. WidgetClass xtermWidgetClass = (WidgetClass)&xtermClassRec;
  528.  
  529. static void VTparse()
  530. {
  531.     register TScreen *screen = &term->screen;
  532.     register int *parsestate = groundtable;
  533.     register unsigned int c;
  534.     register unsigned char *cp;
  535.     register int row, col, top, bot, scstype;
  536.     extern int TrackMouse();
  537.  
  538.     if(setjmp(vtjmpbuf))
  539.         parsestate = groundtable;
  540.     for( ; ; ) {
  541.             switch (parsestate[c = doinput()]) {
  542.          case CASE_PRINT:
  543.             /* printable characters */
  544.             top = bcnt > TEXT_BUF_SIZE ? TEXT_BUF_SIZE : bcnt;
  545.             cp = bptr;
  546.             *--bptr = c;
  547.             while(top > 0 && isprint(*cp & 0x7f)) {
  548.                 top--;
  549.                 bcnt--;
  550.                 cp++;
  551.             }
  552.             if(screen->curss) {
  553.                 dotext(screen, term->flags,
  554.                  screen->gsets[screen->curss], bptr, bptr + 1);
  555.                 screen->curss = 0;
  556.                 bptr++;
  557.             }
  558.             if(bptr < cp)
  559.                 dotext(screen, term->flags,
  560.                  screen->gsets[screen->curgl], bptr, cp);
  561.             bptr = cp;
  562.             break;
  563.  
  564.          case CASE_GROUND_STATE:
  565.             /* exit ignore mode */
  566.             parsestate = groundtable;
  567.             break;
  568.  
  569.          case CASE_IGNORE_STATE:
  570.             /* Ies: ignore anything else */
  571.             parsestate = igntable;
  572.             break;
  573.  
  574.          case CASE_IGNORE_ESC:
  575.             /* Ign: escape */
  576.             parsestate = iestable;
  577.             break;
  578.  
  579.          case CASE_IGNORE:
  580.             /* Ignore character */
  581.             break;
  582.  
  583.          case CASE_BELL:
  584.             /* bell */
  585.             Bell();
  586.             break;
  587.  
  588.          case CASE_BS:
  589.             /* backspace */
  590.             CursorBack(screen, 1);
  591.             break;
  592.  
  593.          case CASE_CR:
  594.             /* carriage return */
  595.             CarriageReturn(screen);
  596.             parsestate = groundtable;
  597.             break;
  598.  
  599.          case CASE_ESC:
  600.             /* escape */
  601.             parsestate = esctable;
  602.             break;
  603.  
  604.          case CASE_VMOT:
  605.             /*
  606.              * form feed, line feed, vertical tab
  607.              */
  608.             Index(screen, 1);
  609.             if (term->flags & LINEFEED)
  610.                 CarriageReturn(screen);
  611.             if (QLength(screen->display) > 0 ||
  612.                 GetBytesAvailable (ConnectionNumber(screen->display)) > 0)
  613.               xevents();
  614.             parsestate = groundtable;
  615.             break;
  616.  
  617.          case CASE_TAB:
  618.             /* tab */
  619.             screen->cur_col = TabNext(term->tabs, screen->cur_col);
  620.             if (screen->cur_col > screen->max_col)
  621.                 screen->cur_col = screen->max_col;
  622.             break;
  623.  
  624.          case CASE_SI:
  625.             screen->curgl = 0;
  626.             break;
  627.  
  628.          case CASE_SO:
  629.             screen->curgl = 1;
  630.             break;
  631.  
  632.          case CASE_SCR_STATE:
  633.             /* enter scr state */
  634.             parsestate = scrtable;
  635.             break;
  636.  
  637.          case CASE_SCS0_STATE:
  638.             /* enter scs state 0 */
  639.             scstype = 0;
  640.             parsestate = scstable;
  641.             break;
  642.  
  643.          case CASE_SCS1_STATE:
  644.             /* enter scs state 1 */
  645.             scstype = 1;
  646.             parsestate = scstable;
  647.             break;
  648.  
  649.          case CASE_SCS2_STATE:
  650.             /* enter scs state 2 */
  651.             scstype = 2;
  652.             parsestate = scstable;
  653.             break;
  654.  
  655.          case CASE_SCS3_STATE:
  656.             /* enter scs state 3 */
  657.             scstype = 3;
  658.             parsestate = scstable;
  659.             break;
  660.  
  661.          case CASE_ESC_IGNORE:
  662.             /* unknown escape sequence */
  663.             parsestate = eigtable;
  664.             break;
  665.  
  666.          case CASE_ESC_DIGIT:
  667.             /* digit in csi or dec mode */
  668.             if((row = param[nparam - 1]) == DEFAULT)
  669.                 row = 0;
  670.             param[nparam - 1] = 10 * row + (c - '0');
  671.             break;
  672.  
  673.          case CASE_ESC_SEMI:
  674.             /* semicolon in csi or dec mode */
  675.             param[nparam++] = DEFAULT;
  676.             break;
  677.  
  678.          case CASE_DEC_STATE:
  679.             /* enter dec mode */
  680.             parsestate = dectable;
  681.             break;
  682.  
  683.          case CASE_ICH:
  684.             /* ICH */
  685.             if((row = param[0]) < 1)
  686.                 row = 1;
  687.             InsertChar(screen, row);
  688.             parsestate = groundtable;
  689.             break;
  690.  
  691.          case CASE_CUU:
  692.             /* CUU */
  693.             if((row = param[0]) < 1)
  694.                 row = 1;
  695.             CursorUp(screen, row);
  696.             parsestate = groundtable;
  697.             break;
  698.  
  699.          case CASE_CUD:
  700.             /* CUD */
  701.             if((row = param[0]) < 1)
  702.                 row = 1;
  703.             CursorDown(screen, row);
  704.             parsestate = groundtable;
  705.             break;
  706.  
  707.          case CASE_CUF:
  708.             /* CUF */
  709.             if((row = param[0]) < 1)
  710.                 row = 1;
  711.             CursorForward(screen, row);
  712.             parsestate = groundtable;
  713.             break;
  714.  
  715.          case CASE_CUB:
  716.             /* CUB */
  717.             if((row = param[0]) < 1)
  718.                 row = 1;
  719.             CursorBack(screen, row);
  720.             parsestate = groundtable;
  721.             break;
  722.  
  723.          case CASE_CUP:
  724.             /* CUP | HVP */
  725.             if((row = param[0]) < 1)
  726.                 row = 1;
  727.             if(nparam < 2 || (col = param[1]) < 1)
  728.                 col = 1;
  729.             CursorSet(screen, row-1, col-1, term->flags);
  730.             parsestate = groundtable;
  731.             break;
  732.  
  733.          case CASE_ED:
  734.             /* ED */
  735.             switch (param[0]) {
  736.              case DEFAULT:
  737.              case 0:
  738.                 ClearBelow(screen);
  739.                 break;
  740.  
  741.              case 1:
  742.                 ClearAbove(screen);
  743.                 break;
  744.  
  745.              case 2:
  746.                 ClearScreen(screen);
  747.                 break;
  748.             }
  749.             parsestate = groundtable;
  750.             break;
  751.  
  752.          case CASE_EL:
  753.             /* EL */
  754.             switch (param[0]) {
  755.              case DEFAULT:
  756.              case 0:
  757.                 ClearRight(screen);
  758.                 break;
  759.              case 1:
  760.                 ClearLeft(screen);
  761.                 break;
  762.              case 2:
  763.                 ClearLine(screen);
  764.                 break;
  765.             }
  766.             parsestate = groundtable;
  767.             break;
  768.  
  769.          case CASE_IL:
  770.             /* IL */
  771.             if((row = param[0]) < 1)
  772.                 row = 1;
  773.             InsertLine(screen, row);
  774.             parsestate = groundtable;
  775.             break;
  776.  
  777.          case CASE_DL:
  778.             /* DL */
  779.             if((row = param[0]) < 1)
  780.                 row = 1;
  781.             DeleteLine(screen, row);
  782.             parsestate = groundtable;
  783.             break;
  784.  
  785.          case CASE_DCH:
  786.             /* DCH */
  787.             if((row = param[0]) < 1)
  788.                 row = 1;
  789.             DeleteChar(screen, row);
  790.             parsestate = groundtable;
  791.             break;
  792.  
  793.          case CASE_TRACK_MOUSE:
  794.              /* Track mouse as long as in window and between
  795.                specified rows */
  796.             TrackMouse(param[0], param[2]-1, param[1]-1,
  797.              param[3]-1, param[4]-2);
  798.             break;
  799.  
  800.          case CASE_DECID:
  801.             param[0] = -1;        /* Default ID parameter */
  802.             /* Fall through into ... */
  803.          case CASE_DA1:
  804.             /* DA1 */
  805.             if (param[0] <= 0) {    /* less than means DEFAULT */
  806.                 reply.a_type   = CSI;
  807.                 reply.a_pintro = '?';
  808.                 reply.a_nparam = 2;
  809.                 reply.a_param[0] = 1;        /* VT102 */
  810.                 reply.a_param[1] = 2;        /* VT102 */
  811.                 reply.a_inters = 0;
  812.                 reply.a_final  = 'c';
  813.                 unparseseq(&reply, screen->respond);
  814.             }
  815.             parsestate = groundtable;
  816.             break;
  817.  
  818.          case CASE_TBC:
  819.             /* TBC */
  820.             if ((row = param[0]) <= 0) /* less than means default */
  821.                 TabClear(term->tabs, screen->cur_col);
  822.             else if (row == 3)
  823.                 TabZonk(term->tabs);
  824.             parsestate = groundtable;
  825.             break;
  826.  
  827.          case CASE_SET:
  828.             /* SET */
  829.             ansi_modes(term, bitset);
  830.             parsestate = groundtable;
  831.             break;
  832.  
  833.          case CASE_RST:
  834.             /* RST */
  835.             ansi_modes(term, bitclr);
  836.             parsestate = groundtable;
  837.             break;
  838.  
  839.          case CASE_SGR:
  840.             /* SGR */
  841.             for (row=0; row<nparam; ++row) {
  842.                 switch (param[row]) {
  843.                  case DEFAULT:
  844.                  case 0:
  845.                     term->flags &= ~(INVERSE|BOLD|UNDERLINE);
  846.                     break;
  847.                  case 1:
  848.                  case 5:    /* Blink, really.    */
  849.                     term->flags |= BOLD;
  850.                     break;
  851.                  case 4:    /* Underscore        */
  852.                     term->flags |= UNDERLINE;
  853.                     break;
  854.                  case 7:
  855.                     term->flags |= INVERSE;
  856.                 }
  857.             }
  858.             parsestate = groundtable;
  859.             break;
  860.  
  861.          case CASE_CPR:
  862.             /* CPR */
  863.             if ((row = param[0]) == 5) {
  864.                 reply.a_type = CSI;
  865.                 reply.a_pintro = 0;
  866.                 reply.a_nparam = 1;
  867.                 reply.a_param[0] = 0;
  868.                 reply.a_inters = 0;
  869.                 reply.a_final  = 'n';
  870.                 unparseseq(&reply, screen->respond);
  871.             } else if (row == 6) {
  872.                 reply.a_type = CSI;
  873.                 reply.a_pintro = 0;
  874.                 reply.a_nparam = 2;
  875.                 reply.a_param[0] = screen->cur_row+1;
  876.                 reply.a_param[1] = screen->cur_col+1;
  877.                 reply.a_inters = 0;
  878.                 reply.a_final  = 'R';
  879.                 unparseseq(&reply, screen->respond);
  880.             }
  881.             parsestate = groundtable;
  882.             break;
  883.  
  884.          case CASE_DECSTBM:
  885.             /* DECSTBM - set scrolling region */
  886.             if((top = param[0]) < 1)
  887.                 top = 1;
  888.             if(nparam < 2 || (bot = param[1]) == DEFAULT
  889.                || bot > screen->max_row + 1
  890.                || bot == 0)
  891.                 bot = screen->max_row+1;
  892.             if (bot > top) {
  893.                 if(screen->scroll_amt)
  894.                     FlushScroll(screen);
  895.                 screen->top_marg = top-1;
  896.                 screen->bot_marg = bot-1;
  897.                 CursorSet(screen, 0, 0, term->flags);
  898.             }
  899.             parsestate = groundtable;
  900.             break;
  901.  
  902.          case CASE_DECREQTPARM:
  903.             /* DECREQTPARM */
  904.             if ((row = param[0]) == DEFAULT)
  905.                 row = 0;
  906.             if (row == 0 || row == 1) {
  907.                 reply.a_type = CSI;
  908.                 reply.a_pintro = 0;
  909.                 reply.a_nparam = 7;
  910.                 reply.a_param[0] = row + 2;
  911.                 reply.a_param[1] = 1;    /* no parity */
  912.                 reply.a_param[2] = 1;    /* eight bits */
  913.                 reply.a_param[3] = 112;    /* transmit 9600 baud */
  914.                 reply.a_param[4] = 112;    /* receive 9600 baud */
  915.                 reply.a_param[5] = 1;    /* clock multiplier ? */
  916.                 reply.a_param[6] = 0;    /* STP flags ? */
  917.                 reply.a_inters = 0;
  918.                 reply.a_final  = 'x';
  919.                 unparseseq(&reply, screen->respond);
  920.             }
  921.             parsestate = groundtable;
  922.             break;
  923.  
  924.          case CASE_DECSET:
  925.             /* DECSET */
  926.             dpmodes(term, bitset);
  927.             parsestate = groundtable;
  928.             if(screen->TekEmu)
  929.                 return;
  930.             break;
  931.  
  932.          case CASE_DECRST:
  933.             /* DECRST */
  934.             dpmodes(term, bitclr);
  935.             parsestate = groundtable;
  936.             break;
  937.  
  938.          case CASE_DECALN:
  939.             /* DECALN */
  940.             if(screen->cursor_state)
  941.                 HideCursor();
  942.             for(row = screen->max_row ; row >= 0 ; row--) {
  943.                 bzero(screen->buf[2 * row + 1],
  944.                  col = screen->max_col + 1);
  945.                 for(cp = (unsigned char *)screen->buf[2 * row] ; col > 0 ; col--)
  946.                     *cp++ = (unsigned char) 'E';
  947.             }
  948.             ScrnRefresh(screen, 0, 0, screen->max_row + 1,
  949.              screen->max_col + 1, False);
  950.             parsestate = groundtable;
  951.             break;
  952.  
  953.          case CASE_GSETS:
  954.             screen->gsets[scstype] = c;
  955.             parsestate = groundtable;
  956.             break;
  957.  
  958.          case CASE_DECSC:
  959.             /* DECSC */
  960.             CursorSave(term, &screen->sc);
  961.             parsestate = groundtable;
  962.             break;
  963.  
  964.          case CASE_DECRC:
  965.             /* DECRC */
  966.             CursorRestore(term, &screen->sc);
  967.             parsestate = groundtable;
  968.             break;
  969.  
  970.          case CASE_DECKPAM:
  971.             /* DECKPAM */
  972.             term->keyboard.flags |= KYPD_APL;
  973.             update_appkeypad();
  974.             parsestate = groundtable;
  975.             break;
  976.  
  977.          case CASE_DECKPNM:
  978.             /* DECKPNM */
  979.             term->keyboard.flags &= ~KYPD_APL;
  980.             update_appkeypad();
  981.             parsestate = groundtable;
  982.             break;
  983.  
  984.          case CASE_IND:
  985.             /* IND */
  986.             Index(screen, 1);
  987.             if (QLength(screen->display) > 0 ||
  988.                 GetBytesAvailable (ConnectionNumber(screen->display)) > 0)
  989.               xevents();
  990.             parsestate = groundtable;
  991.             break;
  992.  
  993.          case CASE_NEL:
  994.             /* NEL */
  995.             Index(screen, 1);
  996.             CarriageReturn(screen);
  997.             
  998.             if (QLength(screen->display) > 0 ||
  999.                 GetBytesAvailable (ConnectionNumber(screen->display)) > 0)
  1000.               xevents();
  1001.             parsestate = groundtable;
  1002.             break;
  1003.  
  1004.          case CASE_HTS:
  1005.             /* HTS */
  1006.             TabSet(term->tabs, screen->cur_col);
  1007.             parsestate = groundtable;
  1008.             break;
  1009.  
  1010.          case CASE_RI:
  1011.             /* RI */
  1012.             RevIndex(screen, 1);
  1013.             parsestate = groundtable;
  1014.             break;
  1015.  
  1016.          case CASE_SS2:
  1017.             /* SS2 */
  1018.             screen->curss = 2;
  1019.             parsestate = groundtable;
  1020.             break;
  1021.  
  1022.          case CASE_SS3:
  1023.             /* SS3 */
  1024.             screen->curss = 3;
  1025.             parsestate = groundtable;
  1026.             break;
  1027.  
  1028.          case CASE_CSI_STATE:
  1029.             /* enter csi state */
  1030.             nparam = 1;
  1031.             param[0] = DEFAULT;
  1032.             parsestate = csitable;
  1033.             break;
  1034.  
  1035.          case CASE_OSC:
  1036.             /* Operating System Command: ESC ] */
  1037.             do_osc(finput);
  1038.             parsestate = groundtable;
  1039.             break;
  1040.  
  1041.          case CASE_RIS:
  1042.             /* RIS */
  1043.             VTReset(TRUE);
  1044.             parsestate = groundtable;
  1045.             break;
  1046.  
  1047.          case CASE_LS2:
  1048.             /* LS2 */
  1049.             screen->curgl = 2;
  1050.             parsestate = groundtable;
  1051.             break;
  1052.  
  1053.          case CASE_LS3:
  1054.             /* LS3 */
  1055.             screen->curgl = 3;
  1056.             parsestate = groundtable;
  1057.             break;
  1058.  
  1059.          case CASE_LS3R:
  1060.             /* LS3R */
  1061.             screen->curgr = 3;
  1062.             parsestate = groundtable;
  1063.             break;
  1064.  
  1065.          case CASE_LS2R:
  1066.             /* LS2R */
  1067.             screen->curgr = 2;
  1068.             parsestate = groundtable;
  1069.             break;
  1070.  
  1071.          case CASE_LS1R:
  1072.             /* LS1R */
  1073.             screen->curgr = 1;
  1074.             parsestate = groundtable;
  1075.             break;
  1076.  
  1077.          case CASE_XTERM_SAVE:
  1078.             savemodes(term);
  1079.             parsestate = groundtable;
  1080.             break;
  1081.  
  1082.          case CASE_XTERM_RESTORE:
  1083.             restoremodes(term);
  1084.             parsestate = groundtable;
  1085.             break;
  1086.         }
  1087.     }
  1088. }
  1089.  
  1090. static finput()
  1091. {
  1092.     return(doinput());
  1093. }
  1094.  
  1095.  
  1096. static char *v_buffer;        /* pointer to physical buffer */
  1097. static char *v_bufstr = NULL;    /* beginning of area to write */
  1098. static char *v_bufptr;        /* end of area to write */
  1099. static char *v_bufend;        /* end of physical buffer */
  1100. #define    ptymask()    (v_bufptr > v_bufstr ? pty_mask : 0)
  1101.  
  1102. /* Write data to the pty as typed by the user, pasted with the mouse,
  1103.    or generated by us in response to a query ESC sequence. */
  1104.  
  1105. v_write(f, d, len)
  1106.     int f;
  1107.     char *d;
  1108.     int len;
  1109. {
  1110.     int riten;
  1111.     int c = len;
  1112.  
  1113.     if (v_bufstr == NULL  &&  len > 0) {
  1114.             v_buffer = XtMalloc(len);
  1115.         v_bufstr = v_buffer;
  1116.         v_bufptr = v_buffer;
  1117.         v_bufend = v_buffer + len;
  1118.     }
  1119. #ifdef DEBUG
  1120.     fprintf(stderr, "v_write called with %d bytes (%d left over)",
  1121.         len, v_bufptr - v_bufstr);
  1122.     if (len > 1  &&  len < 10) fprintf(stderr, " \"%.*s\"", len, d);
  1123.     fprintf(stderr, "\n");
  1124. #endif
  1125.  
  1126.     if ((1 << f) != pty_mask)
  1127.         return(write(f, d, len));
  1128.  
  1129.     /*
  1130.      * Append to the block we already have.
  1131.      * Always doing this simplifies the code, and
  1132.      * isn't too bad, either.  If this is a short
  1133.      * block, it isn't too expensive, and if this is
  1134.      * a long block, we won't be able to write it all
  1135.      * anyway.
  1136.      */
  1137.  
  1138.     if (len > 0) {
  1139.         if (v_bufend < v_bufptr + len) { /* we've run out of room */
  1140.         if (v_bufstr != v_buffer) {
  1141.             /* there is unused space, move everything down */
  1142.             /* possibly overlapping bcopy here */
  1143. #ifdef DEBUG
  1144.             fprintf(stderr, "moving data down %d\n",
  1145.                 v_bufstr - v_buffer);
  1146. #endif
  1147.             bcopy(v_bufstr, v_buffer, v_bufptr - v_bufstr);
  1148.             v_bufptr -= v_bufstr - v_buffer;
  1149.             v_bufstr = v_buffer;
  1150.         }
  1151.         if (v_bufend < v_bufptr + len) {
  1152.             /* still won't fit: get more space */
  1153.             /* Don't use XtRealloc because an error is not fatal. */
  1154.             int size = v_bufptr - v_buffer; /* save across realloc */
  1155.             v_buffer = realloc(v_buffer, size + len);
  1156.             if (v_buffer) {
  1157. #ifdef DEBUG
  1158.             fprintf(stderr, "expanded buffer to %d\n",
  1159.                 size + len);
  1160. #endif
  1161.             v_bufstr = v_buffer;
  1162.             v_bufptr = v_buffer + size;
  1163.             v_bufend = v_bufptr + len;
  1164.             } else {
  1165.             /* no memory: ignore entire write request */
  1166.             fprintf(stderr, "%s: cannot allocate buffer space\n",
  1167.                 xterm_name);
  1168.             v_buffer = v_bufstr; /* restore clobbered pointer */
  1169.             c = 0;
  1170.             }
  1171.         }
  1172.         }
  1173.         if (v_bufend >= v_bufptr + len) {
  1174.         /* new stuff will fit */
  1175.         bcopy(d, v_bufptr, len);
  1176.         v_bufptr += len;
  1177.         }
  1178.     }
  1179.  
  1180.     /*
  1181.      * Write out as much of the buffer as we can.
  1182.      * Be careful not to overflow the pty's input silo.
  1183.      * We are conservative here and only write
  1184.      * a small amount at a time.
  1185.      *
  1186.      * If we can't push all the data into the pty yet, we expect write
  1187.      * to return a non-negative number less than the length requested
  1188.      * (if some data written) or -1 and set errno to EAGAIN,
  1189.      * EWOULDBLOCK, or EINTR (if no data written).
  1190.      *
  1191.      * (Not all systems do this, sigh, so the code is actually
  1192.      * a little more forgiving.)
  1193.      */
  1194.  
  1195. #define MAX_PTY_WRITE 128    /* 1/2 POSIX minimum MAX_INPUT */
  1196.  
  1197.     if (v_bufptr > v_bufstr) {
  1198.         riten = write(f, v_bufstr, v_bufptr - v_bufstr <= MAX_PTY_WRITE ?
  1199.                          v_bufptr - v_bufstr : MAX_PTY_WRITE);
  1200.         if (riten < 0) {
  1201. #ifdef DEBUG
  1202.         perror("write");
  1203. #endif
  1204.         riten = 0;
  1205.         }
  1206. #ifdef DEBUG
  1207.         fprintf(stderr, "write called with %d, wrote %d\n",
  1208.             v_bufptr - v_bufstr <= MAX_PTY_WRITE ?
  1209.             v_bufptr - v_bufstr : MAX_PTY_WRITE,
  1210.             riten);
  1211. #endif
  1212.         v_bufstr += riten;
  1213.         if (v_bufstr >= v_bufptr) /* we wrote it all */
  1214.         v_bufstr = v_bufptr = v_buffer;
  1215.     }
  1216.  
  1217.     /*
  1218.      * If we have lots of unused memory allocated, return it
  1219.      */
  1220.     if (v_bufend - v_bufptr > 1024) { /* arbitrary hysteresis */
  1221.         /* save pointers across realloc */
  1222.         int start = v_bufstr - v_buffer;
  1223.         int size = v_bufptr - v_buffer;
  1224.         int allocsize = size ? size : 1;
  1225.         
  1226.         v_buffer = realloc(v_buffer, allocsize);
  1227.         if (v_buffer) {
  1228.         v_bufstr = v_buffer + start;
  1229.         v_bufptr = v_buffer + size;
  1230.         v_bufend = v_buffer + allocsize;
  1231. #ifdef DEBUG
  1232.         fprintf(stderr, "shrunk buffer to %d\n", allocsize);
  1233. #endif
  1234.         } else {
  1235.         /* should we print a warning if couldn't return memory? */
  1236.         v_buffer = v_bufstr - start; /* restore clobbered pointer */
  1237.         }
  1238.     }
  1239.     return(c);
  1240. }
  1241.  
  1242. static int select_mask;
  1243. static int write_mask;
  1244. static int pty_read_bytes;
  1245.  
  1246. in_put()
  1247. {
  1248.     register TScreen *screen = &term->screen;
  1249.     register int i;
  1250.     static struct timeval select_timeout;
  1251.  
  1252.     for( ; ; ) {
  1253.     if (select_mask & pty_mask && eventMode == NORMAL) {
  1254.         if (screen->logging)
  1255.         FlushLog(screen);
  1256.         bcnt = read(screen->respond, (char *)(bptr = buffer), BUF_SIZE);
  1257.         if (bcnt < 0) {
  1258.         if (errno == EIO)
  1259.             Cleanup (0);
  1260.         else if (!E_TEST(errno))
  1261.             Panic(
  1262.               "input: read returned unexpected error (%d)\n",
  1263.               errno);
  1264.         } else if (bcnt == 0)
  1265.         Panic("input: read returned zero\n", 0);
  1266.         else {
  1267.         /* read from pty was successful */
  1268.         if (!screen->output_eight_bits) {
  1269.             register int bc = bcnt;
  1270.             register Char *b = bptr;
  1271.  
  1272.             for (; bc > 0; bc--, b++) {
  1273.             *b &= (Char) 0x7f;
  1274.             }
  1275.         }
  1276.         if ( screen->scrollWidget && screen->scrollttyoutput &&
  1277.              screen->topline < 0)
  1278.             WindowScroll(screen, 0);  /* Scroll to bottom */
  1279.         pty_read_bytes += bcnt;
  1280.         /* stop speed reading at some point to look for X stuff */
  1281.         /* (4096 is just a random large number.) */
  1282.         if (pty_read_bytes > 4096) {
  1283.             select_mask &= ~pty_mask;
  1284.         }
  1285.         break;
  1286.         }
  1287.     }
  1288.     pty_read_bytes = 0;
  1289.     /* update the screen */
  1290.     if (screen->scroll_amt)
  1291.         FlushScroll(screen);
  1292.     if (screen->cursor_set && (screen->cursor_col != screen->cur_col
  1293.                    || screen->cursor_row != screen->cur_row)) {
  1294.         if (screen->cursor_state)
  1295.         HideCursor();
  1296.         ShowCursor();
  1297.     } else if (screen->cursor_set != screen->cursor_state) {
  1298.         if (screen->cursor_set)
  1299.         ShowCursor();
  1300.         else
  1301.         HideCursor();
  1302.     }
  1303.  
  1304.     XFlush(screen->display); /* always flush writes before waiting */
  1305.  
  1306.     /* Update the masks and, unless X events are already in the queue,
  1307.        wait for I/O to be possible. */
  1308.     select_mask = Select_mask;
  1309.     write_mask = ptymask();
  1310.     select_timeout.tv_sec = 0;
  1311.     select_timeout.tv_usec = 0;
  1312.     i = select(max_plus1, &select_mask, &write_mask, (int *)NULL,
  1313.            QLength(screen->display) ? &select_timeout
  1314.            : (struct timeval *) NULL);
  1315.     if (i < 0) {
  1316.         if (errno != EINTR)
  1317.         SysError(ERROR_SELECT);
  1318.         continue;
  1319.     } 
  1320.  
  1321.     /* if there is room to write more data to the pty, go write more */
  1322.     if (write_mask & ptymask()) {
  1323.         v_write(screen->respond, 0, 0); /* flush buffer */
  1324.     }
  1325.  
  1326.     /* if there are X events already in our queue, it
  1327.        counts as being readable */
  1328.     if (QLength(screen->display) || (select_mask & X_mask)) {
  1329.         xevents();
  1330.     }
  1331.  
  1332.     }
  1333.     bcnt--;
  1334.     return(*bptr++);
  1335. }
  1336.  
  1337. /*
  1338.  * process a string of characters according to the character set indicated
  1339.  * by charset.  worry about end of line conditions (wraparound if selected).
  1340.  */
  1341. static void
  1342. dotext(screen, flags, charset, buf, ptr)
  1343.     register TScreen    *screen;
  1344.     unsigned    flags;
  1345.     char    charset;
  1346.     char    *buf;        /* start of characters to process */
  1347.     char    *ptr;        /* end */
  1348. {
  1349.     register char    *s;
  1350.     register int    len;
  1351.     register int    n;
  1352.     register int    next_col;
  1353.  
  1354.     switch (charset) {
  1355.     case 'A':    /* United Kingdom set            */
  1356.         for (s=buf; s<ptr; ++s)
  1357.             if (*s == '#')
  1358.                 *s = '\036';    /* UK pound sign*/
  1359.         break;
  1360.  
  1361.     case 'B':    /* ASCII set                */
  1362.         break;
  1363.  
  1364.     case '0':    /* special graphics (line drawing)    */
  1365.         for (s=buf; s<ptr; ++s)
  1366.             if (*s>=0x5f && *s<=0x7e)
  1367.                 *s = *s == 0x5f ? 0x7f : *s - 0x5f;
  1368.         break;
  1369.  
  1370.     default:    /* any character sets we don't recognize*/
  1371.         return;
  1372.     }
  1373.  
  1374.     len = ptr - buf; 
  1375.     ptr = buf;
  1376.     while (len > 0) {
  1377.         n = screen->max_col - screen->cur_col +1;
  1378.         if (n <= 1) {
  1379.             if (screen->do_wrap && (flags&WRAPAROUND)) {
  1380.                 /* mark that we had to wrap this line */
  1381.                 ScrnSetAttributes(screen, screen->cur_row, 0,
  1382.                           LINEWRAPPED, LINEWRAPPED, 1);
  1383.                 Index(screen, 1);
  1384.                 screen->cur_col = 0;
  1385.                 screen->do_wrap = 0;
  1386.                 n = screen->max_col+1;
  1387.             } else
  1388.                 n = 1;
  1389.         }
  1390.         if (len < n)
  1391.             n = len;
  1392.         next_col = screen->cur_col + n;
  1393.         WriteText(screen, ptr, n, flags);
  1394.         /*
  1395.          * the call to WriteText updates screen->cur_col.
  1396.          * If screen->cur_col != next_col, we must have
  1397.          * hit the right margin, so set the do_wrap flag.
  1398.          */
  1399.         screen->do_wrap = (screen->cur_col < next_col);
  1400.         len -= n;
  1401.         ptr += n;
  1402.     }
  1403. }
  1404.  
  1405. /*
  1406.  * write a string str of length len onto the screen at
  1407.  * the current cursor position.  update cursor position.
  1408.  */
  1409. static void
  1410. WriteText(screen, str, len, flags)
  1411.     register TScreen    *screen;
  1412.     register char    *str;
  1413.     register int    len;
  1414.     unsigned        flags;
  1415. {
  1416.     register int cx, cy;
  1417.     register unsigned fgs = flags;
  1418.     GC    currentGC;
  1419.  
  1420.    if(screen->cur_row - screen->topline <= screen->max_row) {
  1421.     /*
  1422.     if(screen->cur_row == screen->cursor_row && screen->cur_col <=
  1423.      screen->cursor_col && screen->cursor_col <= screen->cur_col + len - 1)
  1424.         screen->cursor_state = OFF;
  1425.      */
  1426.     if(screen->cursor_state)
  1427.         HideCursor();
  1428.  
  1429.     /*
  1430.      *    make sure that the correct GC is current
  1431.      */
  1432.  
  1433.     if (fgs & BOLD)
  1434.         if (fgs & INVERSE)
  1435.             currentGC = screen->reverseboldGC;
  1436.         else    currentGC = screen->normalboldGC;
  1437.     else  /* not bold */
  1438.         if (fgs & INVERSE)
  1439.             currentGC = screen->reverseGC;
  1440.         else    currentGC = screen->normalGC;
  1441.  
  1442.     if (fgs & INSERT)
  1443.         InsertChar(screen, len);
  1444.       if (!(AddToRefresh(screen))) {
  1445.         if(screen->scroll_amt)
  1446.             FlushScroll(screen);
  1447.     cx = CursorX(screen, screen->cur_col);
  1448.     cy = CursorY(screen, screen->cur_row)+screen->fnt_norm->ascent;
  1449.      XDrawImageString(screen->display, TextWindow(screen), currentGC,
  1450.             cx, cy, str, len);
  1451.  
  1452.     if((fgs & BOLD) && screen->enbolden) 
  1453.         if (currentGC == screen->normalGC || screen->reverseGC)
  1454.             XDrawString(screen->display, TextWindow(screen),
  1455.                       currentGC,cx + 1, cy, str, len);
  1456.  
  1457.     if(fgs & UNDERLINE) 
  1458.         XDrawLine(screen->display, TextWindow(screen), currentGC,
  1459.             cx, cy+1,
  1460.             cx + len * FontWidth(screen), cy+1);
  1461.     /*
  1462.      * the following statements compile data to compute the average 
  1463.      * number of characters written on each call to XText.  The data
  1464.      * may be examined via the use of a "hidden" escape sequence.
  1465.      */
  1466.     ctotal += len;
  1467.     ++ntotal;
  1468.       }
  1469.     }
  1470.     ScreenWrite(screen, str, flags, len);
  1471.     CursorForward(screen, len);
  1472. }
  1473.  
  1474. /*
  1475.  * process ANSI modes set, reset
  1476.  */
  1477. ansi_modes(termw, func)
  1478.     XtermWidget    termw;
  1479.     int        (*func)();
  1480. {
  1481.     register int    i;
  1482.  
  1483.     for (i=0; i<nparam; ++i) {
  1484.         switch (param[i]) {
  1485.         case 4:            /* IRM                */
  1486.             (*func)(&termw->flags, INSERT);
  1487.             break;
  1488.  
  1489.         case 20:        /* LNM                */
  1490.             (*func)(&termw->flags, LINEFEED);
  1491.             update_autolinefeed();
  1492.             break;
  1493.         }
  1494.     }
  1495. }
  1496.  
  1497. /*
  1498.  * process DEC private modes set, reset
  1499.  */
  1500. dpmodes(termw, func)
  1501.     XtermWidget    termw;
  1502.     void (*func)();
  1503. {
  1504.     register TScreen    *screen    = &termw->screen;
  1505.     register int    i, j;
  1506.  
  1507.     for (i=0; i<nparam; ++i) {
  1508.         switch (param[i]) {
  1509.         case 1:            /* DECCKM            */
  1510.             (*func)(&termw->keyboard.flags, CURSOR_APL);
  1511.             update_appcursor();
  1512.             break;
  1513.         case 2:            /* ANSI/VT52 mode        */
  1514.             if (func == bitset) {
  1515.                 screen->gsets[0] =
  1516.                     screen->gsets[1] =
  1517.                     screen->gsets[2] =
  1518.                     screen->gsets[3] = 'B';
  1519.                 screen->curgl = 0;
  1520.                 screen->curgr = 2;
  1521.             }
  1522.             break;
  1523.         case 3:            /* DECCOLM            */
  1524.             if(screen->c132) {
  1525.                 ClearScreen(screen);
  1526.                 CursorSet(screen, 0, 0, termw->flags);
  1527.                 if((j = func == bitset ? 132 : 80) !=
  1528.                  ((termw->flags & IN132COLUMNS) ? 132 : 80) ||
  1529.                  j != screen->max_col + 1) {
  1530.                         Dimension replyWidth, replyHeight;
  1531.                     XtGeometryResult status;
  1532.  
  1533.                     status = XtMakeResizeRequest (
  1534.                         (Widget) termw, 
  1535.                         (Dimension) FontWidth(screen) * j
  1536.                             + 2*screen->border
  1537.                         + screen->scrollbar,
  1538.                         (Dimension) FontHeight(screen)
  1539.                         * (screen->max_row + 1)
  1540.                         + 2 * screen->border,
  1541.                         &replyWidth, &replyHeight);
  1542.  
  1543.                     if (status == XtGeometryYes ||
  1544.                         status == XtGeometryDone) {
  1545.                         ScreenResize (&termw->screen,
  1546.                               replyWidth,
  1547.                               replyHeight,
  1548.                               &termw->flags);
  1549.                     }
  1550.                 }
  1551.                 (*func)(&termw->flags, IN132COLUMNS);
  1552.             }
  1553.             break;
  1554.         case 4:            /* DECSCLM (slow scroll)    */
  1555.             if (func == bitset) {
  1556.                 screen->jumpscroll = 0;
  1557.                 if (screen->scroll_amt)
  1558.                     FlushScroll(screen);
  1559.             } else
  1560.                 screen->jumpscroll = 1;
  1561.             (*func)(&termw->flags, SMOOTHSCROLL);
  1562.             update_jumpscroll();
  1563.             break;
  1564.         case 5:            /* DECSCNM            */
  1565.             j = termw->flags;
  1566.             (*func)(&termw->flags, REVERSE_VIDEO);
  1567.             if ((termw->flags ^ j) & REVERSE_VIDEO)
  1568.                 ReverseVideo(termw);
  1569.             /* update_reversevideo done in RevVid */
  1570.             break;
  1571.  
  1572.         case 6:            /* DECOM            */
  1573.             (*func)(&termw->flags, ORIGIN);
  1574.             CursorSet(screen, 0, 0, termw->flags);
  1575.             break;
  1576.  
  1577.         case 7:            /* DECAWM            */
  1578.             (*func)(&termw->flags, WRAPAROUND);
  1579.             update_autowrap();
  1580.             break;
  1581.         case 8:            /* DECARM            */
  1582.             /* ignore autorepeat */
  1583.             break;
  1584.         case 9:            /* MIT bogus sequence        */
  1585.             if(func == bitset)
  1586.                 screen->send_mouse_pos = 1;
  1587.             else
  1588.                 screen->send_mouse_pos = 0;
  1589.             break;
  1590.         case 38:        /* DECTEK            */
  1591.             if(func == bitset && !(screen->inhibit & I_TEK)) {
  1592.                 if(screen->logging) {
  1593.                     FlushLog(screen);
  1594.                     screen->logstart = Tbuffer;
  1595.                 }
  1596.                 screen->TekEmu = TRUE;
  1597.             }
  1598.             break;
  1599.         case 40:        /* 132 column mode        */
  1600.             screen->c132 = (func == bitset);
  1601.             update_allow132();
  1602.             break;
  1603.         case 41:        /* curses hack            */
  1604.             screen->curses = (func == bitset);
  1605.             update_cursesemul();
  1606.             break;
  1607.         case 44:        /* margin bell            */
  1608.             screen->marginbell = (func == bitset);
  1609.             if(!screen->marginbell)
  1610.                 screen->bellarmed = -1;
  1611.             update_marginbell();
  1612.             break;
  1613.         case 45:        /* reverse wraparound    */
  1614.             (*func)(&termw->flags, REVERSEWRAP);
  1615.             update_reversewrap();
  1616.             break;
  1617.         case 46:        /* logging        */
  1618. #ifdef ALLOWLOGFILEONOFF
  1619.             /*
  1620.              * if this feature is enabled, logging may be 
  1621.              * enabled and disabled via escape sequences.
  1622.              */
  1623.             if(func == bitset)
  1624.                 StartLog(screen);
  1625.             else
  1626.                 CloseLog(screen);
  1627. #else
  1628.             Bell();
  1629.             Bell();
  1630. #endif /* ALLOWLOGFILEONOFF */
  1631.             break;
  1632.         case 47:        /* alternate buffer */
  1633.             if (!termw->misc.titeInhibit) {
  1634.                 if(func == bitset)
  1635.                 ToAlternate(screen);
  1636.                 else
  1637.                 FromAlternate(screen);
  1638.             }
  1639.             break;
  1640.         case 1000:        /* xterm bogus sequence        */
  1641.             if(func == bitset)
  1642.                 screen->send_mouse_pos = 2;
  1643.             else
  1644.                 screen->send_mouse_pos = 0;
  1645.             break;
  1646.         case 1001:        /* xterm sequence w/hilite tracking */
  1647.             if(func == bitset)
  1648.                 screen->send_mouse_pos = 3;
  1649.             else
  1650.                 screen->send_mouse_pos = 0;
  1651.             break;
  1652.         }
  1653.     }
  1654. }
  1655.  
  1656. /*
  1657.  * process xterm private modes save
  1658.  */
  1659. savemodes(termw)
  1660.     XtermWidget termw;
  1661. {
  1662.     register TScreen    *screen    = &termw->screen;
  1663.     register int i;
  1664.  
  1665.     for (i = 0; i < nparam; i++) {
  1666.         switch (param[i]) {
  1667.         case 1:            /* DECCKM            */
  1668.             screen->save_modes[0] = termw->keyboard.flags &
  1669.              CURSOR_APL;
  1670.             break;
  1671.         case 3:            /* DECCOLM            */
  1672.             if(screen->c132)
  1673.                 screen->save_modes[1] = termw->flags & IN132COLUMNS;
  1674.             break;
  1675.         case 4:            /* DECSCLM (slow scroll)    */
  1676.             screen->save_modes[2] = termw->flags & SMOOTHSCROLL;
  1677.             break;
  1678.         case 5:            /* DECSCNM            */
  1679.             screen->save_modes[3] = termw->flags & REVERSE_VIDEO;
  1680.             break;
  1681.         case 6:            /* DECOM            */
  1682.             screen->save_modes[4] = termw->flags & ORIGIN;
  1683.             break;
  1684.  
  1685.         case 7:            /* DECAWM            */
  1686.             screen->save_modes[5] = termw->flags & WRAPAROUND;
  1687.             break;
  1688.         case 8:            /* DECARM            */
  1689.             /* ignore autorepeat */
  1690.             break;
  1691.         case 9:            /* mouse bogus sequence */
  1692.             screen->save_modes[7] = screen->send_mouse_pos;
  1693.             break;
  1694.         case 40:        /* 132 column mode        */
  1695.             screen->save_modes[8] = screen->c132;
  1696.             break;
  1697.         case 41:        /* curses hack            */
  1698.             screen->save_modes[9] = screen->curses;
  1699.             break;
  1700.         case 44:        /* margin bell            */
  1701.             screen->save_modes[12] = screen->marginbell;
  1702.             break;
  1703.         case 45:        /* reverse wraparound    */
  1704.             screen->save_modes[13] = termw->flags & REVERSEWRAP;
  1705.             break;
  1706.         case 46:        /* logging        */
  1707.             screen->save_modes[14] = screen->logging;
  1708.             break;
  1709.         case 47:        /* alternate buffer        */
  1710.             screen->save_modes[15] = screen->alternate;
  1711.             break;
  1712.         case 1000:        /* mouse bogus sequence        */
  1713.         case 1001:
  1714.             screen->save_modes[7] = screen->send_mouse_pos;
  1715.             break;
  1716.         }
  1717.     }
  1718. }
  1719.  
  1720. /*
  1721.  * process xterm private modes restore
  1722.  */
  1723. restoremodes(termw)
  1724.     XtermWidget termw;
  1725. {
  1726.     register TScreen    *screen    = &termw->screen;
  1727.     register int i, j;
  1728.  
  1729.     for (i = 0; i < nparam; i++) {
  1730.         switch (param[i]) {
  1731.         case 1:            /* DECCKM            */
  1732.             termw->keyboard.flags &= ~CURSOR_APL;
  1733.             termw->keyboard.flags |= screen->save_modes[0] &
  1734.              CURSOR_APL;
  1735.             update_appcursor();
  1736.             break;
  1737.         case 3:            /* DECCOLM            */
  1738.             if(screen->c132) {
  1739.                 ClearScreen(screen);
  1740.                 CursorSet(screen, 0, 0, termw->flags);
  1741.                 if((j = (screen->save_modes[1] & IN132COLUMNS)
  1742.                  ? 132 : 80) != ((termw->flags & IN132COLUMNS)
  1743.                  ? 132 : 80) || j != screen->max_col + 1) {
  1744.                         Dimension replyWidth, replyHeight;
  1745.                     XtGeometryResult status;
  1746.                     status = XtMakeResizeRequest (
  1747.                         (Widget) termw,
  1748.                         (Dimension) FontWidth(screen) * j 
  1749.                         + 2*screen->border
  1750.                         + screen->scrollbar,
  1751.                         (Dimension) FontHeight(screen)
  1752.                         * (screen->max_row + 1)
  1753.                         + 2*screen->border,
  1754.                         &replyWidth, &replyHeight);
  1755.  
  1756.                     if (status == XtGeometryYes ||
  1757.                         status == XtGeometryDone) {
  1758.                         ScreenResize (&termw->screen,
  1759.                               replyWidth,
  1760.                               replyHeight,
  1761.                               &termw->flags);
  1762.                     }
  1763.                 }
  1764.                 termw->flags &= ~IN132COLUMNS;
  1765.                 termw->flags |= screen->save_modes[1] &
  1766.                  IN132COLUMNS;
  1767.             }
  1768.             break;
  1769.         case 4:            /* DECSCLM (slow scroll)    */
  1770.             if (screen->save_modes[2] & SMOOTHSCROLL) {
  1771.                 screen->jumpscroll = 0;
  1772.                 if (screen->scroll_amt)
  1773.                     FlushScroll(screen);
  1774.             } else
  1775.                 screen->jumpscroll = 1;
  1776.             termw->flags &= ~SMOOTHSCROLL;
  1777.             termw->flags |= screen->save_modes[2] & SMOOTHSCROLL;
  1778.             update_jumpscroll();
  1779.             break;
  1780.         case 5:            /* DECSCNM            */
  1781.             if((screen->save_modes[3] ^ termw->flags) & REVERSE_VIDEO) {
  1782.                 termw->flags &= ~REVERSE_VIDEO;
  1783.                 termw->flags |= screen->save_modes[3] & REVERSE_VIDEO;
  1784.                 ReverseVideo(termw);
  1785.                 /* update_reversevideo done in RevVid */
  1786.             }
  1787.             break;
  1788.         case 6:            /* DECOM            */
  1789.             termw->flags &= ~ORIGIN;
  1790.             termw->flags |= screen->save_modes[4] & ORIGIN;
  1791.             CursorSet(screen, 0, 0, termw->flags);
  1792.             break;
  1793.  
  1794.         case 7:            /* DECAWM            */
  1795.             termw->flags &= ~WRAPAROUND;
  1796.             termw->flags |= screen->save_modes[5] & WRAPAROUND;
  1797.             update_autowrap();
  1798.             break;
  1799.         case 8:            /* DECARM            */
  1800.             /* ignore autorepeat */
  1801.             break;
  1802.         case 9:            /* MIT bogus sequence        */
  1803.             screen->send_mouse_pos = screen->save_modes[7];
  1804.             break;
  1805.         case 40:        /* 132 column mode        */
  1806.             screen->c132 = screen->save_modes[8];
  1807.             update_allow132();
  1808.             break;
  1809.         case 41:        /* curses hack            */
  1810.             screen->curses = screen->save_modes[9];
  1811.             update_cursesemul();
  1812.             break;
  1813.         case 44:        /* margin bell            */
  1814.             if(!(screen->marginbell = screen->save_modes[12]))
  1815.                 screen->bellarmed = -1;
  1816.             update_marginbell();
  1817.             break;
  1818.         case 45:        /* reverse wraparound    */
  1819.             termw->flags &= ~REVERSEWRAP;
  1820.             termw->flags |= screen->save_modes[13] & REVERSEWRAP;
  1821.             update_reversewrap();
  1822.             break;
  1823.         case 46:        /* logging        */
  1824. #ifdef ALLOWLOGFILEONOFF
  1825.             if(screen->save_modes[14])
  1826.                 StartLog(screen);
  1827.             else
  1828.                 CloseLog(screen);
  1829. #endif /* ALLOWLOGFILEONOFF */
  1830.             /* update_logging done by StartLog and CloseLog */
  1831.             break;
  1832.         case 47:        /* alternate buffer */
  1833.             if (!termw->misc.titeInhibit) {
  1834.                 if(screen->save_modes[15])
  1835.                 ToAlternate(screen);
  1836.                 else
  1837.                 FromAlternate(screen);
  1838.                 /* update_altscreen done by ToAlt and FromAlt */
  1839.             }
  1840.             break;
  1841.         case 1000:        /* mouse bogus sequence        */
  1842.         case 1001:
  1843.             screen->send_mouse_pos = screen->save_modes[7];
  1844.             break;
  1845.         }
  1846.     }
  1847. }
  1848.  
  1849. /*
  1850.  * set a bit in a word given a pointer to the word and a mask.
  1851.  */
  1852. static void bitset(p, mask)
  1853.     unsigned *p;
  1854.     int mask;
  1855. {
  1856.     *p |= mask;
  1857. }
  1858.  
  1859. /*
  1860.  * clear a bit in a word given a pointer to the word and a mask.
  1861.  */
  1862. static void bitclr(p, mask)
  1863.     unsigned *p;
  1864.     int mask;
  1865. {
  1866.     *p &= ~mask;
  1867. }
  1868.  
  1869. unparseseq(ap, fd)
  1870.     register ANSI *ap;
  1871.     int fd;
  1872. {
  1873.     register int    c;
  1874.     register int    i;
  1875.     register int    inters;
  1876.  
  1877.     c = ap->a_type;
  1878.     if (c>=0x80 && c<=0x9F) {
  1879.         unparseputc(ESC, fd);
  1880.         c -= 0x40;
  1881.     }
  1882.     unparseputc(c, fd);
  1883.     c = ap->a_type;
  1884.     if (c==ESC || c==DCS || c==CSI || c==OSC || c==PM || c==APC) {
  1885.         if (ap->a_pintro != 0)
  1886.             unparseputc((char) ap->a_pintro, fd);
  1887.         for (i=0; i<ap->a_nparam; ++i) {
  1888.             if (i != 0)
  1889.                 unparseputc(';', fd);
  1890.             unparseputn((unsigned int) ap->a_param[i], fd);
  1891.         }
  1892.         inters = ap->a_inters;
  1893.         for (i=3; i>=0; --i) {
  1894.             c = (inters >> (8*i)) & 0xff;
  1895.             if (c != 0)
  1896.                 unparseputc(c, fd);
  1897.         }
  1898.         unparseputc((char) ap->a_final, fd);
  1899.     }
  1900. }
  1901.  
  1902. unparseputn(n, fd)
  1903. unsigned int    n;
  1904. int fd;
  1905. {
  1906.     unsigned int    q;
  1907.  
  1908.     q = n/10;
  1909.     if (q != 0)
  1910.         unparseputn(q, fd);
  1911.     unparseputc((char) ('0' + (n%10)), fd);
  1912. }
  1913.  
  1914. unparseputc(c, fd)
  1915. char c;
  1916. int fd;
  1917. {
  1918.     char    buf[2];
  1919.     register i = 1;
  1920.     extern XtermWidget term;
  1921.  
  1922.     if((buf[0] = c) == '\r' && (term->flags & LINEFEED)) {
  1923.         buf[1] = '\n';
  1924.         i++;
  1925.     }
  1926.     v_write(fd, buf, i);
  1927. }
  1928.  
  1929. unparsefputs (s, fd)
  1930.     register char *s;
  1931.     int fd;
  1932. {
  1933.     if (s) {
  1934.     while (*s) unparseputc (*s++, fd);
  1935.     }
  1936. }
  1937.  
  1938. static void SwitchBufs();
  1939.  
  1940. ToAlternate(screen)
  1941. register TScreen *screen;
  1942. {
  1943.     extern ScrnBuf Allocate();
  1944.  
  1945.     if(screen->alternate)
  1946.         return;
  1947.     if(!screen->altbuf)
  1948.         screen->altbuf = Allocate(screen->max_row + 1, screen->max_col
  1949.          + 1, &screen->abuf_address);
  1950.     SwitchBufs(screen);
  1951.     screen->alternate = TRUE;
  1952.     update_altscreen();
  1953. }
  1954.  
  1955. FromAlternate(screen)
  1956. register TScreen *screen;
  1957. {
  1958.     if(!screen->alternate)
  1959.         return;
  1960.     screen->alternate = FALSE;
  1961.     SwitchBufs(screen);
  1962.     update_altscreen();
  1963. }
  1964.  
  1965. static void
  1966. SwitchBufs(screen)
  1967.     register TScreen *screen;
  1968. {
  1969.     register int rows, top;
  1970.  
  1971.     if(screen->cursor_state)
  1972.         HideCursor();
  1973.     rows = screen->max_row + 1;
  1974.     SwitchBufPtrs(screen);
  1975.     TrackText(0, 0, 0, 0);    /* remove any highlighting */
  1976.     if((top = -screen->topline) <= screen->max_row) {
  1977.         if(screen->scroll_amt)
  1978.             FlushScroll(screen);
  1979.         if(top == 0)
  1980.             XClearWindow(screen->display, TextWindow(screen));
  1981.         else
  1982.             XClearArea(
  1983.                 screen->display,
  1984.                 TextWindow(screen),
  1985.                 (int) screen->border + screen->scrollbar,
  1986.                 (int) top * FontHeight(screen) + screen->border,
  1987.                 (unsigned) Width(screen),
  1988.                 (unsigned) (screen->max_row - top + 1)
  1989.                 * FontHeight(screen),
  1990.                 FALSE);
  1991.     }
  1992.     ScrnRefresh(screen, 0, 0, rows, screen->max_col + 1, False);
  1993. }
  1994.  
  1995. /* swap buffer line pointers between alt and regular screens */
  1996.  
  1997. SwitchBufPtrs(screen)
  1998.     register TScreen *screen;
  1999. {
  2000.     register int rows = screen->max_row + 1;
  2001.     char *save [2 * MAX_ROWS];
  2002.  
  2003.     bcopy((char *)screen->buf, (char *)save, 2 * sizeof(char *) * rows);
  2004.     bcopy((char *)screen->altbuf, (char *)screen->buf,
  2005.       2 * sizeof(char *) * rows);
  2006.     bcopy((char *)save, (char *)screen->altbuf, 2 * sizeof(char *) * rows);
  2007. }
  2008.  
  2009. VTRun()
  2010. {
  2011.     register TScreen *screen = &term->screen;
  2012.     register int i;
  2013.     
  2014.     if (!screen->Vshow) {
  2015.         set_vt_visibility (TRUE);
  2016.     } 
  2017.     update_vttekmode();
  2018.     update_vtshow();
  2019.     update_tekshow();
  2020.     set_vthide_sensitivity();
  2021.  
  2022.     if (screen->allbuf == NULL) VTallocbuf ();
  2023.  
  2024.     screen->cursor_state = OFF;
  2025.     screen->cursor_set = ON;
  2026.  
  2027.     bcnt = 0;
  2028.     bptr = buffer;
  2029.     while(Tpushb > Tpushback) {
  2030.         *bptr++ = *--Tpushb;
  2031.         bcnt++;
  2032.     }
  2033.     bcnt += (i = Tbcnt);
  2034.     for( ; i > 0 ; i--)
  2035.         *bptr++ = *Tbptr++;
  2036.     bptr = buffer;
  2037.     if(!setjmp(VTend))
  2038.         VTparse();
  2039.     HideCursor();
  2040.     screen->cursor_set = OFF;
  2041. }
  2042.  
  2043. /*ARGSUSED*/
  2044. static void VTExpose(w, event, region)
  2045.     Widget w;
  2046.     XEvent *event;
  2047.     Region region;
  2048. {
  2049.     register TScreen *screen = &term->screen;
  2050.  
  2051. #ifdef DEBUG
  2052.     if(debug)
  2053.         fputs("Expose\n", stderr);
  2054. #endif    /* DEBUG */
  2055.     if (event->type == Expose)
  2056.         HandleExposure (screen, event);
  2057. }
  2058.  
  2059. static void VTGraphicsOrNoExpose (event)
  2060.     XEvent *event;
  2061. {
  2062.     register TScreen *screen = &term->screen;
  2063.     if (screen->incopy <= 0) {
  2064.         screen->incopy = 1;
  2065.         if (screen->scrolls > 0)
  2066.             screen->scrolls--;
  2067.     }
  2068.     if (event->type == GraphicsExpose)
  2069.       if (HandleExposure (screen, event))
  2070.         screen->cursor_state = OFF;
  2071.     if ((event->type == NoExpose) || ((XGraphicsExposeEvent *)event)->count == 0) {
  2072.         if (screen->incopy <= 0 && screen->scrolls > 0)
  2073.             screen->scrolls--;
  2074.         if (screen->scrolls)
  2075.             screen->incopy = -1;
  2076.         else
  2077.             screen->incopy = 0;
  2078.     }
  2079. }
  2080.  
  2081. /*ARGSUSED*/
  2082. static void VTNonMaskableEvent (w, closure, event, cont)
  2083. Widget w;            /* unused */
  2084. XtPointer closure;        /* unused */
  2085. XEvent *event;
  2086. Boolean *cont;            /* unused */
  2087. {
  2088.     switch (event->type) {
  2089.        case GraphicsExpose:
  2090.        case NoExpose:
  2091.       VTGraphicsOrNoExpose (event);
  2092.       break;
  2093.       }
  2094. }
  2095.  
  2096.  
  2097.  
  2098.  
  2099. static void VTResize(w)
  2100.     Widget w;
  2101. {
  2102.     if (XtIsRealized(w))
  2103.       ScreenResize (&term->screen, term->core.width, term->core.height,
  2104.             &term->flags);
  2105. }
  2106.  
  2107.                 
  2108. extern Atom wm_delete_window;    /* for ICCCM delete window */
  2109.  
  2110. static String xterm_trans =
  2111.     "<ClientMessage>WM_PROTOCOLS: DeleteWindow()\n\
  2112.      <MappingNotify>: KeyboardMapping()\n";
  2113.  
  2114. int VTInit ()
  2115. {
  2116.     register TScreen *screen = &term->screen;
  2117.     Widget vtparent = term->core.parent;
  2118.  
  2119.     XtRealizeWidget (vtparent);
  2120.     XtOverrideTranslations(vtparent, XtParseTranslationTable(xterm_trans));
  2121.     (void) XSetWMProtocols (XtDisplay(vtparent), XtWindow(vtparent),
  2122.                 &wm_delete_window, 1);
  2123.  
  2124.     if (screen->allbuf == NULL) VTallocbuf ();
  2125.     return (1);
  2126. }
  2127.  
  2128. static void VTallocbuf ()
  2129. {
  2130.     register TScreen *screen = &term->screen;
  2131.     int nrows = screen->max_row + 1;
  2132.     extern ScrnBuf Allocate();
  2133.  
  2134.     /* allocate screen buffer now, if necessary. */
  2135.     if (screen->scrollWidget)
  2136.       nrows += screen->savelines;
  2137.     screen->allbuf = Allocate (nrows, screen->max_col + 1,
  2138.      &screen->sbuf_address);
  2139.     if (screen->scrollWidget)
  2140.       screen->buf = &screen->allbuf[2 * screen->savelines];
  2141.     else
  2142.       screen->buf = screen->allbuf;
  2143.     return;
  2144. }
  2145.  
  2146. static void VTClassInit ()
  2147. {
  2148.     XtAddConverter(XtRString, XtRGravity, XmuCvtStringToGravity,
  2149.            (XtConvertArgList) NULL, (Cardinal) 0);
  2150. }
  2151.  
  2152.  
  2153. /* ARGSUSED */
  2154. static void VTInitialize (wrequest, wnew, args, num_args)
  2155.    Widget wrequest, wnew;
  2156.    ArgList args;
  2157.    Cardinal *num_args;
  2158. {
  2159.    XtermWidget request = (XtermWidget) wrequest;
  2160.    XtermWidget new     = (XtermWidget) wnew;
  2161.    int i;
  2162.  
  2163.    /* Zero out the entire "screen" component of "new" widget,
  2164.       then do field-by-field assigment of "screen" fields
  2165.       that are named in the resource list. */
  2166.  
  2167.    bzero ((char *) &new->screen, sizeof(new->screen));
  2168.    new->screen.c132 = request->screen.c132;
  2169.    new->screen.curses = request->screen.curses;
  2170.    new->screen.foreground = request->screen.foreground;
  2171.    new->screen.cursorcolor = request->screen.cursorcolor;
  2172.    new->screen.border = request->screen.border;
  2173.    new->screen.jumpscroll = request->screen.jumpscroll;
  2174.    new->screen.logfile = request->screen.logfile;
  2175.    new->screen.marginbell = request->screen.marginbell;
  2176.    new->screen.mousecolor = request->screen.mousecolor;
  2177.    new->screen.mousecolorback = request->screen.mousecolorback;
  2178.    new->screen.multiscroll = request->screen.multiscroll;
  2179.    new->screen.nmarginbell = request->screen.nmarginbell;
  2180.    new->screen.savelines = request->screen.savelines;
  2181.    new->screen.scrolllines = request->screen.scrolllines;
  2182.    new->screen.scrollttyoutput = request->screen.scrollttyoutput;
  2183.    new->screen.scrollkey = request->screen.scrollkey;
  2184.    new->screen.visualbell = request->screen.visualbell;
  2185.    new->screen.TekEmu = request->screen.TekEmu;
  2186.    new->misc.re_verse = request->misc.re_verse;
  2187.    new->screen.multiClickTime = request->screen.multiClickTime;
  2188.    new->screen.bellSuppressTime = request->screen.bellSuppressTime;
  2189.    new->screen.charClass = request->screen.charClass;
  2190.    new->screen.cutNewline = request->screen.cutNewline;
  2191.    new->screen.cutToBeginningOfLine = request->screen.cutToBeginningOfLine;
  2192.    new->screen.always_highlight = request->screen.always_highlight;
  2193.    new->screen.pointer_cursor = request->screen.pointer_cursor;
  2194.    new->screen.input_eight_bits = request->screen.input_eight_bits;
  2195.    new->screen.output_eight_bits = request->screen.output_eight_bits;
  2196.    new->screen.allowSendEvents = request->screen.allowSendEvents;
  2197.    new->misc.titeInhibit = request->misc.titeInhibit;
  2198.    for (i = fontMenu_font1; i <= fontMenu_lastBuiltin; i++) {
  2199.        new->screen.menu_font_names[i] = request->screen.menu_font_names[i];
  2200.    }
  2201.    /* set default in realize proc */
  2202.    new->screen.menu_font_names[fontMenu_fontdefault] = NULL;
  2203.    new->screen.menu_font_names[fontMenu_fontescape] = NULL;
  2204.    new->screen.menu_font_names[fontMenu_fontsel] = NULL;
  2205.    new->screen.menu_font_number = fontMenu_fontdefault;
  2206.  
  2207.     /*
  2208.      * The definition of -rv now is that it changes the definition of 
  2209.      * XtDefaultForeground and XtDefaultBackground.  So, we no longer
  2210.      * need to do anything special.
  2211.      */
  2212.    new->keyboard.flags = 0;
  2213.    new->screen.display = new->core.screen->display;
  2214.    new->core.height = new->core.width = 1;
  2215.       /* dummy values so that we don't try to Realize the parent shell 
  2216.      with height or width of 0, which is illegal in X.  The real
  2217.      size is computed in the xtermWidget's Realize proc,
  2218.      but the shell's Realize proc is called first, and must see
  2219.      a valid size. */
  2220.  
  2221.    /* look for focus related events on the shell, because we need
  2222.     * to care about the shell's border being part of our focus.
  2223.     */
  2224.    XtAddEventHandler(XtParent(new), EnterWindowMask, FALSE,
  2225.         HandleEnterWindow, (Opaque)NULL);
  2226.    XtAddEventHandler(XtParent(new), LeaveWindowMask, FALSE,
  2227.         HandleLeaveWindow, (Opaque)NULL);
  2228.    XtAddEventHandler(XtParent(new), FocusChangeMask, FALSE,
  2229.         HandleFocusChange, (Opaque)NULL);
  2230.    XtAddEventHandler((Widget)new, 0L, TRUE,
  2231.         VTNonMaskableEvent, (Opaque)NULL);
  2232.    XtAddEventHandler((Widget)new, PropertyChangeMask, FALSE,
  2233.              HandleBellPropertyChange, (Opaque)NULL);
  2234.    new->screen.bellInProgress = FALSE;
  2235.  
  2236.    set_character_class (new->screen.charClass);
  2237.  
  2238.    /* create it, but don't realize it */
  2239.    ScrollBarOn (new, TRUE, FALSE);
  2240.  
  2241.    /* make sure that the resize gravity acceptable */
  2242.    if ( new->misc.resizeGravity != NorthWestGravity &&
  2243.         new->misc.resizeGravity != SouthWestGravity) {
  2244.        extern XtAppContext app_con;
  2245.        Cardinal nparams = 1;
  2246.  
  2247.        XtAppWarningMsg(app_con, "rangeError", "resizeGravity", "XTermError",
  2248.                "unsupported resizeGravity resource value (%d)",
  2249.                (String *) &(new->misc.resizeGravity), &nparams);
  2250.        new->misc.resizeGravity = SouthWestGravity;
  2251.    }
  2252.  
  2253.    return;
  2254. }
  2255.  
  2256.  
  2257. static void VTDestroy (w)
  2258. Widget w;
  2259. {
  2260.     XtFree(((XtermWidget)w)->screen.selection);
  2261. }
  2262.  
  2263. /*ARGSUSED*/
  2264. static void VTRealize (w, valuemask, values)
  2265.     Widget w;
  2266.     XtValueMask *valuemask;
  2267.     XSetWindowAttributes *values;
  2268. {
  2269.     unsigned int width, height;
  2270.     register TScreen *screen = &term->screen;
  2271.     int xpos, ypos, pr;
  2272.     XSizeHints        sizehints;
  2273.     int scrollbar_width;
  2274.  
  2275.     TabReset (term->tabs);
  2276.  
  2277.     screen->menu_font_names[fontMenu_fontdefault] = term->misc.f_n;
  2278.     screen->fnt_norm = screen->fnt_bold = NULL;
  2279.     if (!LoadNewFont(screen, term->misc.f_n, term->misc.f_b, False, 0)) {
  2280.         if (XmuCompareISOLatin1(term->misc.f_n, "fixed") != 0) {
  2281.         fprintf (stderr, 
  2282.              "%s:  unable to open font \"%s\", trying \"fixed\"....\n",
  2283.              xterm_name, term->misc.f_n);
  2284.         (void) LoadNewFont (screen, "fixed", NULL, False, 0);
  2285.         screen->menu_font_names[fontMenu_fontdefault] = "fixed";
  2286.         }
  2287.     }
  2288.  
  2289.     /* really screwed if we couldn't open default font */
  2290.     if (!screen->fnt_norm) {
  2291.         fprintf (stderr, "%s:  unable to locate a suitable font\n",
  2292.              xterm_name);
  2293.         Exit (1);
  2294.     }
  2295.  
  2296.     /* making cursor */
  2297.     if (!screen->pointer_cursor) 
  2298.       screen->pointer_cursor = make_colored_cursor(XC_xterm, 
  2299.                                screen->mousecolor,
  2300.                                screen->mousecolorback);
  2301.     else 
  2302.       recolor_cursor (screen->pointer_cursor, 
  2303.               screen->mousecolor, screen->mousecolorback);
  2304.  
  2305.     scrollbar_width = (term->misc.scrollbar ?
  2306.                screen->scrollWidget->core.width /* +
  2307.                screen->scrollWidget->core.border_width */ : 0);
  2308.  
  2309.     /* set defaults */
  2310.     xpos = 1; ypos = 1; width = 80; height = 24;
  2311.     pr = XParseGeometry (term->misc.geo_metry, &xpos, &ypos,
  2312.                  &width, &height);
  2313.     screen->max_col = (width - 1);    /* units in character cells */
  2314.     screen->max_row = (height - 1);    /* units in character cells */
  2315.     update_font_info (&term->screen, False);
  2316.  
  2317.     width = screen->fullVwin.fullwidth;
  2318.     height = screen->fullVwin.fullheight;
  2319.  
  2320.     if ((pr & XValue) && (XNegative&pr)) 
  2321.       xpos += DisplayWidth(screen->display, DefaultScreen(screen->display))
  2322.             - width - (term->core.parent->core.border_width * 2);
  2323.     if ((pr & YValue) && (YNegative&pr))
  2324.       ypos += DisplayHeight(screen->display,DefaultScreen(screen->display))
  2325.             - height - (term->core.parent->core.border_width * 2);
  2326.  
  2327.     /* set up size hints for window manager; min 1 char by 1 char */
  2328.     sizehints.base_width = 2 * screen->border + scrollbar_width;
  2329.     sizehints.base_height = 2 * screen->border;
  2330.     sizehints.width_inc = FontWidth(screen);
  2331.     sizehints.height_inc = FontHeight(screen);
  2332.     sizehints.min_width = sizehints.base_width + sizehints.width_inc;
  2333.     sizehints.min_height = sizehints.base_height + sizehints.height_inc;
  2334.     sizehints.flags = (PBaseSize|PMinSize|PResizeInc);
  2335.     sizehints.x = xpos;
  2336.     sizehints.y = ypos;
  2337.     if ((XValue&pr) || (YValue&pr)) {
  2338.         sizehints.flags |= USSize|USPosition;
  2339.         sizehints.flags |= PWinGravity;
  2340.         switch (pr & (XNegative | YNegative)) {
  2341.           case 0:
  2342.         sizehints.win_gravity = NorthWestGravity;
  2343.         break;
  2344.           case XNegative:
  2345.         sizehints.win_gravity = NorthEastGravity;
  2346.         break;
  2347.           case YNegative:
  2348.         sizehints.win_gravity = SouthWestGravity;
  2349.         break;
  2350.           default:
  2351.         sizehints.win_gravity = SouthEastGravity;
  2352.         break;
  2353.         }
  2354.     } else {
  2355.         /* set a default size, but do *not* set position */
  2356.         sizehints.flags |= PSize;
  2357.     }
  2358.     sizehints.width = width;
  2359.     sizehints.height = height;
  2360.     if ((WidthValue&pr) || (HeightValue&pr)) 
  2361.       sizehints.flags |= USSize;
  2362.     else sizehints.flags |= PSize;
  2363.  
  2364.     (void) XtMakeResizeRequest((Widget) term,
  2365.                    (Dimension)width, (Dimension)height,
  2366.                    &term->core.width, &term->core.height);
  2367.  
  2368.     /* XXX This is bogus.  We are parsing geometries too late.  This
  2369.      * is information that the shell widget ought to have before we get
  2370.      * realized, so that it can do the right thing.
  2371.      */
  2372.         if (sizehints.flags & USPosition)
  2373.         XMoveWindow (XtDisplay(term), term->core.parent->core.window,
  2374.              sizehints.x, sizehints.y);
  2375.  
  2376.     XSetWMNormalHints (XtDisplay(term), term->core.parent->core.window,
  2377.                &sizehints);
  2378.     XFlush (XtDisplay(term));    /* get it out to window manager */
  2379.  
  2380.     /* use ForgetGravity instead of SouthWestGravity because translating
  2381.        the Expose events for ConfigureNotifys is too hard */
  2382.     values->bit_gravity = term->misc.resizeGravity == NorthWestGravity ?
  2383.         NorthWestGravity : ForgetGravity;
  2384.     term->screen.fullVwin.window = term->core.window =
  2385.       XCreateWindow(XtDisplay(term), XtWindow(term->core.parent),
  2386.         term->core.x, term->core.y,
  2387.         term->core.width, term->core.height, term->core.border_width,
  2388.         (int) term->core.depth,
  2389.         InputOutput, CopyFromParent,    
  2390.         *valuemask|CWBitGravity, values);
  2391.  
  2392.     set_cursor_gcs (screen);
  2393.  
  2394.     /* Reset variables used by ANSI emulation. */
  2395.  
  2396.     screen->gsets[0] = 'B';            /* ASCII_G        */
  2397.     screen->gsets[1] = 'B';
  2398.     screen->gsets[2] = 'B';            /* DEC supplemental.    */
  2399.     screen->gsets[3] = 'B';
  2400.     screen->curgl = 0;            /* G0 => GL.        */
  2401.     screen->curgr = 2;            /* G2 => GR.        */
  2402.     screen->curss = 0;            /* No single shift.    */
  2403.  
  2404.     XDefineCursor(screen->display, VShellWindow, screen->pointer_cursor);
  2405.  
  2406.         screen->cur_col = screen->cur_row = 0;
  2407.     screen->max_col = Width(screen)/screen->fullVwin.f_width - 1;
  2408.     screen->top_marg = 0;
  2409.     screen->bot_marg = screen->max_row = Height(screen) /
  2410.                 screen->fullVwin.f_height - 1;
  2411.  
  2412.     screen->sc.row = screen->sc.col = screen->sc.flags = 0;
  2413.  
  2414.     /* Mark screen buffer as unallocated.  We wait until the run loop so
  2415.        that the child process does not fork and exec with all the dynamic
  2416.        memory it will never use.  If we were to do it here, the
  2417.        swap space for new process would be huge for huge savelines. */
  2418.     if (!tekWidget)            /* if not called after fork */
  2419.       screen->buf = screen->allbuf = NULL;
  2420.  
  2421.     screen->do_wrap = 0;
  2422.     screen->scrolls = screen->incopy = 0;
  2423.     set_vt_box (screen);
  2424.  
  2425.     screen->savedlines = 0;
  2426.  
  2427.     if (term->misc.scrollbar) {
  2428.         screen->scrollbar = 0;
  2429.         ScrollBarOn (term, FALSE, TRUE);
  2430.     }
  2431.     CursorSave (term, &screen->sc);
  2432.     return;
  2433. }
  2434.  
  2435. static Boolean VTSetValues (cur, request, new, args, num_args)
  2436.     Widget cur, request, new;
  2437.     ArgList args;
  2438.     Cardinal *num_args;
  2439. {
  2440.     XtermWidget curvt = (XtermWidget) cur;
  2441.     XtermWidget newvt = (XtermWidget) new; 
  2442.     Boolean refresh_needed = FALSE;
  2443.     Boolean fonts_redone = FALSE;
  2444.  
  2445.     if(curvt->core.background_pixel != newvt->core.background_pixel
  2446.        || curvt->screen.foreground != newvt->screen.foreground
  2447.        || curvt->screen.menu_font_names[curvt->screen.menu_font_number]
  2448.           != newvt->screen.menu_font_names[newvt->screen.menu_font_number]
  2449.        || curvt->misc.f_n != newvt->misc.f_n) {
  2450.     if(curvt->misc.f_n != newvt->misc.f_n)
  2451.         newvt->screen.menu_font_names[fontMenu_fontdefault] = newvt->misc.f_n;
  2452.     if (LoadNewFont(&newvt->screen,
  2453.             newvt->screen.menu_font_names[curvt->screen.menu_font_number],
  2454.             newvt->screen.menu_font_names[curvt->screen.menu_font_number],
  2455.             TRUE, newvt->screen.menu_font_number)) {
  2456.         /* resizing does the redisplay, so don't ask for it here */
  2457.         refresh_needed = TRUE;
  2458.         fonts_redone = TRUE;
  2459.     } else
  2460.         if(curvt->misc.f_n != newvt->misc.f_n)
  2461.         newvt->screen.menu_font_names[fontMenu_fontdefault] = curvt->misc.f_n;
  2462.     }
  2463.     if(!fonts_redone
  2464.        && curvt->screen.cursorcolor != newvt->screen.cursorcolor) {
  2465.     set_cursor_gcs(&newvt->screen);
  2466.     refresh_needed = TRUE;
  2467.     }
  2468.     if(curvt->misc.re_verse != newvt->misc.re_verse) {
  2469.     newvt->flags ^= REVERSE_VIDEO;
  2470.     ReverseVideo(newvt);
  2471.     newvt->misc.re_verse = !newvt->misc.re_verse; /* ReverseVideo toggles */
  2472.     refresh_needed = TRUE;
  2473.     }
  2474.     if(curvt->screen.mousecolor != newvt->screen.mousecolor
  2475.        || curvt->screen.mousecolorback != newvt->screen.mousecolorback) {
  2476.     recolor_cursor (newvt->screen.pointer_cursor, 
  2477.             newvt->screen.mousecolor,
  2478.             newvt->screen.mousecolorback);
  2479.     refresh_needed = TRUE;
  2480.     }
  2481.     if (curvt->misc.scrollbar != newvt->misc.scrollbar) {
  2482.     if (newvt->misc.scrollbar) {
  2483.         ScrollBarOn (newvt, FALSE, FALSE);
  2484.     } else {
  2485.         ScrollBarOff (&newvt->screen);
  2486.     }
  2487.     update_scrollbar();
  2488.     }
  2489.  
  2490.     return refresh_needed;
  2491. }
  2492.  
  2493. /*
  2494.  * Shows cursor at new cursor position in screen.
  2495.  */
  2496. ShowCursor()
  2497. {
  2498.     register TScreen *screen = &term->screen;
  2499.     register int x, y, flags;
  2500.     Char c;
  2501.     GC    currentGC;
  2502.     Boolean    in_selection;
  2503.  
  2504.     if (eventMode != NORMAL) return;
  2505.  
  2506.     if (screen->cur_row - screen->topline > screen->max_row)
  2507.         return;
  2508.     c = screen->buf[y = 2 * (screen->cursor_row = screen->cur_row)]
  2509.      [x = screen->cursor_col = screen->cur_col];
  2510.     flags = screen->buf[y + 1][x];
  2511.     if (c == 0)
  2512.         c = ' ';
  2513.  
  2514.     if (screen->cur_row > screen->endHRow ||
  2515.         (screen->cur_row == screen->endHRow &&
  2516.          screen->cur_col >= screen->endHCol) ||
  2517.         screen->cur_row < screen->startHRow ||
  2518.         (screen->cur_row == screen->startHRow &&
  2519.          screen->cur_col < screen->startHCol))
  2520.         in_selection = False;
  2521.     else
  2522.         in_selection = True;
  2523.  
  2524.     if(screen->select || screen->always_highlight) {
  2525.         if (( (flags & INVERSE) && !in_selection) ||
  2526.             (!(flags & INVERSE) &&  in_selection)){
  2527.             /* text is reverse video */
  2528.             if (screen->cursorGC) {
  2529.             currentGC = screen->cursorGC;
  2530.             } else {
  2531.             if (flags & BOLD) {
  2532.                 currentGC = screen->normalboldGC;
  2533.             } else {
  2534.                 currentGC = screen->normalGC;
  2535.             }
  2536.             }
  2537.         } else { /* normal video */
  2538.             if (screen->reversecursorGC) {
  2539.             currentGC = screen->reversecursorGC;
  2540.             } else {
  2541.             if (flags & BOLD) {
  2542.                 currentGC = screen->reverseboldGC;
  2543.             } else {
  2544.                 currentGC = screen->reverseGC;
  2545.             }
  2546.             }
  2547.         }
  2548.     } else { /* not selected */
  2549.         if (( (flags & INVERSE) && !in_selection) ||
  2550.             (!(flags & INVERSE) &&  in_selection)) {
  2551.             /* text is reverse video */
  2552.             currentGC = screen->reverseGC;
  2553.         } else { /* normal video */
  2554.             currentGC = screen->normalGC;
  2555.         }
  2556.         
  2557.     }
  2558.  
  2559.     x = CursorX (screen, screen->cur_col);
  2560.     y = CursorY(screen, screen->cur_row) + 
  2561.       screen->fnt_norm->ascent;
  2562.     XDrawImageString(screen->display, TextWindow(screen), currentGC,
  2563.         x, y, (char *) &c, 1);
  2564.  
  2565.     if((flags & BOLD) && screen->enbolden) /* no bold font */
  2566.         XDrawString(screen->display, TextWindow(screen), currentGC,
  2567.             x + 1, y, (char *) &c, 1);
  2568.     if(flags & UNDERLINE) 
  2569.         XDrawLine(screen->display, TextWindow(screen), currentGC,
  2570.             x, y+1, x + FontWidth(screen), y+1);
  2571.     if (!screen->select && !screen->always_highlight) {
  2572.         screen->box->x = x;
  2573.         screen->box->y = y - screen->fnt_norm->ascent;
  2574.         XDrawLines (screen->display, TextWindow(screen), 
  2575.                 screen->cursoroutlineGC ? screen->cursoroutlineGC 
  2576.                                 : currentGC,
  2577.                 screen->box, NBOX, CoordModePrevious);
  2578.     }
  2579.     screen->cursor_state = ON;
  2580. }
  2581.  
  2582. /*
  2583.  * hide cursor at previous cursor position in screen.
  2584.  */
  2585. HideCursor()
  2586. {
  2587.     register TScreen *screen = &term->screen;
  2588.     GC    currentGC;
  2589.     register int x, y, flags;
  2590.     char c;
  2591.     Boolean    in_selection;
  2592.  
  2593.     if(screen->cursor_row - screen->topline > screen->max_row)
  2594.         return;
  2595.     c = screen->buf[y = 2 * screen->cursor_row][x = screen->cursor_col];
  2596.     flags = screen->buf[y + 1][x];
  2597.  
  2598.     if (screen->cursor_row > screen->endHRow ||
  2599.         (screen->cursor_row == screen->endHRow &&
  2600.          screen->cursor_col >= screen->endHCol) ||
  2601.         screen->cursor_row < screen->startHRow ||
  2602.         (screen->cursor_row == screen->startHRow &&
  2603.          screen->cursor_col < screen->startHCol))
  2604.         in_selection = False;
  2605.     else
  2606.         in_selection = True;
  2607.  
  2608.     if (( (flags & INVERSE) && !in_selection) ||
  2609.         (!(flags & INVERSE) &&  in_selection)) {
  2610.         if(flags & BOLD) {
  2611.             currentGC = screen->reverseboldGC;
  2612.         } else {
  2613.             currentGC = screen->reverseGC;
  2614.         }
  2615.     } else {
  2616.         if(flags & BOLD) {
  2617.             currentGC = screen->normalboldGC;
  2618.         } else {
  2619.             currentGC = screen->normalGC;
  2620.         }
  2621.     }
  2622.  
  2623.     if (c == 0)
  2624.         c = ' ';
  2625.     x = CursorX (screen, screen->cursor_col);
  2626.     y = (((screen->cursor_row - screen->topline) * FontHeight(screen))) +
  2627.      screen->border;
  2628.     y = y+screen->fnt_norm->ascent;
  2629.     XDrawImageString(screen->display, TextWindow(screen), currentGC,
  2630.         x, y, &c, 1);
  2631.     if((flags & BOLD) && screen->enbolden)
  2632.         XDrawString(screen->display, TextWindow(screen), currentGC,
  2633.             x + 1, y, &c, 1);
  2634.     if(flags & UNDERLINE) 
  2635.         XDrawLine(screen->display, TextWindow(screen), currentGC,
  2636.             x, y+1, x + FontWidth(screen), y+1);
  2637.     screen->cursor_state = OFF;
  2638. }
  2639.  
  2640. VTReset(full)
  2641.     Boolean full;
  2642. {
  2643.     register TScreen *screen = &term->screen;
  2644.  
  2645.     /* reset scrolling region */
  2646.     screen->top_marg = 0;
  2647.     screen->bot_marg = screen->max_row;
  2648.     term->flags &= ~ORIGIN;
  2649.     if(full) {
  2650.         TabReset (term->tabs);
  2651.         term->keyboard.flags = 0;
  2652.         update_appcursor();
  2653.         update_appkeypad();
  2654.         screen->gsets[0] = 'B';
  2655.         screen->gsets[1] = 'B';
  2656.         screen->gsets[2] = 'B';
  2657.         screen->gsets[3] = 'B';
  2658.         screen->curgl = 0;
  2659.         screen->curgr = 2;
  2660.         screen->curss = 0;
  2661.         FromAlternate(screen);
  2662.         ClearScreen(screen);
  2663.         screen->cursor_state = OFF;
  2664.         if (term->flags & REVERSE_VIDEO)
  2665.             ReverseVideo(term);
  2666.  
  2667.         term->flags = term->initflags;
  2668.         update_reversevideo();
  2669.         update_autowrap();
  2670.         update_reversewrap();
  2671.         update_autolinefeed();
  2672.         screen->jumpscroll = !(term->flags & SMOOTHSCROLL);
  2673.         update_jumpscroll();
  2674.         if(screen->c132 && (term->flags & IN132COLUMNS)) {
  2675.                 Dimension junk;
  2676.             XtMakeResizeRequest(
  2677.                 (Widget) term,
  2678.                 (Dimension) 80*FontWidth(screen)
  2679.                 + 2 * screen->border + screen->scrollbar,
  2680.                 (Dimension) FontHeight(screen)
  2681.                     * (screen->max_row + 1) + 2 * screen->border,
  2682.                 &junk, &junk);
  2683.             XSync(screen->display, FALSE);    /* synchronize */
  2684.             if(QLength(screen->display) > 0)
  2685.                 xevents();
  2686.         }
  2687.         CursorSet(screen, 0, 0, term->flags);
  2688.     }
  2689.     longjmp(vtjmpbuf, 1);    /* force ground state in parser */
  2690. }
  2691.  
  2692.  
  2693.  
  2694. /*
  2695.  * set_character_class - takes a string of the form
  2696.  * 
  2697.  *                 low[-high]:val[,low[-high]:val[...]]
  2698.  * 
  2699.  * and sets the indicated ranges to the indicated values.
  2700.  */
  2701.  
  2702. int set_character_class (s)
  2703.     register char *s;
  2704. {
  2705.     register int i;            /* iterator, index into s */
  2706.     int len;                /* length of s */
  2707.     int acc;                /* accumulator */
  2708.     int low, high;            /* bounds of range [0..127] */
  2709.     int base;                /* 8, 10, 16 (octal, decimal, hex) */
  2710.     int numbers;            /* count of numbers per range */
  2711.     int digits;                /* count of digits in a number */
  2712.     static char *errfmt = "%s:  %s in range string \"%s\" (position %d)\n";
  2713.     extern char *ProgramName;
  2714.  
  2715.     if (!s || !s[0]) return -1;
  2716.  
  2717.     base = 10;                /* in case we ever add octal, hex */
  2718.     low = high = -1;            /* out of range */
  2719.  
  2720.     for (i = 0, len = strlen (s), acc = 0, numbers = digits = 0;
  2721.      i < len; i++) {
  2722.     char c = s[i];
  2723.  
  2724.     if (isspace(c)) {
  2725.         continue;
  2726.     } else if (isdigit(c)) {
  2727.         acc = acc * base + (c - '0');
  2728.         digits++;
  2729.         continue;
  2730.     } else if (c == '-') {
  2731.         low = acc;
  2732.         acc = 0;
  2733.         if (digits == 0) {
  2734.         fprintf (stderr, errfmt, ProgramName, "missing number", s, i);
  2735.         return (-1);
  2736.         }
  2737.         digits = 0;
  2738.         numbers++;
  2739.         continue;
  2740.     } else if (c == ':') {
  2741.         if (numbers == 0)
  2742.           low = acc;
  2743.         else if (numbers == 1)
  2744.           high = acc;
  2745.         else {
  2746.         fprintf (stderr, errfmt, ProgramName, "too many numbers",
  2747.              s, i);
  2748.         return (-1);
  2749.         }
  2750.         digits = 0;
  2751.         numbers++;
  2752.         acc = 0;
  2753.         continue;
  2754.     } else if (c == ',') {
  2755.         /*
  2756.          * now, process it
  2757.          */
  2758.  
  2759.         if (high < 0) {
  2760.         high = low;
  2761.         numbers++;
  2762.         }
  2763.         if (numbers != 2) {
  2764.         fprintf (stderr, errfmt, ProgramName, "bad value number", 
  2765.              s, i);
  2766.         } else if (SetCharacterClassRange (low, high, acc) != 0) {
  2767.         fprintf (stderr, errfmt, ProgramName, "bad range", s, i);
  2768.         }
  2769.  
  2770.         low = high = -1;
  2771.         acc = 0;
  2772.         digits = 0;
  2773.         numbers = 0;
  2774.         continue;
  2775.     } else {
  2776.         fprintf (stderr, errfmt, ProgramName, "bad character", s, i);
  2777.         return (-1);
  2778.     }                /* end if else if ... else */
  2779.  
  2780.     }
  2781.  
  2782.     if (low < 0 && high < 0) return (0);
  2783.  
  2784.     /*
  2785.      * now, process it
  2786.      */
  2787.  
  2788.     if (high < 0) high = low;
  2789.     if (numbers < 1 || numbers > 2) {
  2790.     fprintf (stderr, errfmt, ProgramName, "bad value number", s, i);
  2791.     } else if (SetCharacterClassRange (low, high, acc) != 0) {
  2792.     fprintf (stderr, errfmt, ProgramName, "bad range", s, i);
  2793.     }
  2794.  
  2795.     return (0);
  2796. }
  2797.  
  2798. /* ARGSUSED */
  2799. static void HandleKeymapChange(w, event, params, param_count)
  2800.     Widget w;
  2801.     XEvent *event;
  2802.     String *params;
  2803.     Cardinal *param_count;
  2804. {
  2805.     static XtTranslations keymap, original;
  2806.     static XtResource key_resources[] = {
  2807.     { XtNtranslations, XtCTranslations, XtRTranslationTable,
  2808.           sizeof(XtTranslations), 0, XtRTranslationTable, (caddr_t)NULL}
  2809.     };
  2810.     char mapName[1000];
  2811.     char mapClass[1000];
  2812.  
  2813.     if (*param_count != 1) return;
  2814.  
  2815.     if (original == NULL) original = w->core.tm.translations;
  2816.  
  2817.     if (strcmp(params[0], "None") == 0) {
  2818.     XtOverrideTranslations(w, original);
  2819.     return;
  2820.     }
  2821.     (void) sprintf( mapName, "%sKeymap", params[0] );
  2822.     (void) strcpy( mapClass, mapName );
  2823.     if (islower(mapClass[0])) mapClass[0] = toupper(mapClass[0]);
  2824.     XtGetSubresources( w, (XtPointer)&keymap, mapName, mapClass,
  2825.                key_resources, (Cardinal)1, NULL, (Cardinal)0 );
  2826.     if (keymap != NULL)
  2827.     XtOverrideTranslations(w, keymap);
  2828. }
  2829.  
  2830.  
  2831. /* ARGSUSED */
  2832. static void HandleBell(w, event, params, param_count)
  2833.     Widget w;
  2834.     XEvent *event;        /* unused */
  2835.     String *params;        /* [0] = volume */
  2836.     Cardinal *param_count;    /* 0 or 1 */
  2837. {
  2838.     int percent = (*param_count) ? atoi(params[0]) : 0;
  2839.  
  2840.     XBell( XtDisplay(w), percent );
  2841. }
  2842.  
  2843.  
  2844. /* ARGSUSED */
  2845. static void HandleVisualBell(w, event, params, param_count)
  2846.     Widget w;
  2847.     XEvent *event;        /* unused */
  2848.     String *params;        /* unused */
  2849.     Cardinal *param_count;    /* unused */
  2850. {
  2851.     VisualBell();
  2852. }
  2853.  
  2854.  
  2855. /* ARGSUSED */
  2856. static void HandleIgnore(w, event, params, param_count)
  2857.     Widget w;
  2858.     XEvent *event;        /* unused */
  2859.     String *params;        /* unused */
  2860.     Cardinal *param_count;    /* unused */
  2861. {
  2862.     /* do nothing, but check for funny escape sequences */
  2863.     (void) SendMousePosition(w, event);
  2864. }
  2865.  
  2866.  
  2867. /* ARGSUSED */
  2868. static void
  2869. DoSetSelectedFont(w, client_data, selection, type, value, length, format)
  2870.     Widget w;
  2871.     XtPointer client_data;
  2872.     Atom *selection, *type;
  2873.     XtPointer value;
  2874.     unsigned long *length;
  2875.     int *format;
  2876. {
  2877.     char *val = (char *)value;
  2878.     int len;
  2879.     if (*type != XA_STRING  ||  *format != 8) {
  2880.     Bell();
  2881.     return;
  2882.     }
  2883.     len = strlen(val);
  2884.     if (len > 0) {
  2885.     if (val[len-1] == '\n') val[len-1] = '\0';
  2886.     /* Do some sanity checking to avoid sending a long selection
  2887.        back to the server in an OpenFont that is unlikely to succeed.
  2888.        XLFD allows up to 255 characters and no control characters;
  2889.        we are a little more liberal here. */
  2890.     if (len > 1000  ||  strchr(val, '\n'))
  2891.         return;
  2892.     if (!LoadNewFont (&term->screen, val, NULL, True, fontMenu_fontsel))
  2893.         Bell();
  2894.     }
  2895. }
  2896.  
  2897. void FindFontSelection (atom_name, justprobe)
  2898.     char *atom_name;
  2899.     Bool justprobe;
  2900. {
  2901.     static AtomPtr *atoms;
  2902.     static int atomCount = 0;
  2903.     AtomPtr *pAtom;
  2904.     int a;
  2905.     Atom target;
  2906.  
  2907.     if (!atom_name) atom_name = "PRIMARY";
  2908.  
  2909.     for (pAtom = atoms, a = atomCount; a; a--, pAtom++) {
  2910.     if (strcmp(atom_name, XmuNameOfAtom(*pAtom)) == 0) break;
  2911.     }
  2912.     if (!a) {
  2913.     atoms = (AtomPtr*) XtRealloc ((char *)atoms,
  2914.                       sizeof(AtomPtr)*(atomCount+1));
  2915.     *(pAtom = &atoms[atomCount++]) = XmuMakeAtom(atom_name);
  2916.     }
  2917.  
  2918.     target = XmuInternAtom(XtDisplay(term), *pAtom);
  2919.     if (justprobe) {
  2920.     term->screen.menu_font_names[fontMenu_fontsel] = 
  2921.       XGetSelectionOwner(XtDisplay(term), target) ? _Font_Selected_ : NULL;
  2922.     } else {
  2923.     XtGetSelectionValue((Widget)term, target, XA_STRING,
  2924.                 DoSetSelectedFont, NULL,
  2925.                 XtLastTimestampProcessed(XtDisplay(term)));
  2926.     }
  2927.     return;
  2928. }
  2929.  
  2930.  
  2931. /* ARGSUSED */
  2932. void HandleSetFont(w, event, params, param_count)
  2933.     Widget w;
  2934.     XEvent *event;        /* unused */
  2935.     String *params;        /* unused */
  2936.     Cardinal *param_count;    /* unused */
  2937. {
  2938.     int fontnum;
  2939.     char *name1 = NULL, *name2 = NULL;
  2940.  
  2941.     if (*param_count == 0) {
  2942.     fontnum = fontMenu_fontdefault;
  2943.     } else {
  2944.     int maxparams = 1;        /* total number of params allowed */
  2945.  
  2946.     switch (params[0][0]) {
  2947.       case 'd': case 'D': case '0':
  2948.         fontnum = fontMenu_fontdefault; break;
  2949.       case '1':
  2950.         fontnum = fontMenu_font1; break;
  2951.       case '2':
  2952.         fontnum = fontMenu_font2; break;
  2953.       case '3':
  2954.         fontnum = fontMenu_font3; break;
  2955.       case '4':
  2956.         fontnum = fontMenu_font4; break;
  2957.       case '5':
  2958.         fontnum = fontMenu_font5; break;
  2959.       case '6':
  2960.         fontnum = fontMenu_font6; break;
  2961.       case 'e': case 'E':
  2962.         fontnum = fontMenu_fontescape; maxparams = 3; break;
  2963.       case 's': case 'S':
  2964.         fontnum = fontMenu_fontsel; maxparams = 2; break;
  2965.       default:
  2966.         Bell();
  2967.         return;
  2968.     }
  2969.     if (*param_count > maxparams) {     /* see if extra args given */
  2970.         Bell();
  2971.         return;
  2972.     }
  2973.     switch (*param_count) {        /* assign 'em */
  2974.       case 3:
  2975.         name2 = params[2];
  2976.         /* fall through */
  2977.       case 2:
  2978.         name1 = params[1];
  2979.         break;
  2980.     }
  2981.     }
  2982.  
  2983.     SetVTFont (fontnum, True, name1, name2);
  2984. }
  2985.  
  2986.  
  2987. void SetVTFont (i, doresize, name1, name2)
  2988.     int i;
  2989.     Bool doresize;
  2990.     char *name1, *name2;
  2991. {
  2992.     TScreen *screen = &term->screen;
  2993.  
  2994.     if (i < 0 || i >= NMENUFONTS) {
  2995.     Bell();
  2996.     return;
  2997.     }
  2998.     if (i == fontMenu_fontsel) {    /* go get the selection */
  2999.     FindFontSelection (name1, False);  /* name1 = atom, name2 is ignored */
  3000.     return;
  3001.     }
  3002.     if (!name1) name1 = screen->menu_font_names[i];
  3003.     if (!LoadNewFont(screen, name1, name2, doresize, i)) {
  3004.     Bell();
  3005.     }
  3006.     return;
  3007. }
  3008.  
  3009.  
  3010. int LoadNewFont (screen, nfontname, bfontname, doresize, fontnum)
  3011.     TScreen *screen;
  3012.     char *nfontname, *bfontname;
  3013.     Bool doresize;
  3014.     int fontnum;
  3015. {
  3016.     XFontStruct *nfs = NULL, *bfs = NULL;
  3017.     XGCValues xgcv;
  3018.     unsigned long mask;
  3019.     GC new_normalGC = NULL, new_normalboldGC = NULL;
  3020.     GC new_reverseGC = NULL, new_reverseboldGC = NULL;
  3021.     char *tmpname = NULL;
  3022.  
  3023.     if (!nfontname) return 0;
  3024.  
  3025.     if (fontnum == fontMenu_fontescape &&
  3026.     nfontname != screen->menu_font_names[fontnum]) {
  3027.     tmpname = (char *) malloc (strlen(nfontname) + 1);
  3028.     if (!tmpname) return 0;
  3029.     strcpy (tmpname, nfontname);
  3030.     }
  3031.  
  3032.     if (!(nfs = XLoadQueryFont (screen->display, nfontname))) goto bad;
  3033.  
  3034.     if (!(bfontname && 
  3035.       (bfs = XLoadQueryFont (screen->display, bfontname))))
  3036.       bfs = nfs;
  3037.  
  3038.     mask = (GCFont | GCForeground | GCBackground | GCGraphicsExposures |
  3039.         GCFunction);
  3040.  
  3041.     xgcv.font = nfs->fid;
  3042.     xgcv.foreground = screen->foreground;
  3043.     xgcv.background = term->core.background_pixel;
  3044.     xgcv.graphics_exposures = TRUE;    /* default */
  3045.     xgcv.function = GXcopy;
  3046.  
  3047.     new_normalGC = XtGetGC((Widget)term, mask, &xgcv);
  3048.     if (!new_normalGC) goto bad;
  3049.  
  3050.     if (nfs == bfs) {            /* there is no bold font */
  3051.     new_normalboldGC = new_normalGC;
  3052.     } else {
  3053.     xgcv.font = bfs->fid;
  3054.     new_normalboldGC = XtGetGC((Widget)term, mask, &xgcv);
  3055.     if (!new_normalboldGC) goto bad;
  3056.     }
  3057.  
  3058.     xgcv.font = nfs->fid;
  3059.     xgcv.foreground = term->core.background_pixel;
  3060.     xgcv.background = screen->foreground;
  3061.     new_reverseGC = XtGetGC((Widget)term, mask, &xgcv);
  3062.     if (!new_reverseGC) goto bad;
  3063.  
  3064.     if (nfs == bfs) {            /* there is no bold font */
  3065.     new_reverseboldGC = new_reverseGC;
  3066.     } else {
  3067.     xgcv.font = bfs->fid;
  3068.     new_reverseboldGC = XtGetGC((Widget)term, mask, &xgcv);
  3069.     if (!new_reverseboldGC) goto bad;
  3070.     }
  3071.  
  3072.     if (screen->normalGC != screen->normalboldGC)
  3073.     XtReleaseGC ((Widget) term, screen->normalboldGC);
  3074.     XtReleaseGC ((Widget) term, screen->normalGC);
  3075.     if (screen->reverseGC != screen->reverseboldGC)
  3076.     XtReleaseGC ((Widget) term, screen->reverseboldGC);
  3077.     XtReleaseGC ((Widget) term, screen->reverseGC);
  3078.     screen->normalGC = new_normalGC;
  3079.     screen->normalboldGC = new_normalboldGC;
  3080.     screen->reverseGC = new_reverseGC;
  3081.     screen->reverseboldGC = new_reverseboldGC;
  3082.     screen->fnt_norm = nfs;
  3083.     screen->fnt_bold = bfs;
  3084.     screen->enbolden = (nfs == bfs);
  3085.     set_menu_font (False);
  3086.     screen->menu_font_number = fontnum;
  3087.     set_menu_font (True);
  3088.     if (tmpname) {            /* if setting escape or sel */
  3089.     if (screen->menu_font_names[fontnum])
  3090.       free (screen->menu_font_names[fontnum]);
  3091.     screen->menu_font_names[fontnum] = tmpname;
  3092.     if (fontnum == fontMenu_fontescape) {
  3093.         set_sensitivity (term->screen.fontMenu,
  3094.                  fontMenuEntries[fontMenu_fontescape].widget,
  3095.                  TRUE);
  3096.     }
  3097.     }
  3098.     set_cursor_gcs (screen);
  3099.     update_font_info (screen, doresize);
  3100.     return 1;
  3101.  
  3102.   bad:
  3103.     if (tmpname) free (tmpname);
  3104.     if (new_normalGC)
  3105.       XtReleaseGC ((Widget) term, screen->normalGC);
  3106.     if (new_normalGC && new_normalGC != new_normalboldGC)
  3107.       XtReleaseGC ((Widget) term, new_normalboldGC);
  3108.     if (new_reverseGC)
  3109.       XtReleaseGC ((Widget) term, new_reverseGC);
  3110.     if (new_reverseGC && new_reverseGC != new_reverseboldGC)
  3111.       XtReleaseGC ((Widget) term, new_reverseboldGC);
  3112.     if (nfs) XFreeFont (screen->display, nfs);
  3113.     if (nfs && nfs != bfs) XFreeFont (screen->display, bfs);
  3114.     return 0;
  3115. }
  3116.  
  3117.  
  3118. update_font_info (screen, doresize)
  3119.     TScreen *screen;
  3120.     Bool doresize;
  3121. {
  3122.     int i, j, width, height, scrollbar_width;
  3123.  
  3124.     screen->fullVwin.f_width = screen->fnt_norm->max_bounds.width;
  3125.     screen->fullVwin.f_height = (screen->fnt_norm->ascent +
  3126.                  screen->fnt_norm->descent);
  3127.     scrollbar_width = (term->misc.scrollbar ? 
  3128.                screen->scrollWidget->core.width +
  3129.                screen->scrollWidget->core.border_width : 0);
  3130.     i = 2 * screen->border + scrollbar_width;
  3131.     j = 2 * screen->border;
  3132.     width = (screen->max_col + 1) * screen->fullVwin.f_width + i;
  3133.     height = (screen->max_row + 1) * screen->fullVwin.f_height + j;
  3134.     screen->fullVwin.fullwidth = width;
  3135.     screen->fullVwin.fullheight = height;
  3136.     screen->fullVwin.width = width - i;
  3137.     screen->fullVwin.height = height - j;
  3138.  
  3139.     if (doresize) {
  3140.     if (VWindow(screen)) {
  3141.         XClearWindow (screen->display, VWindow(screen));
  3142.     }
  3143.     DoResizeScreen (term);        /* set to the new natural size */
  3144.     if (screen->scrollWidget)
  3145.       ResizeScrollBar (screen->scrollWidget, -1, -1,
  3146.                Height(screen) + screen->border * 2);
  3147.     Redraw ();
  3148.     }
  3149.     set_vt_box (screen);
  3150. }
  3151.  
  3152. set_vt_box (screen)
  3153.     TScreen *screen;
  3154. {
  3155.     XPoint    *vp;
  3156.  
  3157.     vp = &VTbox[1];
  3158.     (vp++)->x = FontWidth(screen) - 1;
  3159.     (vp++)->y = FontHeight(screen) - 1;
  3160.     (vp++)->x = -(FontWidth(screen) - 1);
  3161.     vp->y = -(FontHeight(screen) - 1);
  3162.     screen->box = VTbox;
  3163. }
  3164.  
  3165.  
  3166. set_cursor_gcs (screen)
  3167.     TScreen *screen;
  3168. {
  3169.     XGCValues xgcv;
  3170.     unsigned long mask;
  3171.     unsigned long cc = screen->cursorcolor;
  3172.     unsigned long fg = screen->foreground;
  3173.     unsigned long bg = term->core.background_pixel;
  3174.     GC new_cursorGC = NULL, new_reversecursorGC = NULL;
  3175.     GC new_cursoroutlineGC = NULL;
  3176.  
  3177.     /*
  3178.      * Let's see, there are three things that have "color":
  3179.      *
  3180.      *     background
  3181.      *     text
  3182.      *     cursorblock
  3183.      *
  3184.      * And, there are four situation when drawing a cursor, if we decide
  3185.      * that we like have a solid block of cursor color with the letter
  3186.      * that it is highlighting shown in the background color to make it
  3187.      * stand out:
  3188.      *
  3189.      *     selected window, normal video - background on cursor
  3190.      *     selected window, reverse video - foreground on cursor
  3191.      *     unselected window, normal video - foreground on background
  3192.      *     unselected window, reverse video - background on foreground
  3193.      *
  3194.      * Since the last two are really just normalGC and reverseGC, we only
  3195.      * need two new GC's.  Under monochrome, we get the same effect as
  3196.      * above by setting cursor color to foreground.
  3197.      */
  3198.  
  3199.     xgcv.font = screen->fnt_norm->fid;
  3200.     mask = (GCForeground | GCBackground | GCFont);
  3201.     if (cc != fg && cc != bg) {
  3202.     /* we have a colored cursor */
  3203.     xgcv.foreground = fg;
  3204.     xgcv.background = cc;
  3205.     new_cursorGC = XtGetGC ((Widget) term, mask, &xgcv);
  3206.  
  3207.     if (screen->always_highlight) {
  3208.         new_reversecursorGC = (GC) 0;
  3209.         new_cursoroutlineGC = (GC) 0;
  3210.     } else {
  3211.         xgcv.foreground = bg;
  3212.         xgcv.background = cc;
  3213.         new_reversecursorGC = XtGetGC ((Widget) term, mask, &xgcv);
  3214.         xgcv.foreground = cc;
  3215.         xgcv.background = bg;
  3216.         new_cursoroutlineGC = XtGetGC ((Widget) term, mask, &xgcv);
  3217.         }
  3218.     } else {
  3219.     new_cursorGC = (GC) 0;
  3220.     new_reversecursorGC = (GC) 0;
  3221.     new_cursoroutlineGC = (GC) 0;
  3222.     }
  3223.     if (screen->cursorGC) XtReleaseGC ((Widget)term, screen->cursorGC);
  3224.     if (screen->reversecursorGC)
  3225.     XtReleaseGC ((Widget)term, screen->reversecursorGC);
  3226.     if (screen->cursoroutlineGC)
  3227.     XtReleaseGC ((Widget)term, screen->cursoroutlineGC);
  3228.     screen->cursorGC = new_cursorGC;
  3229.     screen->reversecursorGC = new_reversecursorGC;
  3230.     screen->cursoroutlineGC = new_cursoroutlineGC;
  3231. }
  3232.