tomw@orac.esd.sgi.com (Tom Weinstein) (09/14/90)
Submitted-by: Tom Weinstein <tomw@orac.esd.sgi.com>
Posting-number: Volume 9, Issue 38
Archive-name: colxterm/part08
#! /bin/sh
# This is a shell archive. Remove anything before this line, then feed it
# into a shell via "sh file" or similar. To overwrite existing files,
# type "sh file -c".
# The tool that generated this appeared in the comp.sources.unix newsgroup;
# send mail to comp-sources-unix@uunet.uu.net if you want that tool.
# If this archive is complete, you will see the following message at the end:
# "End of archive 8 (of 14)."
# Contents: xterm/menu.c xterm/misc.c xterm/termcap.bold
# Wrapped by argv@turnpike on Thu Sep 13 20:42:26 1990
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'xterm/menu.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'xterm/menu.c'\"
else
echo shar: Extracting \"'xterm/menu.c'\" \(27111 characters\)
sed "s/^X//" >'xterm/menu.c' <<'END_OF_FILE'
X/* Copyright 1989 Massachusetts Institute of Technology */
X
X#include <stdio.h>
X#include <X11/Intrinsic.h>
X#include <X11/StringDefs.h>
X#include <X11/Shell.h>
X#include <X11/Xaw/SimpleMenu.h>
X#include <X11/Xaw/SmeBSB.h>
X#include <X11/Xaw/SmeLine.h>
X#include "ptyx.h"
X#include <setjmp.h> /* for data.h */
X#include "data.h"
X#include "menu.h"
X
XArg menuArgs[2] = {{ XtNleftBitmap, (XtArgVal) 0 },
X { XtNsensitive, (XtArgVal) 0 }};
X
Xstatic void do_securekbd(), do_allowsends(), do_visualbell(), do_logging(),
X do_redraw(), do_suspend(), do_continue(), do_interrupt(), do_hangup(),
X do_terminate(), do_kill(), do_quit(), do_scrollbar(), do_jumpscroll(),
X do_reversevideo(), do_autowrap(), do_reversewrap(), do_autolinefeed(),
X do_appcursor(), do_appkeypad(), do_scrollkey(), do_scrollttyoutput(),
X do_allow132(), do_cursesemul(), do_marginbell(), do_tekshow(),
X do_altscreen(), do_softreset(), do_hardreset(), do_tekmode(), do_vthide(),
X do_tektextlarge(), do_tektext2(), do_tektext3(), do_tektextsmall(),
X do_tekpage(), do_tekreset(), do_tekcopy(), do_vtshow(), do_vtmode(),
X do_tekhide(), do_vtfont(), do_bltscroll();
X
X
X/*
X * The order entries MUST match the values given in menu.h
X */
XMenuEntry mainMenuEntries[] = {
X { "securekbd", do_securekbd, NULL }, /* 0 */
X { "allowsends", do_allowsends, NULL }, /* 1 */
X { "logging", do_logging, NULL }, /* 2 */
X { "redraw", do_redraw, NULL }, /* 3 */
X { "line1", NULL, NULL }, /* 4 */
X { "suspend", do_suspend, NULL }, /* 5 */
X { "continue", do_continue, NULL }, /* 6 */
X { "interrupt", do_interrupt, NULL }, /* 7 */
X { "hangup", do_hangup, NULL }, /* 8 */
X { "terminate", do_terminate, NULL }, /* 9 */
X { "kill", do_kill, NULL }, /* 10 */
X { "line2", NULL, NULL }, /* 11 */
X { "quit", do_quit, NULL }}; /* 12 */
X
XMenuEntry vtMenuEntries[] = {
X { "scrollbar", do_scrollbar, NULL }, /* 0 */
X { "jumpscroll", do_jumpscroll, NULL }, /* 1 */
X { "bltscroll", do_bltscroll, NULL }, /* 2 */
X { "reversevideo", do_reversevideo, NULL }, /* 3 */
X { "autowrap", do_autowrap, NULL }, /* 4 */
X { "reversewrap", do_reversewrap, NULL }, /* 5 */
X { "autolinefeed", do_autolinefeed, NULL }, /* 6 */
X { "appcursor", do_appcursor, NULL }, /* 7 */
X { "appkeypad", do_appkeypad, NULL }, /* 8 */
X { "scrollkey", do_scrollkey, NULL }, /* 9 */
X { "scrollttyoutput", do_scrollttyoutput, NULL }, /* 10 */
X { "allow132", do_allow132, NULL }, /* 11 */
X { "cursesemul", do_cursesemul, NULL }, /* 12 */
X { "visualbell", do_visualbell, NULL }, /* 13 */
X { "marginbell", do_marginbell, NULL }, /* 14 */
X { "altscreen", do_altscreen, NULL }, /* 15 */
X { "line1", NULL, NULL }, /* 16 */
X { "softreset", do_softreset, NULL }, /* 17 */
X { "hardreset", do_hardreset, NULL }, /* 18 */
X { "line2", NULL, NULL }, /* 19 */
X { "tekshow", do_tekshow, NULL }, /* 20 */
X { "tekmode", do_tekmode, NULL }, /* 21 */
X { "vthide", do_vthide, NULL }}; /* 22 */
X
XMenuEntry fontMenuEntries[] = {
X { "fontdefault", do_vtfont, NULL }, /* 0 */
X { "font1", do_vtfont, NULL }, /* 1 */
X { "font2", do_vtfont, NULL }, /* 2 */
X { "font3", do_vtfont, NULL }, /* 3 */
X { "font4", do_vtfont, NULL }, /* 4 */
X { "fontescape", do_vtfont, NULL }, /* 5 */
X { "fontsel", do_vtfont, NULL }}; /* 6 */
X /* this should match NMENUFONTS in ptyx.h */
X
XMenuEntry tekMenuEntries[] = {
X { "tektextlarge", do_tektextlarge, NULL }, /* 0 */
X { "tektext2", do_tektext2, NULL }, /* 1 */
X { "tektext3", do_tektext3, NULL }, /* 2 */
X { "tektextsmall", do_tektextsmall, NULL }, /* 3 */
X { "line1", NULL, NULL }, /* 4 */
X { "tekpage", do_tekpage, NULL }, /* 5 */
X { "tekreset", do_tekreset, NULL }, /* 6 */
X { "tekcopy", do_tekcopy, NULL }, /* 7 */
X { "line2", NULL, NULL }, /* 8 */
X { "vtshow", do_vtshow, NULL }, /* 9 */
X { "vtmode", do_vtmode, NULL }, /* 10 */
X { "tekhide", do_tekhide, NULL }}; /* 11 */
X
Xstatic Widget create_menu();
Xextern Widget toplevel;
X
X
X/*
X * we really want to do these dynamically
X */
X#define check_width 9
X#define check_height 8
Xstatic char check_bits[] = {
X 0x00, 0x01, 0x80, 0x01, 0xc0, 0x00, 0x60, 0x00,
X 0x31, 0x00, 0x1b, 0x00, 0x0e, 0x00, 0x04, 0x00
X};
X
X
X/*
X * public interfaces
X */
X
Xstatic Bool domenu (w, event, params, param_count)
X Widget w;
X XEvent *event; /* unused */
X String *params; /* mainMenu, vtMenu, or tekMenu */
X Cardinal *param_count; /* 0 or 1 */
X{
X TScreen *screen = &term->screen;
X
X if (*param_count != 1) {
X XBell (XtDisplay(w), 0);
X return False;
X }
X
X switch (params[0][0]) {
X case 'm':
X if (!screen->mainMenu) {
X screen->mainMenu = create_menu (term, toplevel, "mainMenu",
X mainMenuEntries,
X XtNumber(mainMenuEntries));
X update_securekbd();
X update_allowsends();
X update_logging();
X#ifndef SIGTSTP
X set_sensitivity (screen->mainMenu,
X mainMenuEntries[mainMenu_suspend].widget, FALSE);
X#endif
X#ifndef SIGCONT
X set_sensitivity (screen->mainMenu,
X mainMenuEntries[mainMenu_continue].widget, FALSE);
X#endif
X }
X break;
X
X case 'v':
X if (!screen->vtMenu) {
X screen->vtMenu = create_menu (term, toplevel, "vtMenu",
X vtMenuEntries,
X XtNumber(vtMenuEntries));
X /* and turn off the alternate screen entry */
X set_altscreen_sensitivity (FALSE);
X update_scrollbar();
X update_jumpscroll();
X update_bltscroll();
X update_reversevideo();
X update_autowrap();
X update_reversewrap();
X update_autolinefeed();
X update_appcursor();
X update_appkeypad();
X update_scrollkey();
X update_scrollttyoutput();
X update_allow132();
X update_cursesemul();
X update_visualbell();
X update_marginbell();
X }
X break;
X
X case 'f':
X if (!screen->fontMenu) {
X screen->fontMenu = create_menu (term, toplevel, "fontMenu",
X fontMenuEntries,
X NMENUFONTS);
X set_menu_font (True);
X set_sensitivity (screen->fontMenu,
X fontMenuEntries[fontMenu_fontescape].widget,
X (screen->menu_font_names[fontMenu_fontescape]
X ? TRUE : FALSE));
X }
X FindFontSelection (NULL, True);
X set_sensitivity (screen->fontMenu,
X fontMenuEntries[fontMenu_fontsel].widget,
X (screen->menu_font_names[fontMenu_fontsel]
X ? TRUE : FALSE));
X break;
X
X case 't':
X if (!screen->tekMenu) {
X screen->tekMenu = create_menu (term, toplevel, "tekMenu",
X tekMenuEntries,
X XtNumber(tekMenuEntries));
X set_tekfont_menu_item (screen->cur.fontsize, TRUE);
X }
X break;
X
X default:
X XBell (XtDisplay(w), 0);
X return False;
X }
X
X return True;
X}
X
Xvoid HandleCreateMenu (w, event, params, param_count)
X Widget w;
X XEvent *event; /* unused */
X String *params; /* mainMenu, vtMenu, or tekMenu */
X Cardinal *param_count; /* 0 or 1 */
X{
X (void) domenu (w, event, params, param_count);
X}
X
Xvoid HandlePopupMenu (w, event, params, param_count)
X Widget w;
X XEvent *event; /* unused */
X String *params; /* mainMenu, vtMenu, or tekMenu */
X Cardinal *param_count; /* 0 or 1 */
X{
X if (domenu (w, event, params, param_count)) {
X XtCallActionProc (w, "XawPositionSimpleMenu", event, params, 1);
X XtCallActionProc (w, "MenuPopup", event, params, 1);
X }
X}
X
X
X/*
X * private interfaces - keep out!
X */
X
X/*
X * create_menu - create a popup shell and stuff the menu into it.
X */
X
Xstatic Widget create_menu (xtw, toplevel, name, entries, nentries)
X XtermWidget xtw;
X Widget toplevel;
X char *name;
X struct _MenuEntry *entries;
X int nentries;
X{
X Widget m;
X TScreen *screen = &xtw->screen;
X static XtCallbackRec cb[2] = { { NULL, NULL }, { NULL, NULL }};
X static Arg arg = { XtNcallback, (XtArgVal) cb };
X
X if (screen->menu_item_bitmap == None) {
X screen->menu_item_bitmap =
X XCreateBitmapFromData (XtDisplay(xtw),
X RootWindowOfScreen(XtScreen(xtw)),
X check_bits, check_width, check_height);
X }
X
X m = XtCreatePopupShell (name, simpleMenuWidgetClass, toplevel, NULL, 0);
X
X for (; nentries > 0; nentries--, entries++) {
X cb[0].callback = (XtCallbackProc) entries->function;
X cb[0].closure = (caddr_t) entries->name;
X entries->widget = XtCreateManagedWidget (entries->name,
X (entries->function ?
X smeBSBObjectClass :
X smeLineObjectClass), m,
X &arg, (Cardinal) 1);
X }
X
X /* do not realize at this point */
X return m;
X}
X
Xstatic void handle_send_signal (gw, sig)
X Widget gw;
X int sig;
X{
X register TScreen *screen = &term->screen;
X
X if (screen->pid > 1) killpg (screen->pid, sig);
X}
X
X
X/*
X * action routines
X */
X
Xvoid DoSecureKeyboard (time)
X Time time;
X{
X do_securekbd (term->screen.mainMenu, NULL, NULL);
X}
X
Xstatic void do_securekbd (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X register TScreen *screen = &term->screen;
X Time time = CurrentTime; /* XXX - wrong */
X
X if (screen->grabbedKbd) {
X XUngrabKeyboard (screen->display, time);
X ReverseVideo (term);
X screen->grabbedKbd = FALSE;
X } else {
X if (XGrabKeyboard (screen->display, term->core.parent->core.window,
X True, GrabModeAsync, GrabModeAsync, time)
X != GrabSuccess) {
X XBell (screen->display, 100);
X } else {
X ReverseVideo (term);
X screen->grabbedKbd = TRUE;
X }
X }
X update_securekbd();
X}
X
X
Xstatic void do_allowsends (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X register TScreen *screen = &term->screen;
X
X screen->allowSendEvents = !screen->allowSendEvents;
X update_allowsends ();
X}
X
X
Xstatic void do_visualbell (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X register TScreen *screen = &term->screen;
X
X screen->visualbell = !screen->visualbell;
X update_visualbell();
X}
X
X
Xstatic void do_logging (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X register TScreen *screen = &term->screen;
X
X if (screen->logging) {
X CloseLog (screen);
X } else {
X StartLog (screen);
X }
X /* update_logging done by CloseLog and StartLog */
X}
X
X
Xstatic void do_redraw (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X Redraw ();
X}
X
X
X/*
X * The following cases use the pid instead of the process group so that we
X * don't get hosed by programs that change their process group
X */
X
X
Xstatic void do_suspend (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X#ifdef SIGTSTP
X handle_send_signal (gw, SIGTSTP);
X#endif
X}
X
X
Xstatic void do_continue (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X#ifdef SIGCONT
X handle_send_signal (gw, SIGCONT);
X#endif
X}
X
X
Xstatic void do_interrupt (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X handle_send_signal (gw, SIGINT);
X}
X
X
Xstatic void do_hangup (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X handle_send_signal (gw, SIGHUP);
X}
X
X
Xstatic void do_terminate (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X handle_send_signal (gw, SIGTERM);
X}
X
X
Xstatic void do_kill (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X handle_send_signal (gw, SIGKILL);
X}
X
X
Xstatic void do_quit (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X Cleanup (0);
X}
X
X
X
X/*
X * vt menu callbacks
X */
X
Xstatic void do_scrollbar (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X register TScreen *screen = &term->screen;
X
X if (screen->scrollbar) {
X ScrollBarOff (screen);
X } else {
X ScrollBarOn (term, FALSE, FALSE);
X }
X update_scrollbar();
X}
X
X
Xstatic void do_jumpscroll (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X register TScreen *screen = &term->screen;
X
X term->flags ^= SMOOTHSCROLL;
X if (term->flags & SMOOTHSCROLL) {
X screen->jumpscroll = FALSE;
X if (screen->scroll_amt) FlushScroll(screen);
X } else {
X screen->jumpscroll = TRUE;
X }
X update_jumpscroll();
X}
X
X
Xstatic void do_bltscroll (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X register TScreen *screen = &term->screen;
X
X screen->bltscroll = !screen->bltscroll;
X update_bltscroll();
X}
X
X
Xstatic void do_reversevideo (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X term->flags ^= REVERSE_VIDEO;
X ReverseVideo (term);
X /* update_reversevideo done in ReverseVideo */
X}
X
X
Xstatic void do_autowrap (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X term->flags ^= WRAPAROUND;
X update_autowrap();
X}
X
X
Xstatic void do_reversewrap (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X term->flags ^= REVERSEWRAP;
X update_reversewrap();
X}
X
X
Xstatic void do_autolinefeed (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X term->flags ^= LINEFEED;
X update_autolinefeed();
X}
X
X
Xstatic void do_appcursor (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X term->keyboard.flags ^= CURSOR_APL;
X update_appcursor();
X}
X
X
Xstatic void do_appkeypad (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X term->keyboard.flags ^= KYPD_APL;
X update_appkeypad();
X}
X
X
Xstatic void do_scrollkey (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X register TScreen *screen = &term->screen;
X
X screen->scrollkey = !screen->scrollkey;
X update_scrollkey();
X}
X
X
Xstatic void do_scrollttyoutput (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X register TScreen *screen = &term->screen;
X
X screen->scrollttyoutput = !screen->scrollttyoutput;
X update_scrollttyoutput();
X}
X
X
Xstatic void do_allow132 (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X register TScreen *screen = &term->screen;
X
X screen->c132 = !screen->c132;
X update_allow132();
X}
X
X
Xstatic void do_cursesemul (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X register TScreen *screen = &term->screen;
X
X screen->curses = !screen->curses;
X update_cursesemul();
X}
X
X
Xstatic void do_marginbell (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X register TScreen *screen = &term->screen;
X
X if (!(screen->marginbell = !screen->marginbell)) screen->bellarmed = -1;
X update_marginbell();
X}
X
X
Xstatic void handle_tekshow (gw, allowswitch)
X Widget gw;
X Bool allowswitch;
X{
X register TScreen *screen = &term->screen;
X
X if (!screen->Tshow) { /* not showing, turn on */
X set_tek_visibility (TRUE);
X } else if (screen->Vshow || allowswitch) { /* is showing, turn off */
X set_tek_visibility (FALSE);
X end_tek_mode (); /* WARNING: this does a longjmp */
X } else
X Bell();
X}
X
X
Xstatic void do_tekshow (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X handle_tekshow (gw, True);
X}
X
X
Xstatic void do_tekonoff (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X handle_tekshow (gw, False);
X}
X
X
Xstatic void do_altscreen (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X /* do nothing for now; eventually, will want to flip screen */
X}
X
X
Xstatic void do_softreset (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X VTReset (FALSE);
X}
X
X
Xstatic void do_hardreset (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X VTReset (TRUE);
X}
X
X
Xstatic void switch_modes (tovt)
X Bool tovt; /* if true, then become vt mode */
X{
X if (tovt) {
X if (TekRefresh) dorefresh();
X end_tek_mode (); /* WARNING: this does a longjmp... */
X } else {
X end_vt_mode (); /* WARNING: this does a longjmp... */
X }
X}
X
X
Xstatic void do_tekmode (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X register TScreen *screen = &term->screen;
X
X switch_modes (screen->TekEmu); /* switch to tek mode */
X}
X
Xstatic void do_vthide (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X register TScreen *screen = &term->screen;
X
X set_vt_visibility (FALSE);
X if (!screen->TekEmu) switch_modes (False); /* switch to tek mode */
X}
X
X
X/*
X * vtfont menu
X */
X
Xstatic void do_vtfont (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X char *entryname = (char *) closure;
X int i;
X
X for (i = 0; i < NMENUFONTS; i++) {
X if (strcmp (entryname, fontMenuEntries[i].name) == 0) {
X SetVTFont (i, True, NULL, NULL);
X return;
X }
X }
X Bell();
X}
X
X
X/*
X * tek menu
X */
X
Xstatic void do_tektextlarge (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X TekSetFontSize (gw, tekMenu_tektextlarge);
X}
X
X
Xstatic void do_tektext2 (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X TekSetFontSize (gw, tekMenu_tektext2);
X}
X
X
Xstatic void do_tektext3 (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X TekSetFontSize (gw, tekMenu_tektext3);
X}
X
X
Xstatic void do_tektextsmall (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X
X TekSetFontSize (gw, tekMenu_tektextsmall);
X}
X
X
Xstatic void do_tekpage (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X TekSimulatePageButton (False);
X}
X
X
Xstatic void do_tekreset (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X TekSimulatePageButton (True);
X}
X
X
Xstatic void do_tekcopy (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X TekCopy ();
X}
X
X
Xstatic void handle_vtshow (gw, allowswitch)
X Widget gw;
X Bool allowswitch;
X{
X register TScreen *screen = &term->screen;
X
X if (!screen->Vshow) { /* not showing, turn on */
X set_vt_visibility (TRUE);
X } else if (screen->Tshow || allowswitch) { /* is showing, turn off */
X set_vt_visibility (FALSE);
X if (!screen->TekEmu && TekRefresh) dorefresh ();
X end_vt_mode ();
X } else
X Bell();
X}
X
Xstatic void do_vtshow (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X handle_vtshow (gw, True);
X}
X
Xstatic void do_vtonoff (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X handle_vtshow (gw, False);
X}
X
Xstatic void do_vtmode (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X register TScreen *screen = &term->screen;
X
X switch_modes (screen->TekEmu); /* switch to vt, or from */
X}
X
X
Xstatic void do_tekhide (gw, closure, data)
X Widget gw;
X caddr_t closure, data;
X{
X register TScreen *screen = &term->screen;
X
X set_tek_visibility (FALSE);
X TekRefresh = (TekLink *)0;
X if (screen->TekEmu) switch_modes (True); /* does longjmp to vt mode */
X}
X
X
X
X/*
X * public handler routines
X */
X
Xstatic void handle_toggle (proc, var, params, nparams, w, closure, data)
X void (*proc)();
X int var;
X String *params;
X Cardinal nparams;
X Widget w;
X caddr_t closure, data;
X{
X int dir = -2;
X
X switch (nparams) {
X case 0:
X dir = -1;
X case 1:
X if (XmuCompareISOLatin1 (params[0], "on") == 0) dir = 1;
X else if (XmuCompareISOLatin1 (params[0], "off") == 0) dir = 0;
X else if (XmuCompareISOLatin1 (params[0], "toggle") == 0) dir = -1;
X }
X
X switch (dir) {
X case -2:
X Bell();
X break;
X
X case -1:
X (*proc) (w, closure, data);
X break;
X
X case 0:
X if (var) (*proc) (w, closure, data);
X else Bell();
X break;
X
X case 1:
X if (!var) (*proc) (w, closure, data);
X else Bell();
X break;
X }
X return;
X}
X
Xvoid HandleAllowSends(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X handle_toggle (do_allowsends, (int) term->screen.allowSendEvents,
X params, *param_count, w, NULL, NULL);
X}
X
Xvoid HandleVisualBell(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X handle_toggle (do_visualbell, (int) term->screen.visualbell,
X params, *param_count, w, NULL, NULL);
X}
X
Xvoid HandleLogging(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X handle_toggle (do_logging, (int) term->screen.logging,
X params, *param_count, w, NULL, NULL);
X}
X
Xvoid HandleRedraw(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X do_redraw(w, NULL, NULL);
X}
X
Xvoid HandleSendSignal(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X static struct sigtab {
X char *name;
X int sig;
X } signals[] = {
X#ifdef SIGTSTP
X { "suspend", SIGTSTP },
X { "tstp", SIGTSTP },
X#endif
X#ifdef SIGCONT
X { "cont", SIGCONT },
X#endif
X { "int", SIGINT },
X { "hup", SIGHUP },
X { "term", SIGTERM },
X { "kill", SIGKILL },
X { NULL, 0 },
X };
X
X if (*param_count == 1) {
X struct sigtab *st;
X
X for (st = signals; st->name; st++) {
X if (XmuCompareISOLatin1 (st->name, params[0]) == 0) {
X handle_send_signal (w, st->sig);
X return;
X }
X }
X /* one could allow numeric values, but that would be a security hole */
X }
X
X Bell();
X}
X
Xvoid HandleQuit(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X do_quit(w, NULL, NULL);
X}
X
Xvoid HandleScrollbar(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X handle_toggle (do_scrollbar, (int) term->screen.scrollbar,
X params, *param_count, w, NULL, NULL);
X}
X
Xvoid HandleJumpscroll(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X handle_toggle (do_jumpscroll, (int) term->screen.jumpscroll,
X params, *param_count, w, NULL, NULL);
X}
X
Xvoid HandleBltscroll(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X handle_toggle (do_bltscroll, (int) term->screen.bltscroll,
X params, *param_count, w, NULL, NULL);
X}
X
Xvoid HandleReverseVideo(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X handle_toggle (do_reversevideo, (int) (term->flags & REVERSE_VIDEO),
X params, *param_count, w, NULL, NULL);
X}
X
Xvoid HandleAutoWrap(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X handle_toggle (do_autowrap, (int) (term->flags & WRAPAROUND),
X params, *param_count, w, NULL, NULL);
X}
X
Xvoid HandleReverseWrap(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X handle_toggle (do_reversewrap, (int) (term->flags & REVERSEWRAP),
X params, *param_count, w, NULL, NULL);
X}
X
Xvoid HandleAutoLineFeed(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X handle_toggle (do_autolinefeed, (int) (term->flags & LINEFEED),
X params, *param_count, w, NULL, NULL);
X}
X
Xvoid HandleAppCursor(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X handle_toggle (do_appcursor, (int) (term->keyboard.flags & CURSOR_APL),
X params, *param_count, w, NULL, NULL);
X}
X
Xvoid HandleAppKeypad(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X handle_toggle (do_appkeypad, (int) (term->keyboard.flags & KYPD_APL),
X params, *param_count, w, NULL, NULL);
X}
X
Xvoid HandleScrollKey(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X handle_toggle (do_scrollkey, (int) term->screen.scrollkey,
X params, *param_count, w, NULL, NULL);
X}
X
Xvoid HandleScrollTtyOutput(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X handle_toggle (do_scrollttyoutput, (int) term->screen.scrollttyoutput,
X params, *param_count, w, NULL, NULL);
X}
X
Xvoid HandleAllow132(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X handle_toggle (do_allow132, (int) term->screen.c132,
X params, *param_count, w, NULL, NULL);
X}
X
Xvoid HandleCursesEmul(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X handle_toggle (do_cursesemul, (int) term->screen.curses,
X params, *param_count, w, NULL, NULL);
X}
X
Xvoid HandleMarginBell(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X handle_toggle (do_marginbell, (int) term->screen.marginbell,
X params, *param_count, w, NULL, NULL);
X}
X
Xvoid HandleAltScreen(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X /* eventually want to see if sensitive or not */
X handle_toggle (do_altscreen, (int) term->screen.alternate,
X params, *param_count, w, NULL, NULL);
X}
X
Xvoid HandleSoftReset(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X do_softreset(w, NULL, NULL);
X}
X
Xvoid HandleHardReset(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X do_hardreset(w, NULL, NULL);
X}
X
Xvoid HandleSetTerminalType(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X if (*param_count == 1) {
X switch (params[0][0]) {
X case 'v': case 'V':
X if (term->screen.TekEmu) do_vtmode (w, NULL, NULL);
X break;
X case 't': case 'T':
X if (!term->screen.TekEmu) do_tekmode (w, NULL, NULL);
X break;
X default:
X Bell();
X }
X } else {
X Bell();
X }
X}
X
Xvoid HandleVisibility(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X if (*param_count == 2) {
X switch (params[0][0]) {
X case 'v': case 'V':
X handle_toggle (do_vtonoff, (int) term->screen.Vshow,
X params+1, (*param_count) - 1, w, NULL, NULL);
X break;
X case 't': case 'T':
X handle_toggle (do_tekonoff, (int) term->screen.Tshow,
X params+1, (*param_count) - 1, w, NULL, NULL);
X break;
X default:
X Bell();
X }
X } else {
X Bell();
X }
X}
X
Xvoid HandleSetTekText(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X void (*proc)() = NULL;
X
X switch (*param_count) {
X case 0:
X proc = do_tektextlarge;
X break;
X case 1:
X switch (params[0][0]) {
X case 'l': case 'L': proc = do_tektextlarge; break;
X case '2': proc = do_tektext2; break;
X case '3': proc = do_tektext3; break;
X case 's': case 'S': proc = do_tektextsmall; break;
X }
X break;
X }
X if (proc) (*proc) (w, NULL, NULL);
X else Bell();
X}
X
Xvoid HandleTekPage(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X do_tekpage(w, NULL, NULL);
X}
X
Xvoid HandleTekReset(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X do_tekreset(w, NULL, NULL);
X}
X
Xvoid HandleTekCopy(w, event, params, param_count)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *param_count;
X{
X do_tekcopy(w, NULL, NULL);
X}
X
X
END_OF_FILE
if test 27111 -ne `wc -c <'xterm/menu.c'`; then
echo shar: \"'xterm/menu.c'\" unpacked with wrong size!
fi
# end of 'xterm/menu.c'
fi
if test -f 'xterm/misc.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'xterm/misc.c'\"
else
echo shar: Extracting \"'xterm/misc.c'\" \(24024 characters\)
sed "s/^X//" >'xterm/misc.c' <<'END_OF_FILE'
X/*
X * $XConsortium: misc.c,v 1.66 90/04/30 16:53:26 converse Exp $
X */
X
X
X#include <X11/copyright.h>
X
X/*
X * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
X *
X * All Rights Reserved
X *
X * Permission to use, copy, modify, and distribute this software and its
X * documentation for any purpose and without fee is hereby granted,
X * provided that the above copyright notice appear in all copies and that
X * both that copyright notice and this permission notice appear in
X * supporting documentation, and that the name of Digital Equipment
X * Corporation not be used in advertising or publicity pertaining to
X * distribution of the software without specific, written prior permission.
X *
X *
X * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
X * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
X * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
X * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
X * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
X * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
X * SOFTWARE.
X */
X
X#include "ptyx.h" /* X headers included here. */
X
X#include <stdio.h>
X#include <X11/Xos.h>
X#include <setjmp.h>
X#include <ctype.h>
X#include <pwd.h>
X
X#include <X11/Xatom.h>
X#include <X11/cursorfont.h>
X
X#include <X11/Shell.h>
X#include <X11/Xmu/Error.h>
X#include <X11/Xmu/SysUtil.h>
X#include <X11/Xmu/WinUtil.h>
X
X#include "data.h"
X#include "error.h"
X#include "menu.h"
X
Xextern char *malloc();
Xextern char *mktemp();
Xextern void exit();
Xextern void perror();
Xextern void abort();
X
Xstatic void DoSpecialEnterNotify();
Xstatic void DoSpecialLeaveNotify();
X
X#ifndef lint
Xstatic char rcs_id[] = "$XConsortium: misc.c,v 1.66 90/04/30 16:53:26 converse Exp $";
X#endif /* lint */
X
Xxevents()
X{
X XEvent event;
X register TScreen *screen = &term->screen;
X
X if(screen->scroll_amt)
X FlushScroll(screen);
X XPending (screen->display);
X do {
X if (waitingForTrackInfo)
X return;
X XNextEvent (screen->display, &event);
X /*
X * Hack to get around problems with the toolkit throwing away
X * eventing during the exclusive grab of the menu popup. By
X * looking at the event ourselves we make sure that we can
X * do the right thing.
X */
X if (event.type == EnterNotify &&
X (event.xcrossing.window == XtWindow(XtParent(term))) ||
X (tekWidget &&
X event.xcrossing.window == XtWindow(XtParent(tekWidget))))
X DoSpecialEnterNotify (&event);
X else
X if (event.type == LeaveNotify &&
X (event.xcrossing.window == XtWindow(XtParent(term))) ||
X (tekWidget &&
X event.xcrossing.window == XtWindow(XtParent(tekWidget))))
X DoSpecialLeaveNotify (&event);
X
X if (!event.xany.send_event ||
X screen->allowSendEvents ||
X ((event.xany.type != KeyPress) &&
X (event.xany.type != KeyRelease) &&
X (event.xany.type != ButtonPress) &&
X (event.xany.type != ButtonRelease)))
X XtDispatchEvent(&event);
X } while (QLength(screen->display) > 0);
X}
X
X
XCursor make_colored_cursor (cursorindex, fg, bg)
X int cursorindex; /* index into font */
X unsigned long fg, bg; /* pixel value */
X{
X register TScreen *screen = &term->screen;
X Cursor c;
X register Display *dpy = screen->display;
X
X c = XCreateFontCursor (dpy, cursorindex);
X if (c == (Cursor) 0) return (c);
X
X recolor_cursor (c, fg, bg);
X return (c);
X}
X
X/* ARGSUSED */
Xvoid HandleKeyPressed(w, event, params, nparams)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *nparams;
X{
X register TScreen *screen = &term->screen;
X
X#ifdef ACTIVEWINDOWINPUTONLY
X if (w == (screen->TekEmu ? (Widget)tekWidget : (Widget)term))
X#endif
X Input (&term->keyboard, screen, event, False);
X}
X/* ARGSUSED */
Xvoid HandleEightBitKeyPressed(w, event, params, nparams)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *nparams;
X{
X register TScreen *screen = &term->screen;
X
X#ifdef ACTIVEWINDOWINPUTONLY
X if (w == (screen->TekEmu ? (Widget)tekWidget : (Widget)term))
X#endif
X Input (&term->keyboard, screen, event, True);
X}
X
X/* ARGSUSED */
Xvoid HandleStringEvent(w, event, params, nparams)
X Widget w;
X XEvent *event;
X String *params;
X Cardinal *nparams;
X{
X register TScreen *screen = &term->screen;
X
X#ifdef ACTIVEWINDOWINPUTONLY
X if (w != (screen->TekEmu ? (Widget)tekWidget : (Widget)term)) return;
X#endif
X
X if (*nparams != 1) return;
X
X if ((*params)[0] == '0' && (*params)[1] == 'x' && (*params)[2] != '\0') {
X char c, *p, hexval[2];
X hexval[0] = hexval[1] = 0;
X for (p = *params+2; (c = *p); p++) {
X hexval[0] *= 16;
X if (isupper(c)) c = tolower(c);
X if (c >= '0' && c <= '9')
X hexval[0] += c - '0';
X else if (c >= 'a' && c <= 'f')
X hexval[0] += c - 'a' + 10;
X else break;
X }
X if (c == '\0')
X StringInput (screen, hexval);
X }
X else {
X StringInput (screen, *params);
X }
X}
X
Xstatic void DoSpecialEnterNotify (ev)
X register XEnterWindowEvent *ev;
X{
X register TScreen *screen = &term->screen;
X
X#ifdef ACTIVEWINDOWINPUTONLY
X if (ev->window == XtWindow(XtParent(screen->TekEmu ?
X (Widget)tekWidget : (Widget)term)))
X#endif
X if (((ev->detail) != NotifyInferior) &&
X ev->focus &&
X !(screen->select & FOCUS))
X selectwindow(screen, INWINDOW);
X}
X
X/*ARGSUSED*/
Xvoid HandleEnterWindow(w, eventdata, event)
XWidget w;
Xregister XEnterWindowEvent *event;
Xcaddr_t eventdata;
X{
X /* NOP since we handled it above */
X}
X
X
Xstatic void DoSpecialLeaveNotify (ev)
X register XEnterWindowEvent *ev;
X{
X register TScreen *screen = &term->screen;
X
X#ifdef ACTIVEWINDOWINPUTONLY
X if (ev->window == XtWindow(XtParent(screen->TekEmu ?
X (Widget)tekWidget : (Widget)term)))
X#endif
X if (((ev->detail) != NotifyInferior) &&
X ev->focus &&
X !(screen->select & FOCUS))
X unselectwindow(screen, INWINDOW);
X}
X
X
X/*ARGSUSED*/
Xvoid HandleLeaveWindow(w, eventdata, event)
XWidget w;
Xregister XEnterWindowEvent *event;
Xcaddr_t eventdata;
X{
X /* NOP since we handled it above */
X}
X
X
X/*ARGSUSED*/
Xvoid HandleFocusChange(w, eventdata, event)
XWidget w;
Xregister XFocusChangeEvent *event;
Xcaddr_t eventdata;
X{
X register TScreen *screen = &term->screen;
X
X if(event->type == FocusIn)
X selectwindow(screen,
X (event->detail == NotifyPointer) ? INWINDOW :
X FOCUS);
X else {
X unselectwindow(screen,
X (event->detail == NotifyPointer) ? INWINDOW :
X FOCUS);
X if (screen->grabbedKbd && (event->mode == NotifyUngrab)) {
X screen->grabbedKbd = FALSE;
X ReverseVideo(term);
X XBell(screen->display, 100);
X }
X }
X}
X
X
X
Xselectwindow(screen, flag)
Xregister TScreen *screen;
Xregister int flag;
X{
X if(screen->TekEmu) {
X if(!Ttoggled)
X TCursorToggle(TOGGLE);
X screen->select |= flag;
X if(!Ttoggled)
X TCursorToggle(TOGGLE);
X return;
X } else {
X if(screen->cursor_state &&
X (screen->cursor_col != screen->cur_col ||
X screen->cursor_row != screen->cur_row))
X HideCursor();
X screen->select |= flag;
X if(screen->cursor_state)
X ShowCursor();
X return;
X }
X}
X
Xunselectwindow(screen, flag)
Xregister TScreen *screen;
Xregister int flag;
X{
X if (screen->always_highlight) return;
X
X if(screen->TekEmu) {
X if(!Ttoggled) TCursorToggle(TOGGLE);
X screen->select &= ~flag;
X if(!Ttoggled) TCursorToggle(TOGGLE);
X } else {
X screen->select &= ~flag;
X if(screen->cursor_state &&
X (screen->cursor_col != screen->cur_col ||
X screen->cursor_row != screen->cur_row))
X HideCursor();
X if(screen->cursor_state)
X ShowCursor();
X }
X}
X
X
XBell()
X{
X extern XtermWidget term;
X register TScreen *screen = &term->screen;
X register Pixel xorPixel = screen->foreground ^ term->core.background_pixel;
X XGCValues gcval;
X GC visualGC;
X
X if(screen->visualbell) {
X gcval.function = GXxor;
X gcval.foreground = xorPixel;
X visualGC = XtGetGC((Widget)term, GCFunction+GCForeground, &gcval);
X if(screen->TekEmu) {
X XFillRectangle(
X screen->display,
X TWindow(screen),
X visualGC,
X 0, 0,
X (unsigned) TFullWidth(screen),
X (unsigned) TFullHeight(screen));
X XFlush(screen->display);
X XFillRectangle(
X screen->display,
X TWindow(screen),
X visualGC,
X 0, 0,
X (unsigned) TFullWidth(screen),
X (unsigned) TFullHeight(screen));
X } else {
X XFillRectangle(
X screen->display,
X VWindow(screen),
X visualGC,
X 0, 0,
X (unsigned) FullWidth(screen),
X (unsigned) FullHeight(screen));
X XFlush(screen->display);
X XFillRectangle(
X screen->display,
X VWindow(screen),
X visualGC,
X 0, 0,
X (unsigned) FullWidth(screen),
X (unsigned) FullHeight(screen));
X }
X } else
X XBell(screen->display, 0);
X}
X
XRedraw()
X{
X extern XtermWidget term;
X register TScreen *screen = &term->screen;
X XExposeEvent event;
X
X event.type = Expose;
X event.display = screen->display;
X event.x = 0;
X event.y = 0;
X event.count = 0;
X
X if(VWindow(screen)) {
X event.window = VWindow(screen);
X event.width = term->core.width;
X event.height = term->core.height;
X (*term->core.widget_class->core_class.expose)((Widget)term, (XEvent *)&event, NULL);
X if(screen->scrollbar)
X (*screen->scrollWidget->core.widget_class->core_class.expose)(screen->scrollWidget, (XEvent *)&event, NULL);
X }
X
X if(TWindow(screen) && screen->Tshow) {
X event.window = TWindow(screen);
X event.width = tekWidget->core.width;
X event.height = tekWidget->core.height;
X TekExpose (tekWidget, &event, NULL);
X }
X}
X
XStartLog(screen)
Xregister TScreen *screen;
X{
X register char *cp;
X register int i;
X static char *log_default;
X char *malloc(), *rindex();
X#ifdef ALLOWLOGFILEEXEC
X void logpipe();
X#ifdef SYSV
X /* SYSV has another pointer which should be part of the
X ** FILE structure but is actually a separate array.
X */
X unsigned char *old_bufend;
X#endif /* SYSV */
X#endif /* ALLOWLOGFILEEXEC */
X
X if(screen->logging || (screen->inhibit & I_LOG))
X return;
X if(screen->logfile == NULL || *screen->logfile == 0) {
X if(screen->logfile)
X free(screen->logfile);
X if(log_default == NULL)
X mktemp(log_default = log_def_name);
X if((screen->logfile = malloc((unsigned)strlen(log_default) + 1)) == NULL)
X return;
X strcpy(screen->logfile, log_default);
X }
X if(*screen->logfile == '|') { /* exec command */
X#ifdef ALLOWLOGFILEEXEC
X /*
X * Warning, enabling this "feature" allows arbitrary programs
X * to be run. If ALLOWLOGFILECHANGES is enabled, this can be
X * done through escape sequences.... You have been warned.
X */
X int p[2];
X static char *shell;
X
X if(pipe(p) < 0 || (i = fork()) < 0)
X return;
X if(i == 0) { /* child */
X close(p[1]);
X dup2(p[0], 0);
X close(p[0]);
X dup2(fileno(stderr), 1);
X dup2(fileno(stderr), 2);
X#ifdef SYSV
X old_bufend = _bufend(stderr);
X#endif /* SYSV */
X close(fileno(stderr));
X fileno(stderr) = 2;
X#ifdef SYSV
X _bufend(stderr) = old_bufend;
X#endif /* SYSV */
X close(screen->display->fd);
X close(screen->respond);
X if(!shell) {
X register struct passwd *pw;
X char *getenv(), *malloc();
X struct passwd *getpwuid();
X
X if(((cp = getenv("SHELL")) == NULL || *cp == 0)
X && ((pw = getpwuid(screen->uid)) == NULL ||
X *(cp = pw->pw_shell) == 0) ||
X (shell = malloc((unsigned) strlen(cp) + 1)) == NULL)
X shell = "/bin/sh";
X else
X strcpy(shell, cp);
X }
X signal(SIGHUP, SIG_DFL);
X signal(SIGCHLD, SIG_DFL);
X setgid(screen->gid);
X setuid(screen->uid);
X execl(shell, shell, "-c", &screen->logfile[1], 0);
X fprintf(stderr, "%s: Can't exec `%s'\n", xterm_name,
X &screen->logfile[1]);
X exit(ERROR_LOGEXEC);
X }
X close(p[0]);
X screen->logfd = p[1];
X signal(SIGPIPE, logpipe);
X#else
X Bell();
X Bell();
X return;
X#endif
X } else {
X if(access(screen->logfile, F_OK) == 0) {
X if(access(screen->logfile, W_OK) < 0)
X return;
X } else if(cp = rindex(screen->logfile, '/')) {
X *cp = 0;
X i = access(screen->logfile, W_OK);
X *cp = '/';
X if(i < 0)
X return;
X } else if(access(".", W_OK) < 0)
X return;
X if((screen->logfd = open(screen->logfile, O_WRONLY | O_APPEND |
X O_CREAT, 0644)) < 0)
X return;
X chown(screen->logfile, screen->uid, screen->gid);
X
X }
X screen->logstart = screen->TekEmu ? Tbptr : bptr;
X screen->logging = TRUE;
X update_logging();
X}
X
XCloseLog(screen)
Xregister TScreen *screen;
X{
X if(!screen->logging || (screen->inhibit & I_LOG))
X return;
X FlushLog(screen);
X close(screen->logfd);
X screen->logging = FALSE;
X update_logging();
X}
X
XFlushLog(screen)
Xregister TScreen *screen;
X{
X register Char *cp;
X register int i;
X
X cp = screen->TekEmu ? Tbptr : bptr;
X if((i = cp - screen->logstart) > 0)
X write(screen->logfd, screen->logstart, i);
X screen->logstart = screen->TekEmu ? Tbuffer : buffer;
X}
X
X#ifdef ALLOWLOGFILEEXEC
Xvoid logpipe()
X{
X register TScreen *screen = &term->screen;
X
X#ifdef SYSV
X (void) signal(SIGPIPE, SIG_IGN);
X#endif /* SYSV */
X if(screen->logging)
X CloseLog(screen);
X}
X#endif /* ALLOWLOGFILEEXEC */
X
X
Xdo_osc(func)
Xint (*func)();
X{
X register TScreen *screen = &term->screen;
X register int mode, c;
X register char *cp;
X char buf[512];
X char *bufend = &buf[(sizeof buf) - 1]; /* leave room for null */
X extern char *malloc();
X Bool okay = True;
X
X /*
X * lines should be of the form <ESC> ] number ; string <BEL>
X *
X * where number is one of 0, 1, 2, or 46
X */
X mode = 0;
X while(isdigit(c = (*func)()))
X mode = 10 * mode + (c - '0');
X if (c != ';') okay = False;
X cp = buf;
X while(isprint((c = (*func)()) & 0x7f) && cp < bufend)
X *cp++ = c;
X if (c != 7) okay = False;
X *cp = 0;
X if (okay) switch(mode) {
X case 0: /* new icon name and title*/
X Changename(buf);
X Changetitle(buf);
X break;
X
X case 1: /* new icon name only */
X Changename(buf);
X break;
X
X case 2: /* new title only */
X Changetitle(buf);
X break;
X case 10: case 11: case 12:
X case 13: case 14: case 15:
X case 16:
X {
X extern Boolean ChangeColorsRequest();
X if (term->misc.dynamicColors)
X ChangeColorsRequest(term,mode-10,buf);
X }
X break;
X
X case 46: /* new log file */
X#ifdef ALLOWLOGFILECHANGES
X /*
X * Warning, enabling this feature allows people to overwrite
X * arbitrary files accessible to the person running xterm.
X */
X if((cp = malloc((unsigned)strlen(buf) + 1)) == NULL)
X break;
X strcpy(cp, buf);
X if(screen->logfile)
X free(screen->logfile);
X screen->logfile = cp;
X#else
X Bell();
X Bell();
X#endif
X break;
X
X case 50:
X SetVTFont (fontMenu_fontescape, True, buf, NULL);
X break;
X
X /*
X * One could write code to send back the display and host names,
X * but that could potentially open a fairly nasty security hole.
X */
X }
X}
X
Xstatic ChangeGroup(attribute, value)
X String attribute;
X XtArgVal value;
X{
X extern Widget toplevel;
X Arg args[1];
X
X XtSetArg( args[0], attribute, value );
X XtSetValues( toplevel, args, 1 );
X}
X
XChangename(name)
Xregister char *name;
X{
X ChangeGroup( XtNiconName, (XtArgVal)name );
X}
X
XChangetitle(name)
Xregister char *name;
X{
X ChangeGroup( XtNtitle, (XtArgVal)name );
X}
X
X/***====================================================================***/
X
XScrnColors *pOldColors= NULL;
X
XBoolean
XGetOldColors(pTerm)
XXtermWidget pTerm;
X{
Xint i;
X if (pOldColors==NULL) {
X pOldColors= (ScrnColors *)XtMalloc(sizeof(ScrnColors));
X if (pOldColors==NULL) {
X fprintf(stderr,"allocation failure in GetOldColors\n");
X return(FALSE);
X }
X pOldColors->which= 0;
X for (i=0;i<NCOLORS;i++) {
X pOldColors->colors[i]= 0;
X pOldColors->names[i]= NULL;
X }
X GetColors(pTerm,pOldColors);
X }
X return(TRUE);
X}
X
XBoolean
XUpdateOldColors(pTerm,pNew)
XXtermWidget pTerm;
XScrnColors *pNew;
X{
Xint i;
X
X /* if we were going to free old colors, this would be the place to
X * do it. I've decided not to (for now), because it seems likely
X * that we'd have a small set of colors we use over and over, and that
X * we could save some overhead this way. The only case in which this
X * (clearly) fails is if someone is trying a boatload of colors, in
X * which case they can restart xterm
X */
X for (i=0;i<NCOLORS;i++) {
X if (COLOR_DEFINED(pNew,i)) {
X if (pOldColors->names[i]!=NULL) {
X XtFree(pOldColors->names[i]);
X pOldColors->names[i]= NULL;
X }
X if (pNew->names[i]) {
X pOldColors->names[i]= pNew->names[i];
X }
X pOldColors->colors[i]= pNew->colors[i];
X }
X }
X return(TRUE);
X}
X
Xvoid
XReverseOldColors()
X{
Xregister ScrnColors *pOld= pOldColors;
XPixel tmpPix;
Xchar *tmpName;
X
X if (pOld) {
X /* change text cursor, if necesary */
X if (pOld->colors[TEXT_CURSOR]==pOld->colors[TEXT_FG]) {
X pOld->colors[TEXT_CURSOR]= pOld->colors[TEXT_BG];
X if (pOld->names[TEXT_CURSOR]) {
X XtFree(pOldColors->names[TEXT_CURSOR]);
X pOld->names[TEXT_CURSOR]= NULL;
X }
X if (pOld->names[TEXT_BG]) {
X tmpName= XtMalloc(strlen(pOld->names[TEXT_BG])+1);
X if (tmpName) {
X strcpy(tmpName,pOld->names[TEXT_BG]);
X pOld->names[TEXT_CURSOR]= tmpName;
X }
X }
X }
X
X /* swap text FG and BG */
X tmpPix= pOld->colors[TEXT_FG];
X tmpName= pOld->names[TEXT_FG];
X pOld->colors[TEXT_FG]= pOld->colors[TEXT_BG];
X pOld->names[TEXT_FG]= pOld->names[TEXT_BG];
X pOld->colors[TEXT_BG]= tmpPix;
X pOld->names[TEXT_BG]= tmpName;
X
X /* swap mouse FG and BG */
X tmpPix= pOld->colors[MOUSE_FG];
X tmpName= pOld->names[MOUSE_FG];
X pOld->colors[MOUSE_FG]= pOld->colors[MOUSE_BG];
X pOld->names[MOUSE_FG]= pOld->names[MOUSE_BG];
X pOld->colors[MOUSE_BG]= tmpPix;
X pOld->names[MOUSE_BG]= tmpName;
X
X /* swap Tek FG and BG */
X tmpPix= pOld->colors[TEK_FG];
X tmpName= pOld->names[TEK_FG];
X pOld->colors[TEK_FG]= pOld->colors[TEK_BG];
X pOld->names[TEK_FG]= pOld->names[TEK_BG];
X pOld->colors[TEK_BG]= tmpPix;
X pOld->names[TEK_BG]= tmpName;
X }
X return;
X}
X
XBoolean
XAllocateColor(pTerm,pNew,ndx,name)
XXtermWidget pTerm;
XScrnColors *pNew;
Xint ndx;
Xchar *name;
X{
XXColor def;
Xregister TScreen *screen= &pTerm->screen;
XColormap cmap= pTerm->core.colormap;
Xchar *newName;
X
X if ((XParseColor(screen->display,cmap,name,&def))&&
X (XAllocColor(screen->display,cmap,&def))) {
X SET_COLOR_VALUE(pNew,ndx,def.pixel);
X newName= XtMalloc(strlen(name)+1);
X if (newName) {
X strcpy(newName,name);
X SET_COLOR_NAME(pNew,ndx,newName);
X }
X return(TRUE);
X }
X return(FALSE);
X}
X
XBoolean
XChangeColorsRequest(pTerm,start,names)
XXtermWidget pTerm;
Xint start;
Xregister char *names;
X{
Xchar *thisName;
XScrnColors newColors;
Xint i,ndx;
X
X if ((pOldColors==NULL)&&(!GetOldColors(pTerm))) {
X return(FALSE);
X }
X newColors.which= 0;
X for (i=0;i<NCOLORS;i++) {
X newColors.names[i]= NULL;
X }
X for (i=start;i<NCOLORS;i++) {
X if (term->misc.re_verse) ndx= OPPOSITE_COLOR(i);
X else ndx= i;
X if ((names==NULL)||(names[0]=='\0')) {
X newColors.names[ndx]= NULL;
X }
X else {
X if (names[0]==';')
X thisName= NULL;
X else thisName= names;
X names= index(names,';');
X if (names!=NULL) {
X *names= '\0';
X names++;
X }
X if ((!pOldColors->names[ndx])||
X (thisName&&(strcmp(thisName,pOldColors->names[ndx])))) {
X AllocateColor(pTerm,&newColors,ndx,thisName);
X }
X }
X }
X
X if (newColors.which==0)
X return(TRUE);
X
X ChangeColors(pTerm,&newColors);
X UpdateOldColors(pTerm,&newColors);
X return(TRUE);
X}
X
X/***====================================================================***/
X
X#ifndef DEBUG
X/* ARGSUSED */
X#endif
XPanic(s, a)
Xchar *s;
Xint a;
X{
X#ifdef DEBUG
X if(debug) {
X fprintf(stderr, "%s: PANIC! ", xterm_name);
X fprintf(stderr, s, a);
X fputs("\r\n", stderr);
X fflush(stderr);
X }
X#endif /* DEBUG */
X}
X
Xchar *SysErrorMsg (n)
X int n;
X{
X extern char *sys_errlist[];
X extern int sys_nerr;
X
X return ((n >= 0 && n < sys_nerr) ? sys_errlist[n] : "unknown error");
X}
X
X
XSysError (i)
Xint i;
X{
X int oerrno;
X
X oerrno = errno;
X /* perror(3) write(2)s to file descriptor 2 */
X fprintf (stderr, "%s: Error %d, errno %d: ", xterm_name, i, oerrno);
X fprintf (stderr, "%s\n", SysErrorMsg (oerrno));
X Cleanup(i);
X}
X
XError (i)
Xint i;
X{
X fprintf (stderr, "%s: Error %d\n", xterm_name, i);
X Cleanup(i);
X}
X
X
X/*
X * cleanup by sending SIGHUP to client processes
X */
XCleanup (code)
Xint code;
X{
X extern XtermWidget term;
X register TScreen *screen;
X
X screen = &term->screen;
X if (screen->pid > 1) {
X (void) killpg (screen->pid, SIGHUP);
X }
X Exit (code);
X}
X
X/*
X * sets the value of var to be arg in the Unix 4.2 BSD environment env.
X * Var should end with '=' (bindings are of the form "var=value").
X * This procedure assumes the memory for the first level of environ
X * was allocated using calloc, with enough extra room at the end so not
X * to have to do a realloc().
X */
XSetenv (var, value)
Xregister char *var, *value;
X{
X extern char **environ;
X register int index = 0;
X register int len = strlen(var);
X
X while (environ [index] != NULL) {
X if (strncmp (environ [index], var, len) == 0) {
X /* found it */
X environ[index] = (char *)malloc ((unsigned)len + strlen (value) + 1);
X strcpy (environ [index], var);
X strcat (environ [index], value);
X return;
X }
X index ++;
X }
X
X#ifdef DEBUG
X if (debug) fputs ("expanding env\n", stderr);
X#endif /* DEBUG */
X
X environ [index] = (char *) malloc ((unsigned)len + strlen (value) + 1);
X (void) strcpy (environ [index], var);
X strcat (environ [index], value);
X environ [++index] = NULL;
X}
X
X/*
X * returns a pointer to the first occurrence of s2 in s1,
X * or NULL if there are none.
X */
Xchar *strindex (s1, s2)
Xregister char *s1, *s2;
X{
X register char *s3;
X char *index();
X int s2len = strlen (s2);
X
X while ((s3=index(s1, *s2)) != NULL) {
X if (strncmp(s3, s2, s2len) == 0)
X return (s3);
X s1 = ++s3;
X }
X return (NULL);
X}
X
X/*ARGSUSED*/
Xxerror(d, ev)
XDisplay *d;
Xregister XErrorEvent *ev;
X{
X fprintf (stderr, "%s: warning, error event receieved:\n", xterm_name);
X (void) XmuPrintDefaultErrorMessage (d, ev, stderr);
X Exit (ERROR_XERROR);
X}
X
X/*ARGSUSED*/
Xxioerror(dpy)
XDisplay *dpy;
X{
X (void) fprintf (stderr,
X "%s: fatal IO error %d (%s) or KillClient on X server \"%s\"\r\n",
X xterm_name, errno, SysErrorMsg (errno),
X DisplayString (dpy));
X
X Exit(ERROR_XIOERROR);
X}
X
XXStrCmp(s1, s2)
Xchar *s1, *s2;
X{
X if (s1 && s2) return(strcmp(s1, s2));
X if (s1 && *s1) return(1);
X if (s2 && *s2) return(-1);
X return(0);
X}
X
Xstatic void withdraw_window (dpy, w, scr)
X Display *dpy;
X Window w;
X int scr;
X{
X (void) XmuUpdateMapHints (dpy, w, NULL);
X XWithdrawWindow (dpy, w, scr);
X return;
X}
X
X
Xvoid set_vt_visibility (on)
X Boolean on;
X{
X register TScreen *screen = &term->screen;
X
X if (on) {
X if (!screen->Vshow && term) {
X VTInit ();
X XtMapWidget (term->core.parent);
X screen->Vshow = TRUE;
X }
X } else {
X if (screen->Vshow && term) {
X withdraw_window (XtDisplay (term),
X XtWindow(XtParent(term)),
X XScreenNumberOfScreen(XtScreen(term)));
X screen->Vshow = FALSE;
X }
X }
X set_vthide_sensitivity();
X set_tekhide_sensitivity();
X update_vttekmode();
X update_tekshow();
X update_vtshow();
X return;
X}
X
Xvoid set_tek_visibility (on)
X Boolean on;
X{
X register TScreen *screen = &term->screen;
X
X if (on) {
X if (!screen->Tshow && (tekWidget || TekInit())) {
X XtRealizeWidget (tekWidget->core.parent);
X XtMapWidget (tekWidget->core.parent);
X screen->Tshow = TRUE;
X }
X } else {
X if (screen->Tshow && tekWidget) {
X withdraw_window (XtDisplay (tekWidget),
X XtWindow(XtParent(tekWidget)),
X XScreenNumberOfScreen(XtScreen(tekWidget)));
X screen->Tshow = FALSE;
X }
X }
X set_tekhide_sensitivity();
X set_vthide_sensitivity();
X update_vtshow();
X update_tekshow();
X update_vttekmode();
X return;
X}
X
Xvoid end_tek_mode ()
X{
X register TScreen *screen = &term->screen;
X
X if (screen->TekEmu) {
X if (screen->logging) {
X FlushLog (screen);
X screen->logstart = buffer;
X }
X longjmp(Tekend, 1);
X }
X return;
X}
X
Xvoid end_vt_mode ()
X{
X register TScreen *screen = &term->screen;
X
X if (!screen->TekEmu) {
X if(screen->logging) {
X FlushLog(screen);
X screen->logstart = Tbuffer;
X }
X screen->TekEmu = TRUE;
X longjmp(VTend, 1);
X }
X return;
X}
END_OF_FILE
if test 24024 -ne `wc -c <'xterm/misc.c'`; then
echo shar: \"'xterm/misc.c'\" unpacked with wrong size!
fi
# end of 'xterm/misc.c'
fi
if test -f 'xterm/termcap.bold' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'xterm/termcap.bold'\"
else
echo shar: Extracting \"'xterm/termcap.bold'\" \(510 characters\)
sed "s/^X//" >'xterm/termcap.bold' <<'END_OF_FILE'
Xvs|xterm|vs100:AL=\E[%dL:DC=\E[%dP:DL=\E[%dM:DO=\E[%dB:IC=\E[%d@:MT:UP=\E[%dA:al=\E[L:am:bs:cd=\E[J:ce=\E[K:cl=\E[H\E[2J:cm=\E[%i%d;%dH:co#80:cs=\E[%i%d;%dr:ct=\E[3k:dc=\E[P:dl=\E[M:do=^J:ei=\E[4l:ho=\E[H:im=\E[4h:is=\E[r\E[m\E[2J\E[H\E[?7h\E[?1;3;4;6l:k1=\EOP:k2=\EOQ:k3=\EOR:k4=\EOS:kb=^H:kd=\EOB:ke=\E[?1l\E>:kl=\EOD:kn#4:kr=\EOC:ks=\E[?1h\E=:ku=\EOA:le=^H:li#50:md=\E[1m:me=\E[m:mi:mr=\E[7m:ms:nd=\E[C:pt:rs=\E[r\E<\E[m\E[2J\E[H\E[?7h\E[?1;3;4;6l:se=\E[m:sf=\n:so=\E[7m:sr=\EM:ue=\E[m:up=\E[A:us=\E[1m:xn:
END_OF_FILE
if test 510 -ne `wc -c <'xterm/termcap.bold'`; then
echo shar: \"'xterm/termcap.bold'\" unpacked with wrong size!
fi
# end of 'xterm/termcap.bold'
fi
echo shar: End of archive 8 \(of 14\).
cp /dev/null ark8isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked all 14 archives.
rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
echo You still need to unpack the following archives:
echo " " ${MISSING}
fi
## End of shell archive.
exit 0
dan
----------------------------------------------------
O'Reilly && Associates argv@sun.com / argv@ora.com
Opinions expressed reflect those of the author only.