home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / X / mit / clients / xterm / menu.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-21  |  27.1 KB  |  1,229 lines
  1. /* $XConsortium: menu.c,v 1.61 92/04/20 18:46:39 rws Exp $ */
  2. /*
  3. Copyright 1989 Massachusetts Institute of Technology
  4.  
  5. Permission to use, copy, modify, distribute, and sell this software and its
  6. documentation for any purpose is hereby granted without fee, provided that
  7. the above copyright notice appear in all copies and that both that
  8. copyright notice and this permission notice appear in supporting
  9. documentation, and that the name of M.I.T. not be used in advertising or
  10. publicity pertaining to distribution of the software without specific,
  11. written prior permission.  M.I.T. makes no representations about the
  12. suitability of this software for any purpose.  It is provided "as is"
  13. without express or implied warranty.
  14. */
  15.  
  16. #include "ptyx.h"
  17. #include "data.h"
  18. #include "menu.h"
  19. #include <X11/StringDefs.h>
  20. #include <X11/Shell.h>
  21. #include <X11/Xmu/CharSet.h>
  22. #include <X11/Xaw/SimpleMenu.h>
  23. #include <X11/Xaw/SmeBSB.h>
  24. #include <X11/Xaw/SmeLine.h>
  25. #include <stdio.h>
  26. #include <signal.h>
  27.  
  28. extern void FindFontSelection();
  29.  
  30. Arg menuArgs[2] = {{ XtNleftBitmap, (XtArgVal) 0 },
  31.            { XtNsensitive, (XtArgVal) 0 }};
  32.  
  33. void do_hangup();
  34.  
  35. static void do_securekbd(), do_allowsends(), do_visualbell(), do_logging(),
  36.     do_redraw(), do_suspend(), do_continue(), do_interrupt(), 
  37.     do_terminate(), do_kill(), do_quit(), do_scrollbar(), do_jumpscroll(),
  38.     do_reversevideo(), do_autowrap(), do_reversewrap(), do_autolinefeed(),
  39.     do_appcursor(), do_appkeypad(), do_scrollkey(), do_scrollttyoutput(),
  40.     do_allow132(), do_cursesemul(), do_marginbell(), do_tekshow(), 
  41.     do_altscreen(), do_softreset(), do_hardreset(), do_clearsavedlines(),
  42.     do_tekmode(), do_vthide(), 
  43.     do_tektextlarge(), do_tektext2(), do_tektext3(), do_tektextsmall(), 
  44.     do_tekpage(), do_tekreset(), do_tekcopy(), do_vtshow(), do_vtmode(), 
  45.     do_tekhide(), do_vtfont();
  46.  
  47.  
  48. /*
  49.  * The order entries MUST match the values given in menu.h
  50.  */
  51. MenuEntry mainMenuEntries[] = {
  52.     { "securekbd",    do_securekbd, NULL },        /*  0 */
  53.     { "allowsends",    do_allowsends, NULL },        /*  1 */
  54.     { "logging",    do_logging, NULL },        /*  2 */
  55.     { "redraw",        do_redraw, NULL },        /*  3 */
  56.     { "line1",        NULL, NULL },            /*  4 */
  57.     { "suspend",    do_suspend, NULL },        /*  5 */
  58.     { "continue",    do_continue, NULL },        /*  6 */
  59.     { "interrupt",    do_interrupt, NULL },        /*  7 */
  60.     { "hangup",        do_hangup, NULL },        /*  8 */
  61.     { "terminate",    do_terminate, NULL },        /*  9 */
  62.     { "kill",        do_kill, NULL },        /* 10 */
  63.     { "line2",        NULL, NULL },            /* 11 */
  64.     { "quit",        do_quit, NULL }};        /* 12 */
  65.  
  66. MenuEntry vtMenuEntries[] = {
  67.     { "scrollbar",    do_scrollbar, NULL },        /*  0 */
  68.     { "jumpscroll",    do_jumpscroll, NULL },        /*  1 */
  69.     { "reversevideo",    do_reversevideo, NULL },    /*  2 */
  70.     { "autowrap",    do_autowrap, NULL },        /*  3 */
  71.     { "reversewrap",    do_reversewrap, NULL },        /*  4 */
  72.     { "autolinefeed",    do_autolinefeed, NULL },    /*  5 */
  73.     { "appcursor",    do_appcursor, NULL },        /*  6 */
  74.     { "appkeypad",    do_appkeypad, NULL },        /*  7 */
  75.     { "scrollkey",    do_scrollkey, NULL },        /*  8 */
  76.     { "scrollttyoutput",do_scrollttyoutput, NULL },    /*  9 */
  77.     { "allow132",    do_allow132, NULL },        /* 10 */
  78.     { "cursesemul",    do_cursesemul, NULL },        /* 11 */
  79.     { "visualbell",    do_visualbell, NULL },        /* 12 */
  80.     { "marginbell",    do_marginbell, NULL },        /* 13 */
  81.     { "altscreen",    do_altscreen, NULL },        /* 14 */
  82.     { "line1",        NULL, NULL },            /* 15 */
  83.     { "softreset",    do_softreset, NULL },        /* 16 */
  84.     { "hardreset",    do_hardreset, NULL },        /* 17 */
  85.     { "clearsavedlines",do_clearsavedlines, NULL },    /* 18 */
  86.     { "line2",        NULL, NULL },            /* 19 */
  87.     { "tekshow",    do_tekshow, NULL },        /* 20 */
  88.     { "tekmode",    do_tekmode, NULL },        /* 21 */
  89.     { "vthide",        do_vthide, NULL }};        /* 22 */
  90.  
  91. MenuEntry fontMenuEntries[] = {
  92.     { "fontdefault",    do_vtfont, NULL },        /*  0 */
  93.     { "font1",        do_vtfont, NULL },        /*  1 */
  94.     { "font2",        do_vtfont, NULL },        /*  2 */
  95.     { "font3",        do_vtfont, NULL },        /*  3 */
  96.     { "font4",        do_vtfont, NULL },        /*  4 */
  97.     { "font5",        do_vtfont, NULL },        /*  5 */
  98.     { "font6",        do_vtfont, NULL },        /*  6 */
  99.     { "fontescape",    do_vtfont, NULL },        /*  7 */
  100.     { "fontsel",    do_vtfont, NULL }};        /*  8 */
  101.     /* this should match NMENUFONTS in ptyx.h */
  102.  
  103. MenuEntry tekMenuEntries[] = {
  104.     { "tektextlarge",    do_tektextlarge, NULL },    /*  0 */
  105.     { "tektext2",    do_tektext2, NULL },        /*  1 */
  106.     { "tektext3",    do_tektext3, NULL },        /*  2 */
  107.     { "tektextsmall",    do_tektextsmall, NULL },    /*  3 */
  108.     { "line1",        NULL, NULL },            /*  4 */
  109.     { "tekpage",    do_tekpage, NULL },        /*  5 */
  110.     { "tekreset",    do_tekreset, NULL },        /*  6 */
  111.     { "tekcopy",    do_tekcopy, NULL },        /*  7 */
  112.     { "line2",        NULL, NULL },            /*  8 */
  113.     { "vtshow",        do_vtshow, NULL },        /*  9 */
  114.     { "vtmode",        do_vtmode, NULL },        /* 10 */
  115.     { "tekhide",    do_tekhide, NULL }};        /* 11 */
  116.  
  117. static Widget create_menu();
  118. extern Widget toplevel;
  119.  
  120.  
  121. /*
  122.  * we really want to do these dynamically
  123.  */
  124. #define check_width 9
  125. #define check_height 8
  126. static unsigned char check_bits[] = {
  127.    0x00, 0x01, 0x80, 0x01, 0xc0, 0x00, 0x60, 0x00,
  128.    0x31, 0x00, 0x1b, 0x00, 0x0e, 0x00, 0x04, 0x00
  129. };
  130.  
  131.  
  132. /*
  133.  * public interfaces
  134.  */
  135.  
  136. /* ARGSUSED */
  137. static Bool domenu (w, event, params, param_count)
  138.     Widget w;
  139.     XEvent *event;              /* unused */
  140.     String *params;             /* mainMenu, vtMenu, or tekMenu */
  141.     Cardinal *param_count;      /* 0 or 1 */
  142. {
  143.     TScreen *screen = &term->screen;
  144.  
  145.     if (*param_count != 1) {
  146.     XBell (XtDisplay(w), 0);
  147.     return False;
  148.     }
  149.  
  150.     switch (params[0][0]) {
  151.       case 'm':
  152.     if (!screen->mainMenu) {
  153.         screen->mainMenu = create_menu (term, toplevel, "mainMenu",
  154.                         mainMenuEntries,
  155.                         XtNumber(mainMenuEntries));
  156.         update_securekbd();
  157.         update_allowsends();
  158.         update_logging();
  159. #ifndef SIGTSTP
  160.         set_sensitivity (screen->mainMenu,
  161.                  mainMenuEntries[mainMenu_suspend].widget, FALSE);
  162. #endif
  163. #ifndef SIGCONT
  164.         set_sensitivity (screen->mainMenu, 
  165.                  mainMenuEntries[mainMenu_continue].widget, FALSE);
  166. #endif
  167.     }
  168.     break;
  169.  
  170.       case 'v':
  171.     if (!screen->vtMenu) {
  172.         screen->vtMenu = create_menu (term, toplevel, "vtMenu",
  173.                       vtMenuEntries,
  174.                       XtNumber(vtMenuEntries));
  175.         /* and turn off the alternate screen entry */
  176.         set_altscreen_sensitivity (FALSE);
  177.         update_scrollbar();
  178.         update_jumpscroll();
  179.         update_reversevideo();
  180.         update_autowrap();
  181.         update_reversewrap();
  182.         update_autolinefeed();
  183.         update_appcursor();
  184.         update_appkeypad();
  185.         update_scrollkey();
  186.         update_scrollttyoutput();
  187.         update_allow132();
  188.         update_cursesemul();
  189.         update_visualbell();
  190.         update_marginbell();
  191.     }
  192.     break;
  193.  
  194.       case 'f':
  195.     if (!screen->fontMenu) {
  196.         screen->fontMenu = create_menu (term, toplevel, "fontMenu",
  197.                         fontMenuEntries,
  198.                         NMENUFONTS);  
  199.         set_menu_font (True);
  200.         set_sensitivity (screen->fontMenu,
  201.                  fontMenuEntries[fontMenu_fontescape].widget,
  202.                  (screen->menu_font_names[fontMenu_fontescape]
  203.                   ? TRUE : FALSE));
  204.     }
  205.     FindFontSelection (NULL, True);
  206.     set_sensitivity (screen->fontMenu,
  207.              fontMenuEntries[fontMenu_fontsel].widget,
  208.              (screen->menu_font_names[fontMenu_fontsel]
  209.               ? TRUE : FALSE));
  210.     break;
  211.  
  212.       case 't':
  213.     if (!screen->tekMenu) {
  214.         screen->tekMenu = create_menu (term, toplevel, "tekMenu",
  215.                        tekMenuEntries,
  216.                        XtNumber(tekMenuEntries));
  217.         set_tekfont_menu_item (screen->cur.fontsize, TRUE);
  218.     }
  219.     break;
  220.  
  221.       default:
  222.     XBell (XtDisplay(w), 0);
  223.     return False;
  224.     }
  225.  
  226.     return True;
  227. }
  228.  
  229. void HandleCreateMenu (w, event, params, param_count)
  230.     Widget w;
  231.     XEvent *event;              /* unused */
  232.     String *params;             /* mainMenu, vtMenu, or tekMenu */
  233.     Cardinal *param_count;      /* 0 or 1 */
  234. {
  235.     (void) domenu (w, event, params, param_count);
  236. }
  237.  
  238. void HandlePopupMenu (w, event, params, param_count)
  239.     Widget w;
  240.     XEvent *event;              /* unused */
  241.     String *params;             /* mainMenu, vtMenu, or tekMenu */
  242.     Cardinal *param_count;      /* 0 or 1 */
  243. {
  244.     if (domenu (w, event, params, param_count)) {
  245.     XtCallActionProc (w, "XawPositionSimpleMenu", event, params, 1);
  246.     XtCallActionProc (w, "MenuPopup", event, params, 1);
  247.     }
  248. }
  249.  
  250.  
  251. /*
  252.  * private interfaces - keep out!
  253.  */
  254.  
  255. /*
  256.  * create_menu - create a popup shell and stuff the menu into it.
  257.  */
  258.  
  259. static Widget create_menu (xtw, toplevelw, name, entries, nentries)
  260.     XtermWidget xtw;
  261.     Widget toplevelw;
  262.     char *name;
  263.     struct _MenuEntry *entries;
  264.     int nentries;
  265. {
  266.     Widget m;
  267.     TScreen *screen = &xtw->screen;
  268.     static XtCallbackRec cb[2] = { { NULL, NULL }, { NULL, NULL }};
  269.     static Arg arg = { XtNcallback, (XtArgVal) cb };
  270.  
  271.     if (screen->menu_item_bitmap == None) {
  272.     screen->menu_item_bitmap =
  273.       XCreateBitmapFromData (XtDisplay(xtw),
  274.                  RootWindowOfScreen(XtScreen(xtw)),
  275.                  (char *)check_bits, check_width, check_height);
  276.     }
  277.  
  278.     m = XtCreatePopupShell (name, simpleMenuWidgetClass, toplevelw, NULL, 0);
  279.  
  280.     for (; nentries > 0; nentries--, entries++) {
  281.     cb[0].callback = (XtCallbackProc) entries->function;
  282.     cb[0].closure = (caddr_t) entries->name;
  283.     entries->widget = XtCreateManagedWidget (entries->name, 
  284.                          (entries->function ?
  285.                           smeBSBObjectClass :
  286.                           smeLineObjectClass), m,
  287.                          &arg, (Cardinal) 1);
  288.     }
  289.  
  290.     /* do not realize at this point */
  291.     return m;
  292. }
  293.  
  294. /* ARGSUSED */
  295. static void handle_send_signal (gw, sig)
  296.     Widget gw;
  297.     int sig;
  298. {
  299.     register TScreen *screen = &term->screen;
  300.  
  301.     if (screen->pid > 1) kill_process_group (screen->pid, sig);
  302. }
  303.  
  304.  
  305. /*
  306.  * action routines
  307.  */
  308.  
  309. /* ARGSUSED */
  310. void DoSecureKeyboard (time)
  311.     Time time;
  312. {
  313.     do_securekbd (term->screen.mainMenu, NULL, NULL);
  314. }
  315.  
  316. static void do_securekbd (gw, closure, data)
  317.     Widget gw;
  318.     caddr_t closure, data;
  319. {
  320.     register TScreen *screen = &term->screen;
  321.     Time time = CurrentTime;        /* XXX - wrong */
  322.  
  323.     if (screen->grabbedKbd) {
  324.     XUngrabKeyboard (screen->display, time);
  325.     ReverseVideo (term);
  326.     screen->grabbedKbd = FALSE;
  327.     } else {
  328.     if (XGrabKeyboard (screen->display, term->core.window,
  329.                True, GrabModeAsync, GrabModeAsync, time)
  330.         != GrabSuccess) {
  331.         XBell (screen->display, 100);
  332.     } else {
  333.         ReverseVideo (term);
  334.         screen->grabbedKbd = TRUE;
  335.     }
  336.     }
  337.     update_securekbd();
  338. }
  339.  
  340.  
  341. static void do_allowsends (gw, closure, data)
  342.     Widget gw;
  343.     caddr_t closure, data;
  344. {
  345.     register TScreen *screen = &term->screen;
  346.  
  347.     screen->allowSendEvents = !screen->allowSendEvents;
  348.     update_allowsends ();
  349. }
  350.  
  351. static void do_visualbell (gw, closure, data)
  352.     Widget gw;
  353.     caddr_t closure, data;
  354. {
  355.     register TScreen *screen = &term->screen;
  356.  
  357.     screen->visualbell = !screen->visualbell;
  358.     update_visualbell();
  359. }
  360.  
  361. static void do_logging (gw, closure, data)
  362.     Widget gw;
  363.     caddr_t closure, data;
  364. {
  365.     register TScreen *screen = &term->screen;
  366.  
  367.     if (screen->logging) {
  368.     CloseLog (screen);
  369.     } else {
  370.     StartLog (screen);
  371.     }
  372.     /* update_logging done by CloseLog and StartLog */
  373. }
  374.  
  375.  
  376. static void do_redraw (gw, closure, data)
  377.     Widget gw;
  378.     caddr_t closure, data;
  379. {
  380.     Redraw ();
  381. }
  382.  
  383.  
  384. /*
  385.  * The following cases use the pid instead of the process group so that we
  386.  * don't get hosed by programs that change their process group
  387.  */
  388.  
  389.  
  390. /* ARGSUSED */
  391. static void do_suspend (gw, closure, data)
  392.     Widget gw;
  393.     caddr_t closure, data;
  394. {
  395. #ifdef SIGTSTP
  396.     handle_send_signal (gw, SIGTSTP);
  397. #endif
  398. }
  399.  
  400. /* ARGSUSED */
  401. static void do_continue (gw, closure, data)
  402.     Widget gw;
  403.     caddr_t closure, data;
  404. {
  405. #ifdef SIGCONT
  406.     handle_send_signal (gw, SIGCONT);
  407. #endif
  408. }
  409.  
  410. /* ARGSUSED */
  411. static void do_interrupt (gw, closure, data)
  412.     Widget gw;
  413.     caddr_t closure, data;
  414. {
  415.     handle_send_signal (gw, SIGINT);
  416. }
  417.  
  418. /* ARGSUSED */
  419. void do_hangup (gw, closure, data)
  420.     Widget gw;
  421.     caddr_t closure, data;
  422. {
  423.     handle_send_signal (gw, SIGHUP);
  424. }
  425.  
  426. /* ARGSUSED */
  427. static void do_terminate (gw, closure, data)
  428.     Widget gw;
  429.     caddr_t closure, data;
  430. {
  431.     handle_send_signal (gw, SIGTERM);
  432. }
  433.  
  434. /* ARGSUSED */
  435. static void do_kill (gw, closure, data)
  436.     Widget gw;
  437.     caddr_t closure, data;
  438. {
  439.     handle_send_signal (gw, SIGKILL);
  440. }
  441.  
  442. static void do_quit (gw, closure, data)
  443.     Widget gw;
  444.     caddr_t closure, data;
  445. {
  446.     Cleanup (0);
  447. }
  448.  
  449.  
  450.  
  451. /*
  452.  * vt menu callbacks
  453.  */
  454.  
  455. static void do_scrollbar (gw, closure, data)
  456.     Widget gw;
  457.     caddr_t closure, data;
  458. {
  459.     register TScreen *screen = &term->screen;
  460.  
  461.     if (screen->scrollbar) {
  462.     ScrollBarOff (screen);
  463.     } else {
  464.     ScrollBarOn (term, FALSE, FALSE);
  465.     }
  466.     update_scrollbar();
  467. }
  468.  
  469.  
  470. static void do_jumpscroll (gw, closure, data)
  471.     Widget gw;
  472.     caddr_t closure, data;
  473. {
  474.     register TScreen *screen = &term->screen;
  475.  
  476.     term->flags ^= SMOOTHSCROLL;
  477.     if (term->flags & SMOOTHSCROLL) {
  478.     screen->jumpscroll = FALSE;
  479.     if (screen->scroll_amt) FlushScroll(screen);
  480.     } else {
  481.     screen->jumpscroll = TRUE;
  482.     }
  483.     update_jumpscroll();
  484. }
  485.  
  486.  
  487. static void do_reversevideo (gw, closure, data)
  488.     Widget gw;
  489.     caddr_t closure, data;
  490. {
  491.     term->flags ^= REVERSE_VIDEO;
  492.     ReverseVideo (term);
  493.     /* update_reversevideo done in ReverseVideo */
  494. }
  495.  
  496.  
  497. static void do_autowrap (gw, closure, data)
  498.     Widget gw;
  499.     caddr_t closure, data;
  500. {
  501.     term->flags ^= WRAPAROUND;
  502.     update_autowrap();
  503. }
  504.  
  505.  
  506. static void do_reversewrap (gw, closure, data)
  507.     Widget gw;
  508.     caddr_t closure, data;
  509. {
  510.     term->flags ^= REVERSEWRAP;
  511.     update_reversewrap();
  512. }
  513.  
  514.  
  515. static void do_autolinefeed (gw, closure, data)
  516.     Widget gw;
  517.     caddr_t closure, data;
  518. {
  519.     term->flags ^= LINEFEED;
  520.     update_autolinefeed();
  521. }
  522.  
  523.  
  524. static void do_appcursor (gw, closure, data)
  525.     Widget gw;
  526.     caddr_t closure, data;
  527. {
  528.     term->keyboard.flags ^= CURSOR_APL;
  529.     update_appcursor();
  530. }
  531.  
  532.  
  533. static void do_appkeypad (gw, closure, data)
  534.     Widget gw;
  535.     caddr_t closure, data;
  536. {
  537.     term->keyboard.flags ^= KYPD_APL;
  538.     update_appkeypad();
  539. }
  540.  
  541.  
  542. static void do_scrollkey (gw, closure, data)
  543.     Widget gw;
  544.     caddr_t closure, data;
  545. {
  546.     register TScreen *screen = &term->screen;
  547.  
  548.     screen->scrollkey = !screen->scrollkey;
  549.     update_scrollkey();
  550. }
  551.  
  552.  
  553. static void do_scrollttyoutput (gw, closure, data)
  554.     Widget gw;
  555.     caddr_t closure, data;
  556. {
  557.     register TScreen *screen = &term->screen;
  558.  
  559.     screen->scrollttyoutput = !screen->scrollttyoutput;
  560.     update_scrollttyoutput();
  561. }
  562.  
  563.  
  564. static void do_allow132 (gw, closure, data)
  565.     Widget gw;
  566.     caddr_t closure, data;
  567. {
  568.     register TScreen *screen = &term->screen;
  569.  
  570.     screen->c132 = !screen->c132;
  571.     update_allow132();
  572. }
  573.  
  574.  
  575. static void do_cursesemul (gw, closure, data)
  576.     Widget gw;
  577.     caddr_t closure, data;
  578. {
  579.     register TScreen *screen = &term->screen;
  580.  
  581.     screen->curses = !screen->curses;
  582.     update_cursesemul();
  583. }
  584.  
  585.  
  586. static void do_marginbell (gw, closure, data)
  587.     Widget gw;
  588.     caddr_t closure, data;
  589. {
  590.     register TScreen *screen = &term->screen;
  591.  
  592.     if (!(screen->marginbell = !screen->marginbell)) screen->bellarmed = -1;
  593.     update_marginbell();
  594. }
  595.  
  596.  
  597. static void handle_tekshow (gw, allowswitch)
  598.     Widget gw;
  599.     Bool allowswitch;
  600. {
  601.     register TScreen *screen = &term->screen;
  602.  
  603.     if (!screen->Tshow) {        /* not showing, turn on */
  604.     set_tek_visibility (TRUE);
  605.     } else if (screen->Vshow || allowswitch) {  /* is showing, turn off */
  606.     set_tek_visibility (FALSE);
  607.     end_tek_mode ();        /* WARNING: this does a longjmp */
  608.     } else
  609.       Bell();
  610. }
  611.  
  612. /* ARGSUSED */
  613. static void do_tekshow (gw, closure, data)
  614.     Widget gw;
  615.     caddr_t closure, data;
  616. {
  617.     handle_tekshow (gw, True);
  618. }
  619.  
  620. /* ARGSUSED */
  621. static void do_tekonoff (gw, closure, data)
  622.     Widget gw;
  623.     caddr_t closure, data;
  624. {
  625.     handle_tekshow (gw, False);
  626. }
  627.  
  628. /* ARGSUSED */
  629. static void do_altscreen (gw, closure, data)
  630.     Widget gw;
  631.     caddr_t closure, data;
  632. {
  633.     /* do nothing for now; eventually, will want to flip screen */
  634. }
  635.  
  636.  
  637. static void do_softreset (gw, closure, data)
  638.     Widget gw;
  639.     caddr_t closure, data;
  640. {
  641.     VTReset (FALSE);
  642. }
  643.  
  644.  
  645. static void do_hardreset (gw, closure, data)
  646.     Widget gw;
  647.     caddr_t closure, data;
  648. {
  649.     VTReset (TRUE);
  650. }
  651.  
  652.  
  653. static void do_clearsavedlines (gw, closure, data)
  654.     Widget gw;
  655.     caddr_t closure, data;
  656. {
  657.     register TScreen *screen = &term->screen;
  658.  
  659.     screen->savedlines = 0;
  660.     ScrollBarDrawThumb(screen->scrollWidget);
  661.     VTReset (TRUE); 
  662. }
  663.  
  664.  
  665. static void do_tekmode (gw, closure, data)
  666.     Widget gw;
  667.     caddr_t closure, data;
  668. {
  669.     register TScreen *screen = &term->screen;
  670.  
  671.     switch_modes (screen->TekEmu);    /* switch to tek mode */
  672. }
  673.  
  674. /* ARGSUSED */
  675. static void do_vthide (gw, closure, data)
  676.     Widget gw;
  677.     caddr_t closure, data;
  678. {
  679.     hide_vt_window();
  680. }
  681.  
  682.  
  683. /*
  684.  * vtfont menu
  685.  */
  686.  
  687. static void do_vtfont (gw, closure, data)
  688.     Widget gw;
  689.     caddr_t closure, data;
  690. {
  691.     char *entryname = (char *) closure;
  692.     int i;
  693.  
  694.     for (i = 0; i < NMENUFONTS; i++) {
  695.     if (strcmp (entryname, fontMenuEntries[i].name) == 0) {
  696.         SetVTFont (i, True, NULL, NULL);
  697.         return;
  698.     }
  699.     }
  700.     Bell();
  701. }
  702.  
  703.  
  704. /*
  705.  * tek menu
  706.  */
  707.  
  708. static void do_tektextlarge (gw, closure, data)
  709.     Widget gw;
  710.     caddr_t closure, data;
  711. {
  712.     TekSetFontSize (tekMenu_tektextlarge);
  713. }
  714.  
  715.  
  716. static void do_tektext2 (gw, closure, data)
  717.     Widget gw;
  718.     caddr_t closure, data;
  719. {
  720.     TekSetFontSize (tekMenu_tektext2);
  721. }
  722.  
  723.  
  724. static void do_tektext3 (gw, closure, data)
  725.     Widget gw;
  726.     caddr_t closure, data;
  727. {
  728.     TekSetFontSize (tekMenu_tektext3);
  729. }
  730.  
  731.  
  732. static void do_tektextsmall (gw, closure, data)
  733.     Widget gw;
  734.     caddr_t closure, data;
  735. {
  736.  
  737.     TekSetFontSize (tekMenu_tektextsmall);
  738. }
  739.  
  740.  
  741. static void do_tekpage (gw, closure, data)
  742.     Widget gw;
  743.     caddr_t closure, data;
  744. {
  745.     TekSimulatePageButton (False);
  746. }
  747.  
  748.  
  749. static void do_tekreset (gw, closure, data)
  750.     Widget gw;
  751.     caddr_t closure, data;
  752. {
  753.     TekSimulatePageButton (True);
  754. }
  755.  
  756.  
  757. static void do_tekcopy (gw, closure, data)
  758.     Widget gw;
  759.     caddr_t closure, data;
  760. {
  761.     TekCopy ();
  762. }
  763.  
  764.  
  765. static void handle_vtshow (gw, allowswitch)
  766.     Widget gw;
  767.     Bool allowswitch;
  768. {
  769.     register TScreen *screen = &term->screen;
  770.  
  771.     if (!screen->Vshow) {        /* not showing, turn on */
  772.     set_vt_visibility (TRUE);
  773.     } else if (screen->Tshow || allowswitch) {  /* is showing, turn off */
  774.     set_vt_visibility (FALSE);
  775.     if (!screen->TekEmu && TekRefresh) dorefresh ();
  776.     end_vt_mode ();
  777.     } else 
  778.       Bell();
  779. }
  780.  
  781. static void do_vtshow (gw, closure, data)
  782.     Widget gw;
  783.     caddr_t closure, data;
  784. {
  785.     handle_vtshow (gw, True);
  786. }
  787.  
  788. static void do_vtonoff (gw, closure, data)
  789.     Widget gw;
  790.     caddr_t closure, data;
  791. {
  792.     handle_vtshow (gw, False);
  793. }
  794.  
  795. static void do_vtmode (gw, closure, data)
  796.     Widget gw;
  797.     caddr_t closure, data;
  798. {
  799.     register TScreen *screen = &term->screen;
  800.  
  801.     switch_modes (screen->TekEmu);    /* switch to vt, or from */
  802. }
  803.  
  804.  
  805. /* ARGSUSED */
  806. static void do_tekhide (gw, closure, data)
  807.     Widget gw;
  808.     caddr_t closure, data;
  809. {
  810.     hide_tek_window();
  811. }
  812.  
  813.  
  814.  
  815. /*
  816.  * public handler routines
  817.  */
  818.  
  819. static void handle_toggle (proc, var, params, nparams, w, closure, data)
  820.     void (*proc)();
  821.     int var;
  822.     String *params;
  823.     Cardinal nparams;
  824.     Widget w;
  825.     caddr_t closure, data;
  826. {
  827.     int dir = -2;
  828.  
  829.     switch (nparams) {
  830.       case 0:
  831.     dir = -1;
  832.     break;
  833.       case 1:
  834.     if (XmuCompareISOLatin1 (params[0], "on") == 0) dir = 1;
  835.     else if (XmuCompareISOLatin1 (params[0], "off") == 0) dir = 0;
  836.     else if (XmuCompareISOLatin1 (params[0], "toggle") == 0) dir = -1;
  837.     break;
  838.     }
  839.  
  840.     switch (dir) {
  841.       case -2:
  842.     Bell();
  843.     break;
  844.  
  845.       case -1:
  846.     (*proc) (w, closure, data);
  847.     break;
  848.  
  849.       case 0:
  850.     if (var) (*proc) (w, closure, data);
  851.     else Bell();
  852.     break;
  853.  
  854.       case 1:
  855.     if (!var) (*proc) (w, closure, data);
  856.     else Bell();
  857.     break;
  858.     }
  859.     return;
  860. }
  861.  
  862. void HandleAllowSends(w, event, params, param_count)
  863.     Widget w;
  864.     XEvent *event;
  865.     String *params;
  866.     Cardinal *param_count;
  867. {
  868.     handle_toggle (do_allowsends, (int) term->screen.allowSendEvents,
  869.            params, *param_count, w, NULL, NULL);
  870. }
  871.  
  872. void HandleSetVisualBell(w, event, params, param_count)
  873.     Widget w;
  874.     XEvent *event;
  875.     String *params;
  876.     Cardinal *param_count;
  877. {
  878.     handle_toggle (do_visualbell, (int) term->screen.visualbell,
  879.            params, *param_count, w, NULL, NULL);
  880. }
  881.  
  882. void HandleLogging(w, event, params, param_count)
  883.     Widget w;
  884.     XEvent *event;
  885.     String *params;
  886.     Cardinal *param_count;
  887. {
  888.     handle_toggle (do_logging, (int) term->screen.logging,
  889.            params, *param_count, w, NULL, NULL);
  890. }
  891.  
  892. /* ARGSUSED */
  893. void HandleRedraw(w, event, params, param_count)
  894.     Widget w;
  895.     XEvent *event;
  896.     String *params;
  897.     Cardinal *param_count;
  898. {
  899.     do_redraw(w, NULL, NULL);
  900. }
  901.  
  902. /* ARGSUSED */
  903. void HandleSendSignal(w, event, params, param_count)
  904.     Widget w;
  905.     XEvent *event;        /* unused */
  906.     String *params;
  907.     Cardinal *param_count;
  908. {
  909.     static struct sigtab {
  910.     char *name;
  911.     int sig;
  912.     } signals[] = {
  913. #ifdef SIGTSTP
  914.     { "suspend",    SIGTSTP },
  915.     { "tstp",    SIGTSTP },
  916. #endif
  917. #ifdef SIGCONT
  918.     { "cont",    SIGCONT },
  919. #endif
  920.     { "int",    SIGINT },
  921.     { "hup",    SIGHUP },
  922.     { "quit",    SIGQUIT },
  923.     { "alrm",    SIGALRM },
  924.     { "alarm",    SIGALRM },
  925.     { "term",    SIGTERM },
  926.     { "kill",    SIGKILL },
  927.     { NULL, 0 },
  928.     };
  929.  
  930.     if (*param_count == 1) {
  931.     struct sigtab *st;
  932.  
  933.     for (st = signals; st->name; st++) {
  934.         if (XmuCompareISOLatin1 (st->name, params[0]) == 0) {
  935.         handle_send_signal (w, st->sig);
  936.         return;
  937.         }
  938.     }
  939.     /* one could allow numeric values, but that would be a security hole */
  940.     }
  941.  
  942.     Bell();
  943. }
  944.  
  945. /* ARGSUSED */
  946. void HandleQuit(w, event, params, param_count)
  947.     Widget w;
  948.     XEvent *event;
  949.     String *params;
  950.     Cardinal *param_count;
  951. {
  952.     do_quit(w, NULL, NULL);
  953. }
  954.  
  955. void HandleScrollbar(w, event, params, param_count)
  956.     Widget w;
  957.     XEvent *event;
  958.     String *params;
  959.     Cardinal *param_count;
  960. {
  961.     handle_toggle (do_scrollbar, (int) term->screen.scrollbar,
  962.            params, *param_count, w, NULL, NULL);
  963. }
  964.  
  965. void HandleJumpscroll(w, event, params, param_count)
  966.     Widget w;
  967.     XEvent *event;
  968.     String *params;
  969.     Cardinal *param_count;
  970. {
  971.     handle_toggle (do_jumpscroll, (int) term->screen.jumpscroll,
  972.            params, *param_count, w, NULL, NULL);
  973. }
  974.  
  975. void HandleReverseVideo(w, event, params, param_count)
  976.     Widget w;
  977.     XEvent *event;
  978.     String *params;
  979.     Cardinal *param_count;
  980. {
  981.     handle_toggle (do_reversevideo, (int) (term->flags & REVERSE_VIDEO),
  982.            params, *param_count, w, NULL, NULL);
  983. }
  984.  
  985. void HandleAutoWrap(w, event, params, param_count)
  986.     Widget w;
  987.     XEvent *event;
  988.     String *params;
  989.     Cardinal *param_count;
  990. {
  991.     handle_toggle (do_autowrap, (int) (term->flags & WRAPAROUND),
  992.            params, *param_count, w, NULL, NULL);
  993. }
  994.  
  995. void HandleReverseWrap(w, event, params, param_count)
  996.     Widget w;
  997.     XEvent *event;
  998.     String *params;
  999.     Cardinal *param_count;
  1000. {
  1001.     handle_toggle (do_reversewrap, (int) (term->flags & REVERSEWRAP),
  1002.            params, *param_count, w, NULL, NULL);
  1003. }
  1004.  
  1005. void HandleAutoLineFeed(w, event, params, param_count)
  1006.     Widget w;
  1007.     XEvent *event;
  1008.     String *params;
  1009.     Cardinal *param_count;
  1010. {
  1011.     handle_toggle (do_autolinefeed, (int) (term->flags & LINEFEED),
  1012.            params, *param_count, w, NULL, NULL);
  1013. }
  1014.  
  1015. void HandleAppCursor(w, event, params, param_count)
  1016.     Widget w;
  1017.     XEvent *event;
  1018.     String *params;
  1019.     Cardinal *param_count;
  1020. {
  1021.     handle_toggle (do_appcursor, (int) (term->keyboard.flags & CURSOR_APL),
  1022.            params, *param_count, w, NULL, NULL);
  1023. }
  1024.  
  1025. void HandleAppKeypad(w, event, params, param_count)
  1026.     Widget w;
  1027.     XEvent *event;
  1028.     String *params;
  1029.     Cardinal *param_count;
  1030. {
  1031.     handle_toggle (do_appkeypad, (int) (term->keyboard.flags & KYPD_APL),
  1032.            params, *param_count, w, NULL, NULL);
  1033. }
  1034.  
  1035. void HandleScrollKey(w, event, params, param_count)
  1036.     Widget w;
  1037.     XEvent *event;
  1038.     String *params;
  1039.     Cardinal *param_count;
  1040. {
  1041.     handle_toggle (do_scrollkey, (int) term->screen.scrollkey,
  1042.            params, *param_count, w, NULL, NULL);
  1043. }
  1044.  
  1045. void HandleScrollTtyOutput(w, event, params, param_count)
  1046.     Widget w;
  1047.     XEvent *event;
  1048.     String *params;
  1049.     Cardinal *param_count;
  1050. {
  1051.     handle_toggle (do_scrollttyoutput, (int) term->screen.scrollttyoutput,
  1052.            params, *param_count, w, NULL, NULL);
  1053. }
  1054.  
  1055. void HandleAllow132(w, event, params, param_count)
  1056.     Widget w;
  1057.     XEvent *event;
  1058.     String *params;
  1059.     Cardinal *param_count;
  1060. {
  1061.     handle_toggle (do_allow132, (int) term->screen.c132,
  1062.            params, *param_count, w, NULL, NULL);
  1063. }
  1064.  
  1065. void HandleCursesEmul(w, event, params, param_count)
  1066.     Widget w;
  1067.     XEvent *event;
  1068.     String *params;
  1069.     Cardinal *param_count;
  1070. {
  1071.     handle_toggle (do_cursesemul, (int) term->screen.curses,
  1072.            params, *param_count, w, NULL, NULL);
  1073. }
  1074.  
  1075. void HandleMarginBell(w, event, params, param_count)
  1076.     Widget w;
  1077.     XEvent *event;
  1078.     String *params;
  1079.     Cardinal *param_count;
  1080. {
  1081.     handle_toggle (do_marginbell, (int) term->screen.marginbell,
  1082.            params, *param_count, w, NULL, NULL);
  1083. }
  1084.  
  1085. void HandleAltScreen(w, event, params, param_count)
  1086.     Widget w;
  1087.     XEvent *event;
  1088.     String *params;
  1089.     Cardinal *param_count;
  1090. {
  1091.     /* eventually want to see if sensitive or not */
  1092.     handle_toggle (do_altscreen, (int) term->screen.alternate,
  1093.            params, *param_count, w, NULL, NULL);
  1094. }
  1095.  
  1096. /* ARGSUSED */
  1097. void HandleSoftReset(w, event, params, param_count)
  1098.     Widget w;
  1099.     XEvent *event;
  1100.     String *params;
  1101.     Cardinal *param_count;
  1102. {
  1103.     do_softreset(w, NULL, NULL);
  1104. }
  1105.  
  1106. /* ARGSUSED */
  1107. void HandleHardReset(w, event, params, param_count)
  1108.     Widget w;
  1109.     XEvent *event;
  1110.     String *params;
  1111.     Cardinal *param_count;
  1112. {
  1113.     do_hardreset(w, NULL, NULL);
  1114. }
  1115.  
  1116. /* ARGSUSED */
  1117. void HandleClearSavedLines(w, event, params, param_count)
  1118.     Widget w;
  1119.     XEvent *event;
  1120.     String *params;
  1121.     Cardinal *param_count;
  1122. {
  1123.     do_clearsavedlines(w, NULL, NULL);
  1124. }
  1125.  
  1126. void HandleSetTerminalType(w, event, params, param_count)
  1127.     Widget w;
  1128.     XEvent *event;
  1129.     String *params;
  1130.     Cardinal *param_count;
  1131. {
  1132.     if (*param_count == 1) {
  1133.     switch (params[0][0]) {
  1134.       case 'v': case 'V':
  1135.         if (term->screen.TekEmu) do_vtmode (w, NULL, NULL);
  1136.         break;
  1137.       case 't': case 'T':
  1138.         if (!term->screen.TekEmu) do_tekmode (w, NULL, NULL);
  1139.         break;
  1140.       default:
  1141.         Bell();
  1142.     }
  1143.     } else {
  1144.     Bell();
  1145.     }
  1146. }
  1147.  
  1148. void HandleVisibility(w, event, params, param_count)
  1149.     Widget w;
  1150.     XEvent *event;
  1151.     String *params;
  1152.     Cardinal *param_count;
  1153. {
  1154.     if (*param_count == 2) {
  1155.     switch (params[0][0]) {
  1156.       case 'v': case 'V':
  1157.         handle_toggle (do_vtonoff, (int) term->screen.Vshow,
  1158.                params+1, (*param_count) - 1, w, NULL, NULL);
  1159.         break;
  1160.       case 't': case 'T':
  1161.         handle_toggle (do_tekonoff, (int) term->screen.Tshow,
  1162.                params+1, (*param_count) - 1, w, NULL, NULL);
  1163.         break;
  1164.       default:
  1165.         Bell();
  1166.     }
  1167.     } else {
  1168.     Bell();
  1169.     }
  1170. }
  1171.  
  1172. /* ARGSUSED */
  1173. void HandleSetTekText(w, event, params, param_count)
  1174.     Widget w;
  1175.     XEvent *event;
  1176.     String *params;
  1177.     Cardinal *param_count;
  1178. {
  1179.     void (*proc)() = NULL;
  1180.  
  1181.     switch (*param_count) {
  1182.       case 0:
  1183.     proc = do_tektextlarge;
  1184.     break;
  1185.       case 1:
  1186.     switch (params[0][0]) {
  1187.       case 'l': case 'L': proc = do_tektextlarge; break;
  1188.       case '2': proc = do_tektext2; break;
  1189.       case '3': proc = do_tektext3; break;
  1190.       case 's': case 'S': proc = do_tektextsmall; break;
  1191.     }
  1192.     break;
  1193.     }
  1194.     if (proc) (*proc) (w, NULL, NULL);
  1195.     else Bell();
  1196. }
  1197.  
  1198. /* ARGSUSED */
  1199. void HandleTekPage(w, event, params, param_count)
  1200.     Widget w;
  1201.     XEvent *event;
  1202.     String *params;
  1203.     Cardinal *param_count;
  1204. {
  1205.     do_tekpage(w, NULL, NULL);
  1206. }
  1207.  
  1208. /* ARGSUSED */
  1209. void HandleTekReset(w, event, params, param_count)
  1210.     Widget w;
  1211.     XEvent *event;
  1212.     String *params;
  1213.     Cardinal *param_count;
  1214. {
  1215.     do_tekreset(w, NULL, NULL);
  1216. }
  1217.  
  1218. /* ARGSUSED */
  1219. void HandleTekCopy(w, event, params, param_count)
  1220.     Widget w;
  1221.     XEvent *event;
  1222.     String *params;
  1223.     Cardinal *param_count;
  1224. {
  1225.     do_tekcopy(w, NULL, NULL);
  1226. }
  1227.  
  1228.  
  1229.