home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / X / mit / clients / xterm / misc.c.orig < prev    next >
Encoding:
Text File  |  1991-07-25  |  21.8 KB  |  956 lines
  1. /*
  2.  *    $XConsortium: misc.c,v 1.90 91/07/25 17:59:05 rws Exp $
  3.  */
  4.  
  5. /*
  6.  * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
  7.  *
  8.  *                         All Rights Reserved
  9.  *
  10.  * Permission to use, copy, modify, and distribute this software and its
  11.  * documentation for any purpose and without fee is hereby granted,
  12.  * provided that the above copyright notice appear in all copies and that
  13.  * both that copyright notice and this permission notice appear in
  14.  * supporting documentation, and that the name of Digital Equipment
  15.  * Corporation not be used in advertising or publicity pertaining to
  16.  * distribution of the software without specific, written prior permission.
  17.  *
  18.  *
  19.  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  20.  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  21.  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  22.  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  23.  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  24.  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  25.  * SOFTWARE.
  26.  */
  27.  
  28. #include "ptyx.h"        /* X headers included here. */
  29.  
  30. #include <X11/Xos.h>
  31. #include <stdio.h>
  32. #include <setjmp.h>
  33. #include <signal.h>
  34. #include <ctype.h>
  35. #include <pwd.h>
  36. #include <errno.h>
  37.  
  38. #include <X11/Xatom.h>
  39. #include <X11/cursorfont.h>
  40.  
  41. #include <X11/Shell.h>
  42. #include <X11/Xmu/Error.h>
  43. #include <X11/Xmu/SysUtil.h>
  44. #include <X11/Xmu/WinUtil.h>
  45.  
  46. #include "data.h"
  47. #include "error.h"
  48. #include "menu.h"
  49.  
  50. extern jmp_buf Tekend;
  51. extern jmp_buf VTend;
  52.  
  53. #ifndef X_NOT_STDC_ENV
  54. #include <stdlib.h>
  55. #else
  56. extern char *malloc();
  57. extern char *getenv();
  58. #endif
  59. #if defined(macII) && !defined(__STDC__)  /* stdlib.h fails to define these */
  60. char *malloc();
  61. #endif /* macII */
  62.  
  63. static void DoSpecialEnterNotify();
  64. static void DoSpecialLeaveNotify();
  65.  
  66. xevents()
  67. {
  68.     XEvent event;
  69.     register TScreen *screen = &term->screen;
  70.     extern XtAppContext app_con;
  71.  
  72.     if(screen->scroll_amt)
  73.         FlushScroll(screen);
  74.     if (!XPending (screen->display))
  75.         /* protect against events/errors being swallowed by us or Xlib */
  76.         return;
  77.     do {
  78.         if (waitingForTrackInfo)
  79.             return;
  80.         XNextEvent (screen->display, &event);
  81.         /*
  82.          * Hack to get around problems with the toolkit throwing away
  83.          * eventing during the exclusive grab of the menu popup.  By
  84.          * looking at the event ourselves we make sure that we can
  85.          * do the right thing.
  86.          */
  87.         if(event.type == EnterNotify &&
  88.            (event.xcrossing.window == XtWindow(XtParent(term)) ||
  89.             (tekWidget &&
  90.              event.xcrossing.window == XtWindow(XtParent(tekWidget)))))
  91.           DoSpecialEnterNotify (&event.xcrossing);
  92.         else 
  93.         if(event.type == LeaveNotify &&
  94.            (event.xcrossing.window == XtWindow(XtParent(term)) ||
  95.             (tekWidget &&
  96.              event.xcrossing.window == XtWindow(XtParent(tekWidget)))))
  97.           DoSpecialLeaveNotify (&event.xcrossing);
  98.  
  99.         if (!event.xany.send_event ||
  100.             screen->allowSendEvents ||
  101.             ((event.xany.type != KeyPress) &&
  102.              (event.xany.type != KeyRelease) &&
  103.              (event.xany.type != ButtonPress) &&
  104.              (event.xany.type != ButtonRelease)))
  105.             XtDispatchEvent(&event);
  106.     } while (QLength(screen->display) > 0);
  107. }
  108.  
  109.  
  110. Cursor make_colored_cursor (cursorindex, fg, bg)
  111.     int cursorindex;            /* index into font */
  112.     unsigned long fg, bg;            /* pixel value */
  113. {
  114.     register TScreen *screen = &term->screen;
  115.     Cursor c;
  116.     register Display *dpy = screen->display;
  117.     
  118.     c = XCreateFontCursor (dpy, cursorindex);
  119.     if (c == (Cursor) 0) return (c);
  120.  
  121.     recolor_cursor (c, fg, bg);
  122.     return (c);
  123. }
  124.  
  125. /* ARGSUSED */
  126. void HandleKeyPressed(w, event, params, nparams)
  127.     Widget w;
  128.     XEvent *event;
  129.     String *params;
  130.     Cardinal *nparams;
  131. {
  132.     register TScreen *screen = &term->screen;
  133.  
  134. #ifdef ACTIVEWINDOWINPUTONLY
  135.     if (w == (screen->TekEmu ? (Widget)tekWidget : (Widget)term))
  136. #endif
  137.     Input (&term->keyboard, screen, &event->xkey, False);
  138. }
  139. /* ARGSUSED */
  140. void HandleEightBitKeyPressed(w, event, params, nparams)
  141.     Widget w;
  142.     XEvent *event;
  143.     String *params;
  144.     Cardinal *nparams;
  145. {
  146.     register TScreen *screen = &term->screen;
  147.  
  148. #ifdef ACTIVEWINDOWINPUTONLY
  149.     if (w == (screen->TekEmu ? (Widget)tekWidget : (Widget)term))
  150. #endif
  151.     Input (&term->keyboard, screen, &event->xkey, True);
  152. }
  153.  
  154. /* ARGSUSED */
  155. void HandleStringEvent(w, event, params, nparams)
  156.     Widget w;
  157.     XEvent *event;
  158.     String *params;
  159.     Cardinal *nparams;
  160. {
  161.     register TScreen *screen = &term->screen;
  162.  
  163. #ifdef ACTIVEWINDOWINPUTONLY
  164.     if (w != (screen->TekEmu ? (Widget)tekWidget : (Widget)term)) return;
  165. #endif
  166.  
  167.     if (*nparams != 1) return;
  168.  
  169.     if ((*params)[0] == '0' && (*params)[1] == 'x' && (*params)[2] != '\0') {
  170.     char c, *p, hexval[2];
  171.     hexval[0] = hexval[1] = 0;
  172.     for (p = *params+2; (c = *p); p++) {
  173.         hexval[0] *= 16;
  174.         if (isupper(c)) c = tolower(c);
  175.         if (c >= '0' && c <= '9')
  176.         hexval[0] += c - '0';
  177.         else if (c >= 'a' && c <= 'f')
  178.         hexval[0] += c - 'a' + 10;
  179.         else break;
  180.     }
  181.     if (c == '\0')
  182.         StringInput (screen, hexval, 1);
  183.     }
  184.     else {
  185.     StringInput (screen, *params, strlen(*params));
  186.     }
  187. }
  188.  
  189. static void DoSpecialEnterNotify (ev)
  190.     register XEnterWindowEvent *ev;
  191. {
  192.     register TScreen *screen = &term->screen;
  193.  
  194. #ifdef ACTIVEWINDOWINPUTONLY
  195.     if (ev->window == XtWindow(XtParent(screen->TekEmu ?
  196.                     (Widget)tekWidget : (Widget)term)))
  197. #endif
  198.       if (((ev->detail) != NotifyInferior) &&
  199.       ev->focus &&
  200.       !(screen->select & FOCUS))
  201.     selectwindow(screen, INWINDOW);
  202. }
  203.  
  204. /*ARGSUSED*/
  205. void HandleEnterWindow(w, eventdata, event)
  206. Widget w;
  207. register XEnterWindowEvent *event;
  208. caddr_t eventdata;
  209. {
  210.     /* NOP since we handled it above */
  211. }
  212.  
  213.  
  214. static void DoSpecialLeaveNotify (ev)
  215.     register XEnterWindowEvent *ev;
  216. {
  217.     register TScreen *screen = &term->screen;
  218.  
  219. #ifdef ACTIVEWINDOWINPUTONLY
  220.     if (ev->window == XtWindow(XtParent(screen->TekEmu ?
  221.                     (Widget)tekWidget : (Widget)term)))
  222. #endif
  223.       if (((ev->detail) != NotifyInferior) &&
  224.       ev->focus &&
  225.       !(screen->select & FOCUS))
  226.     unselectwindow(screen, INWINDOW);
  227. }
  228.  
  229.  
  230. /*ARGSUSED*/
  231. void HandleLeaveWindow(w, eventdata, event)
  232. Widget w;
  233. register XEnterWindowEvent *event;
  234. caddr_t eventdata;
  235. {
  236.     /* NOP since we handled it above */
  237. }
  238.  
  239.  
  240. /*ARGSUSED*/
  241. void HandleFocusChange(w, eventdata, event)
  242. Widget w;
  243. register XFocusChangeEvent *event;
  244. caddr_t eventdata;
  245. {
  246.         register TScreen *screen = &term->screen;
  247.  
  248.         if(event->type == FocusIn)
  249.                 selectwindow(screen,
  250.                  (event->detail == NotifyPointer) ? INWINDOW :
  251.                                 FOCUS);
  252.         else {
  253.                 unselectwindow(screen,
  254.                    (event->detail == NotifyPointer) ? INWINDOW :
  255.                                   FOCUS);
  256.         if (screen->grabbedKbd && (event->mode == NotifyUngrab)) {
  257.             screen->grabbedKbd = FALSE;
  258.             ReverseVideo(term);
  259.             XBell(screen->display, 100);
  260.         }
  261.     }
  262. }
  263.  
  264.  
  265.  
  266. selectwindow(screen, flag)
  267. register TScreen *screen;
  268. register int flag;
  269. {
  270.     if(screen->TekEmu) {
  271.         if(!Ttoggled)
  272.             TCursorToggle(TOGGLE);
  273.         screen->select |= flag;
  274.         if(!Ttoggled)
  275.             TCursorToggle(TOGGLE);
  276.         return;
  277.     } else {
  278.         if(screen->cursor_state &&
  279.            (screen->cursor_col != screen->cur_col ||
  280.             screen->cursor_row != screen->cur_row))
  281.             HideCursor();
  282.         screen->select |= flag;
  283.         if(screen->cursor_state)
  284.             ShowCursor();
  285.         return;
  286.     }
  287. }
  288.  
  289. unselectwindow(screen, flag)
  290. register TScreen *screen;
  291. register int flag;
  292. {
  293.     if (screen->always_highlight) return;
  294.  
  295.     if(screen->TekEmu) {
  296.     if(!Ttoggled) TCursorToggle(TOGGLE);
  297.     screen->select &= ~flag;
  298.     if(!Ttoggled) TCursorToggle(TOGGLE);
  299.     } else {
  300.     screen->select &= ~flag;
  301.     if(screen->cursor_state &&
  302.        (screen->cursor_col != screen->cur_col ||
  303.         screen->cursor_row != screen->cur_row))
  304.           HideCursor();
  305.     if(screen->cursor_state)
  306.       ShowCursor();
  307.     }
  308. }
  309.  
  310. static long lastBellTime;    /* in milliseconds */
  311.  
  312. Bell()
  313. {
  314.     extern XtermWidget term;
  315.     register TScreen *screen = &term->screen;
  316.     struct timeval curtime;
  317.     long now_msecs;
  318.  
  319.     /* has enough time gone by that we are allowed to ring
  320.        the bell again? */
  321.     if(screen->bellSuppressTime) {
  322.     if(screen->bellInProgress) {
  323.         if (QLength(screen->display) > 0 ||
  324.         GetBytesAvailable (ConnectionNumber(screen->display)) > 0)
  325.         xevents();
  326.         if(screen->bellInProgress) { /* even after new events? */
  327.         return;
  328.         }
  329.     }
  330.     gettimeofday(&curtime, NULL);
  331.     now_msecs = 1000*curtime.tv_sec + curtime.tv_usec/1000;
  332.     if(lastBellTime != 0  &&  now_msecs - lastBellTime >= 0  &&
  333.        now_msecs - lastBellTime < screen->bellSuppressTime) {
  334.         return;
  335.     }
  336.     lastBellTime = now_msecs;
  337.     }
  338.  
  339.     if (screen->visualbell)
  340.     VisualBell();
  341.     else
  342.     XBell(screen->display, 0);
  343.  
  344.     if(screen->bellSuppressTime) {
  345.     /* now we change a property and wait for the notify event to come
  346.        back.  If the server is suspending operations while the bell
  347.        is being emitted (problematic for audio bell), this lets us
  348.        know when the previous bell has finished */
  349.     Widget w = screen->TekEmu ? (Widget) tekWidget : (Widget) term;
  350.     XChangeProperty(XtDisplay(w), XtWindow(w),
  351.             XA_NOTICE, XA_NOTICE, 8, PropModeAppend, NULL, 0);
  352.     screen->bellInProgress = TRUE;
  353.     }
  354. }
  355.  
  356.  
  357. VisualBell()
  358. {
  359.     extern XtermWidget term;
  360.     register TScreen *screen = &term->screen;
  361.     register Pixel xorPixel = screen->foreground ^ term->core.background_pixel;
  362.     XGCValues gcval;
  363.     GC visualGC;
  364.  
  365.     gcval.function = GXxor;
  366.     gcval.foreground = xorPixel;
  367.     visualGC = XtGetGC((Widget)term, GCFunction+GCForeground, &gcval);
  368.     if(screen->TekEmu) {
  369.     XFillRectangle(
  370.                screen->display,
  371.                TWindow(screen), 
  372.                visualGC,
  373.                0, 0,
  374.                (unsigned) TFullWidth(screen),
  375.                (unsigned) TFullHeight(screen));
  376.     XFlush(screen->display);
  377.     XFillRectangle(
  378.                screen->display,
  379.                TWindow(screen), 
  380.                visualGC,
  381.                0, 0,
  382.                (unsigned) TFullWidth(screen),
  383.                (unsigned) TFullHeight(screen));
  384.     } else {
  385.     XFillRectangle(
  386.                screen->display,
  387.                VWindow(screen), 
  388.                visualGC,
  389.                0, 0,
  390.                (unsigned) FullWidth(screen),
  391.                (unsigned) FullHeight(screen));
  392.     XFlush(screen->display);
  393.     XFillRectangle(
  394.                screen->display,
  395.                VWindow(screen), 
  396.                visualGC,
  397.                0, 0,
  398.                (unsigned) FullWidth(screen),
  399.                (unsigned) FullHeight(screen));
  400.     }
  401. }
  402.  
  403. /* ARGSUSED */
  404. void HandleBellPropertyChange(w, data, ev, more)
  405.     Widget w;
  406.     XtPointer data;
  407.     XEvent *ev;
  408.     Boolean *more;
  409. {
  410.     register TScreen *screen = &term->screen;
  411.  
  412.     if (ev->xproperty.atom == XA_NOTICE) {
  413.     screen->bellInProgress = FALSE;
  414.     }
  415. }
  416.  
  417. Redraw()
  418. {
  419.     extern XtermWidget term;
  420.     register TScreen *screen = &term->screen;
  421.     XExposeEvent event;
  422.  
  423.     event.type = Expose;
  424.     event.display = screen->display;
  425.     event.x = 0;
  426.     event.y = 0;
  427.     event.count = 0; 
  428.     
  429.     if(VWindow(screen)) {
  430.             event.window = VWindow(screen);
  431.         event.width = term->core.width;
  432.         event.height = term->core.height;
  433.         (*term->core.widget_class->core_class.expose)((Widget)term, (XEvent *)&event, NULL);
  434.         if(screen->scrollbar) 
  435.             (*screen->scrollWidget->core.widget_class->core_class.expose)(screen->scrollWidget, (XEvent *)&event, NULL);
  436.         }
  437.  
  438.     if(TWindow(screen) && screen->Tshow) {
  439.             event.window = TWindow(screen);
  440.         event.width = tekWidget->core.width;
  441.         event.height = tekWidget->core.height;
  442.         TekExpose (tekWidget, &event, NULL);
  443.     }
  444. }
  445.  
  446. StartLog(screen)
  447. register TScreen *screen;
  448. {
  449.     register char *cp;
  450.     register int i;
  451.     static char *log_default;
  452. #ifdef ALLOWLOGFILEEXEC
  453.     void logpipe();
  454. #ifdef SYSV
  455.     /* SYSV has another pointer which should be part of the
  456.     ** FILE structure but is actually a separate array.
  457.     */
  458.     unsigned char *old_bufend;
  459. #endif    /* SYSV */
  460. #endif /* ALLOWLOGFILEEXEC */
  461.  
  462.     if(screen->logging || (screen->inhibit & I_LOG))
  463.         return;
  464.     if(screen->logfile == NULL || *screen->logfile == 0) {
  465.         if(screen->logfile)
  466.             free(screen->logfile);
  467.         if(log_default == NULL)
  468.             log_default = log_def_name;
  469.             mktemp(log_default);
  470.         if((screen->logfile = malloc((unsigned)strlen(log_default) + 1)) == NULL)
  471.             return;
  472.         strcpy(screen->logfile, log_default);
  473.     }
  474.     if(*screen->logfile == '|') {    /* exec command */
  475. #ifdef ALLOWLOGFILEEXEC
  476.         /*
  477.          * Warning, enabling this "feature" allows arbitrary programs
  478.          * to be run.  If ALLOWLOGFILECHANGES is enabled, this can be
  479.          * done through escape sequences....  You have been warned.
  480.          */
  481.         int p[2];
  482.         static char *shell;
  483.  
  484.         if(pipe(p) < 0 || (i = fork()) < 0)
  485.             return;
  486.         if(i == 0) {    /* child */
  487.             close(p[1]);
  488.             dup2(p[0], 0);
  489.             close(p[0]);
  490.             dup2(fileno(stderr), 1);
  491.             dup2(fileno(stderr), 2);
  492. #ifdef SYSV
  493.             old_bufend = _bufend(stderr);
  494. #endif    /* SYSV */
  495.             close(fileno(stderr));
  496.             stderr->_file = 2;
  497. #ifdef SYSV
  498.             _bufend(stderr) = old_bufend;
  499. #endif    /* SYSV */
  500.             close(ConnectionNumber(screen->display));
  501.             close(screen->respond);
  502.             if(!shell) {
  503.                 register struct passwd *pw;
  504.                 struct passwd *getpwuid();
  505.  
  506.                 if(((cp = getenv("SHELL")) == NULL || *cp == 0)
  507.                  && ((pw = getpwuid(screen->uid)) == NULL ||
  508.                  *(cp = pw->pw_shell) == 0) ||
  509.                  (shell = malloc((unsigned) strlen(cp) + 1)) == NULL)
  510.                     shell = "/bin/sh";
  511.                 else
  512.                     strcpy(shell, cp);
  513.             }
  514.             signal(SIGHUP, SIG_DFL);
  515.             signal(SIGCHLD, SIG_DFL);
  516.             setgid(screen->gid);
  517.             setuid(screen->uid);
  518.             execl(shell, shell, "-c", &screen->logfile[1], 0);
  519.             fprintf(stderr, "%s: Can't exec `%s'\n", xterm_name,
  520.              &screen->logfile[1]);
  521.             exit(ERROR_LOGEXEC);
  522.         }
  523.         close(p[0]);
  524.         screen->logfd = p[1];
  525.         signal(SIGPIPE, logpipe);
  526. #else
  527.         Bell();
  528.         Bell();
  529.         return;
  530. #endif
  531.     } else {
  532.         if(access(screen->logfile, F_OK) == 0) {
  533.             if(access(screen->logfile, W_OK) < 0)
  534.                 return;
  535.         } else if(cp = rindex(screen->logfile, '/')) {
  536.             *cp = 0;
  537.             i = access(screen->logfile, W_OK);
  538.             *cp = '/';
  539.             if(i < 0)
  540.                 return;
  541.         } else if(access(".", W_OK) < 0)
  542.             return;
  543.         if((screen->logfd = open(screen->logfile, O_WRONLY | O_APPEND |
  544.          O_CREAT, 0644)) < 0)
  545.             return;
  546.         chown(screen->logfile, screen->uid, screen->gid);
  547.  
  548.     }
  549.     screen->logstart = screen->TekEmu ? Tbptr : bptr;
  550.     screen->logging = TRUE;
  551.     update_logging();
  552. }
  553.  
  554. CloseLog(screen)
  555. register TScreen *screen;
  556. {
  557.     if(!screen->logging || (screen->inhibit & I_LOG))
  558.         return;
  559.     FlushLog(screen);
  560.     close(screen->logfd);
  561.     screen->logging = FALSE;
  562.     update_logging();
  563. }
  564.  
  565. FlushLog(screen)
  566. register TScreen *screen;
  567. {
  568.     register Char *cp;
  569.     register int i;
  570.  
  571.     cp = screen->TekEmu ? Tbptr : bptr;
  572.     if((i = cp - screen->logstart) > 0)
  573.         write(screen->logfd, screen->logstart, i);
  574.     screen->logstart = screen->TekEmu ? Tbuffer : buffer;
  575. }
  576.  
  577. #ifdef ALLOWLOGFILEEXEC
  578. void logpipe()
  579. {
  580.     register TScreen *screen = &term->screen;
  581.  
  582. #ifdef SYSV
  583.     (void) signal(SIGPIPE, SIG_IGN);
  584. #endif    /* SYSV */
  585.     if(screen->logging)
  586.         CloseLog(screen);
  587. }
  588. #endif /* ALLOWLOGFILEEXEC */
  589.  
  590.  
  591. do_osc(func)
  592. int (*func)();
  593. {
  594.     register int mode, c;
  595.     register char *cp;
  596.     char buf[512];
  597.     char *bufend = &buf[(sizeof buf) - 1];    /* leave room for null */
  598.     Bool okay = True;
  599.  
  600.     /* 
  601.      * lines should be of the form <ESC> ] number ; string <BEL>
  602.      *
  603.      * where number is one of 0, 1, 2, or 46
  604.      */
  605.     mode = 0;
  606.     while(isdigit(c = (*func)()))
  607.         mode = 10 * mode + (c - '0');
  608.     if (c != ';') okay = False;
  609.     cp = buf;
  610.     while(isprint((c = (*func)()) & 0x7f) && cp < bufend)
  611.         *cp++ = c;
  612.     if (c != 7) okay = False;
  613.     *cp = 0;
  614.     if (okay) switch(mode) {
  615.      case 0:    /* new icon name and title*/
  616.         Changename(buf);
  617.         Changetitle(buf);
  618.         break;
  619.  
  620.      case 1:    /* new icon name only */
  621.         Changename(buf);
  622.         break;
  623.  
  624.      case 2:    /* new title only */
  625.         Changetitle(buf);
  626.         break;
  627.  
  628.      case 46:    /* new log file */
  629. #ifdef ALLOWLOGFILECHANGES
  630.         /*
  631.          * Warning, enabling this feature allows people to overwrite
  632.          * arbitrary files accessible to the person running xterm.
  633.          */
  634.         if((cp = malloc((unsigned)strlen(buf) + 1)) == NULL)
  635.             break;
  636.         strcpy(cp, buf);
  637.         if(term->screen.logfile)
  638.             free(term->screen.logfile);
  639.         term->screen.logfile = cp;
  640. #else
  641.         Bell();
  642.         Bell();
  643. #endif
  644.         break;
  645.  
  646.     case 50:
  647.         SetVTFont (fontMenu_fontescape, True, buf, NULL);
  648.         break;
  649.  
  650.     /*
  651.      * One could write code to send back the display and host names,
  652.      * but that could potentially open a fairly nasty security hole.
  653.      */
  654.     }
  655. }
  656.  
  657. static ChangeGroup(attribute, value)
  658.      String attribute;
  659.      XtArgVal value;
  660. {
  661.     extern Widget toplevel;
  662.     Arg args[1];
  663.  
  664.     XtSetArg( args[0], attribute, value );
  665.     XtSetValues( toplevel, args, 1 );
  666. }
  667.  
  668. Changename(name)
  669. register char *name;
  670. {
  671.     ChangeGroup( XtNiconName, (XtArgVal)name );
  672. }
  673.  
  674. Changetitle(name)
  675. register char *name;
  676. {
  677.     ChangeGroup( XtNtitle, (XtArgVal)name );
  678. }
  679.  
  680. #ifndef DEBUG
  681. /* ARGSUSED */
  682. #endif
  683. Panic(s, a)
  684. char    *s;
  685. int a;
  686. {
  687. #ifdef DEBUG
  688.     if(debug) {
  689.         fprintf(stderr, "%s: PANIC!    ", xterm_name);
  690.         fprintf(stderr, s, a);
  691.         fputs("\r\n", stderr);
  692.         fflush(stderr);
  693.     }
  694. #endif    /* DEBUG */
  695. }
  696.  
  697. char *SysErrorMsg (n)
  698.     int n;
  699. {
  700.     extern char *sys_errlist[];
  701.     extern int sys_nerr;
  702.  
  703.     return ((n >= 0 && n < sys_nerr) ? sys_errlist[n] : "unknown error");
  704. }
  705.  
  706.  
  707. SysError (i)
  708. int i;
  709. {
  710.     int oerrno;
  711.  
  712.     oerrno = errno;
  713.     /* perror(3) write(2)s to file descriptor 2 */
  714.     fprintf (stderr, "%s: Error %d, errno %d: ", xterm_name, i, oerrno);
  715.     fprintf (stderr, "%s\n", SysErrorMsg (oerrno));
  716.     Cleanup(i);
  717. }
  718.  
  719. Error (i)
  720. int i;
  721. {
  722.     fprintf (stderr, "%s: Error %d\n", xterm_name, i);
  723.     Cleanup(i);
  724. }
  725.  
  726.  
  727. /*
  728.  * cleanup by sending SIGHUP to client processes
  729.  */
  730. Cleanup (code)
  731. int code;
  732. {
  733.     extern XtermWidget term;
  734.     register TScreen *screen;
  735.  
  736.     screen = &term->screen;
  737.     if (screen->pid > 1) {
  738.         (void) kill_process_group (screen->pid, SIGHUP);
  739.     }
  740.     Exit (code);
  741. }
  742.  
  743. /*
  744.  * sets the value of var to be arg in the Unix 4.2 BSD environment env.
  745.  * Var should end with '=' (bindings are of the form "var=value").
  746.  * This procedure assumes the memory for the first level of environ
  747.  * was allocated using calloc, with enough extra room at the end so not
  748.  * to have to do a realloc().
  749.  */
  750. Setenv (var, value)
  751. register char *var, *value;
  752. {
  753.     extern char **environ;
  754.     register int envindex = 0;
  755.     register int len = strlen(var);
  756.  
  757.     while (environ [envindex] != NULL) {
  758.         if (strncmp (environ [envindex], var, len) == 0) {
  759.         /* found it */
  760.         environ[envindex] = (char *)malloc ((unsigned)len + strlen (value) + 1);
  761.         strcpy (environ [envindex], var);
  762.         strcat (environ [envindex], value);
  763.         return;
  764.         }
  765.         envindex ++;
  766.     }
  767.  
  768. #ifdef DEBUG
  769.     if (debug) fputs ("expanding env\n", stderr);
  770. #endif    /* DEBUG */
  771.  
  772.     environ [envindex] = (char *) malloc ((unsigned)len + strlen (value) + 1);
  773.     (void) strcpy (environ [envindex], var);
  774.     strcat (environ [envindex], value);
  775.     environ [++envindex] = NULL;
  776. }
  777.  
  778. /*
  779.  * returns a pointer to the first occurrence of s2 in s1,
  780.  * or NULL if there are none.
  781.  */
  782. char *strindex (s1, s2)
  783. register char    *s1, *s2;
  784. {
  785.     register char    *s3;
  786.     int s2len = strlen (s2);
  787.  
  788.     while ((s3=index(s1, *s2)) != NULL) {
  789.         if (strncmp(s3, s2, s2len) == 0)
  790.             return (s3);
  791.         s1 = ++s3;
  792.     }
  793.     return (NULL);
  794. }
  795.  
  796. /*ARGSUSED*/
  797. xerror(d, ev)
  798. Display *d;
  799. register XErrorEvent *ev;
  800. {
  801.     fprintf (stderr, "%s:  warning, error event receieved:\n", xterm_name);
  802.     (void) XmuPrintDefaultErrorMessage (d, ev, stderr);
  803.     Exit (ERROR_XERROR);
  804. }
  805.  
  806. /*ARGSUSED*/
  807. xioerror(dpy)
  808. Display *dpy;
  809. {
  810.     (void) fprintf (stderr, 
  811.             "%s:  fatal IO error %d (%s) or KillClient on X server \"%s\"\r\n",
  812.             xterm_name, errno, SysErrorMsg (errno),
  813.             DisplayString (dpy));
  814.  
  815.     Exit(ERROR_XIOERROR);
  816. }
  817.  
  818. XStrCmp(s1, s2)
  819. char *s1, *s2;
  820. {
  821.   if (s1 && s2) return(strcmp(s1, s2));
  822.   if (s1 && *s1) return(1);
  823.   if (s2 && *s2) return(-1);
  824.   return(0);
  825. }
  826.  
  827. static void withdraw_window (dpy, w, scr)
  828.     Display *dpy;
  829.     Window w;
  830.     int scr;
  831. {
  832.     (void) XmuUpdateMapHints (dpy, w, NULL);
  833.     XWithdrawWindow (dpy, w, scr);
  834.     return;
  835. }
  836.  
  837.  
  838. void set_vt_visibility (on)
  839.     Boolean on;
  840. {
  841.     register TScreen *screen = &term->screen;
  842.  
  843.     if (on) {
  844.     if (!screen->Vshow && term) {
  845.         VTInit ();
  846.         XtMapWidget (term->core.parent);
  847.         screen->Vshow = TRUE;
  848.     }
  849.     } else {
  850.     if (screen->Vshow && term) {
  851.         withdraw_window (XtDisplay (term), 
  852.                  XtWindow(XtParent(term)),
  853.                  XScreenNumberOfScreen(XtScreen(term)));
  854.         screen->Vshow = FALSE;
  855.     }
  856.     }
  857.     set_vthide_sensitivity();
  858.     set_tekhide_sensitivity();
  859.     update_vttekmode();
  860.     update_tekshow();
  861.     update_vtshow();
  862.     return;
  863. }
  864.                 
  865. extern Atom wm_delete_window;    /* for ICCCM delete window */
  866.  
  867. void set_tek_visibility (on)
  868.     Boolean on;
  869. {
  870.     register TScreen *screen = &term->screen;
  871.     if (on) {
  872.     if (!screen->Tshow && (tekWidget || TekInit())) {
  873.         Widget tekParent = tekWidget->core.parent;
  874.         XtRealizeWidget (tekParent);
  875.         XtMapWidget (tekParent);
  876.         XtOverrideTranslations(tekParent,
  877.                    XtParseTranslationTable
  878.                    ("<Message>WM_PROTOCOLS: DeleteWindow()"));
  879.         (void) XSetWMProtocols (XtDisplay(tekParent), 
  880.                     XtWindow(tekParent),
  881.                     &wm_delete_window, 1);
  882.         screen->Tshow = TRUE;
  883.     }
  884.     } else {
  885.     if (screen->Tshow && tekWidget) {
  886.         withdraw_window (XtDisplay (tekWidget), 
  887.                  XtWindow(XtParent(tekWidget)),
  888.                  XScreenNumberOfScreen(XtScreen(tekWidget)));
  889.         screen->Tshow = FALSE;
  890.     }
  891.     }
  892.     set_tekhide_sensitivity();
  893.     set_vthide_sensitivity();
  894.     update_vtshow();
  895.     update_tekshow();
  896.     update_vttekmode();
  897.     return;
  898. }
  899.  
  900. void end_tek_mode ()
  901. {
  902.     register TScreen *screen = &term->screen;
  903.  
  904.     if (screen->TekEmu) {
  905.     if (screen->logging) {
  906.         FlushLog (screen);
  907.         screen->logstart = buffer;
  908.     }
  909.     longjmp(Tekend, 1);
  910.     } 
  911.     return;
  912. }
  913.  
  914. void end_vt_mode ()
  915. {
  916.     register TScreen *screen = &term->screen;
  917.  
  918.     if (!screen->TekEmu) {
  919.     if(screen->logging) {
  920.         FlushLog(screen);
  921.         screen->logstart = Tbuffer;
  922.     }
  923.     screen->TekEmu = TRUE;
  924.     longjmp(VTend, 1);
  925.     } 
  926.     return;
  927. }
  928.  
  929. void switch_modes (tovt)
  930.     Bool tovt;                /* if true, then become vt mode */
  931. {
  932.     if (tovt) {
  933.     if (TekRefresh) dorefresh();
  934.     end_tek_mode ();        /* WARNING: this does a longjmp... */
  935.     } else {
  936.     end_vt_mode ();            /* WARNING: this does a longjmp... */
  937.     }
  938. }
  939.  
  940. void hide_vt_window ()
  941. {
  942.     register TScreen *screen = &term->screen;
  943.  
  944.     set_vt_visibility (FALSE);
  945.     if (!screen->TekEmu) switch_modes (False);    /* switch to tek mode */
  946. }
  947.  
  948. void hide_tek_window ()
  949. {
  950.     register TScreen *screen = &term->screen;
  951.  
  952.     set_tek_visibility (FALSE);
  953.     TekRefresh = (TekLink *)0;
  954.     if (screen->TekEmu) switch_modes (True);    /* does longjmp to vt mode */
  955. }
  956.