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