menu.c

   1 /* $XTermId: menu.c,v 1.279 2011/02/09 10:00:58 tom Exp $ */
   2
   3 /*
   4  * Copyright 1999-2010,2011 by Thomas E. Dickey
   5  *
   6  *                         All Rights Reserved
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the
  10  * "Software"), to deal in the Software without restriction, including
  11  * without limitation the rights to use, copy, modify, merge, publish,
  12  * distribute, sublicense, and/or sell copies of the Software, and to
  13  * permit persons to whom the Software is furnished to do so, subject to
  14  * the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included
  17  * in all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  22  * IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY
  23  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  24  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  25  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27  * Except as contained in this notice, the name(s) of the above copyright
  28  * holders shall not be used in advertising or otherwise to promote the
  29  * sale, use or other dealings in this Software without prior written
  30  * authorization.
  31  *
  32  *
  33  * Copyright 1989  The Open Group
  34  *
  35  * Permission to use, copy, modify, distribute, and sell this software and its
  36  * documentation for any purpose is hereby granted without fee, provided that
  37  * the above copyright notice appear in all copies and that both that
  38  * copyright notice and this permission notice appear in supporting
  39  * documentation.
  40  *
  41  * The above copyright notice and this permission notice shall be included in
  42  * all copies or substantial portions of the Software.
  43  *
  44  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  45  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  46  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  47  * OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  48  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  49  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  50  *
  51  * Except as contained in this notice, the name of The Open Group shall not be
  52  * used in advertising or otherwise to promote the sale, use or other dealings
  53  * in this Software without prior written authorization from The Open Group.
  54  */
  55
  56 #include <xterm.h>
  57 #include <data.h>
  58 #include <menu.h>
  59 #include <fontutils.h>
  60 #include <xstrings.h>
  61
  62 #include <locale.h>
  63
  64 #include <X11/Xmu/CharSet.h>
  65
  66 #define app_con Xaw_app_con     /* quiet a warning from SimpleMenu.h */
  67
  68 #if defined(HAVE_LIB_XAW)
  69
  70 #include <X11/Xaw/SimpleMenu.h>
  71 #include <X11/Xaw/Box.h>
  72 #include <X11/Xaw/SmeBSB.h>
  73 #include <X11/Xaw/SmeLine.h>
  74
  75 #if OPT_MAXIMIZE
  76 #include <X11/Xatom.h>
  77 #include <X11/Xmd.h>
  78 #endif
  79
  80 #if OPT_TOOLBAR
  81 #include <X11/Xaw/MenuButton.h>
  82 #include <X11/Xaw/Form.h>
  83 #endif
  84
  85 #elif defined(HAVE_LIB_XAW3D)
  86
  87 #include <X11/Xaw3d/SimpleMenu.h>
  88 #include <X11/Xaw3d/Box.h>
  89 #include <X11/Xaw3d/SmeBSB.h>
  90 #include <X11/Xaw3d/SmeLine.h>
  91
  92 #if OPT_TOOLBAR
  93 #include <X11/Xaw3d/MenuButton.h>
  94 #include <X11/Xaw3d/Form.h>
  95 #endif
  96
  97 #elif defined(HAVE_LIB_NEXTAW)
  98
  99 #include <X11/neXtaw/SimpleMenu.h>
 100 #include <X11/neXtaw/Box.h>
 101 #include <X11/neXtaw/SmeBSB.h>
 102 #include <X11/neXtaw/SmeLine.h>
 103
 104 #if OPT_TOOLBAR
 105 #include <X11/neXtaw/MenuButton.h>
 106 #include <X11/neXtaw/Form.h>
 107 #endif
 108
 109 #elif defined(HAVE_LIB_XAWPLUS)
 110
 111 #include <X11/XawPlus/SimpleMenu.h>
 112 #include <X11/XawPlus/Box.h>
 113 #include <X11/XawPlus/SmeBSB.h>
 114 #include <X11/XawPlus/SmeLine.h>
 115
 116 #if OPT_TOOLBAR
 117 #include <X11/XawPlus/MenuButton.h>
 118 #include <X11/XawPlus/Form.h>
 119 #endif
 120
 121 #endif
 122
 123 #undef app_con
 124
 125 #include <stdio.h>
 126 #include <signal.h>
 127
 128 #if OPT_TRACE
 129 #define UpdateCheckbox(func, mn, mi, val) UpdateMenuItem(func, mn, mi, val)
 130 #else
 131 #define UpdateCheckbox(func, mn, mi, val) UpdateMenuItem(mn, mi, val)
 132 #endif
 133
 134 #define ToggleFlag(flag) flag = (Boolean) !flag
 135 /* *INDENT-OFF* */
 136 static void do_8bit_control    PROTO_XT_CALLBACK_ARGS;
 137 static void do_allow132        PROTO_XT_CALLBACK_ARGS;
 138 static void do_allowsends      PROTO_XT_CALLBACK_ARGS;
 139 static void do_altscreen       PROTO_XT_CALLBACK_ARGS;
 140 static void do_appcursor       PROTO_XT_CALLBACK_ARGS;
 141 static void do_appkeypad       PROTO_XT_CALLBACK_ARGS;
 142 static void do_autolinefeed    PROTO_XT_CALLBACK_ARGS;
 143 static void do_autowrap        PROTO_XT_CALLBACK_ARGS;
 144 static void do_backarrow       PROTO_XT_CALLBACK_ARGS;
 145 static void do_bellIsUrgent    PROTO_XT_CALLBACK_ARGS;
 146 static void do_clearsavedlines PROTO_XT_CALLBACK_ARGS;
 147 static void do_continue        PROTO_XT_CALLBACK_ARGS;
 148 static void do_delete_del      PROTO_XT_CALLBACK_ARGS;
 149 static void do_hardreset       PROTO_XT_CALLBACK_ARGS;
 150 static void do_interrupt       PROTO_XT_CALLBACK_ARGS;
 151 static void do_jumpscroll      PROTO_XT_CALLBACK_ARGS;
 152 static void do_kill            PROTO_XT_CALLBACK_ARGS;
 153 static void do_old_fkeys       PROTO_XT_CALLBACK_ARGS;
 154 static void do_poponbell       PROTO_XT_CALLBACK_ARGS;
 155 static void do_print           PROTO_XT_CALLBACK_ARGS;
 156 static void do_print_redir     PROTO_XT_CALLBACK_ARGS;
 157 static void do_quit            PROTO_XT_CALLBACK_ARGS;
 158 static void do_redraw          PROTO_XT_CALLBACK_ARGS;
 159 static void do_reversevideo    PROTO_XT_CALLBACK_ARGS;
 160 static void do_reversewrap     PROTO_XT_CALLBACK_ARGS;
 161 static void do_scrollbar       PROTO_XT_CALLBACK_ARGS;
 162 static void do_scrollkey       PROTO_XT_CALLBACK_ARGS;
 163 static void do_scrollttyoutput PROTO_XT_CALLBACK_ARGS;
 164 static void do_securekbd       PROTO_XT_CALLBACK_ARGS;
 165 static void do_keepSelection   PROTO_XT_CALLBACK_ARGS;
 166 static void do_selectClipboard PROTO_XT_CALLBACK_ARGS;
 167 static void do_softreset       PROTO_XT_CALLBACK_ARGS;
 168 static void do_suspend         PROTO_XT_CALLBACK_ARGS;
 169 static void do_terminate       PROTO_XT_CALLBACK_ARGS;
 170 static void do_titeInhibit     PROTO_XT_CALLBACK_ARGS;
 171 static void do_visualbell      PROTO_XT_CALLBACK_ARGS;
 172 static void do_vtfont          PROTO_XT_CALLBACK_ARGS;
 173
 174 #ifdef ALLOWLOGGING
 175 static void do_logging         PROTO_XT_CALLBACK_ARGS;
 176 #endif
 177
 178 #ifndef NO_ACTIVE_ICON
 179 static void do_activeicon      PROTO_XT_CALLBACK_ARGS;
 180 #endif /* NO_ACTIVE_ICON */
 181
 182 #if OPT_ALLOW_XXX_OPS
 183 static void enable_allow_xxx_ops (Bool);
 184 static void do_allowColorOps   PROTO_XT_CALLBACK_ARGS;
 185 static void do_allowFontOps    PROTO_XT_CALLBACK_ARGS;
 186 static void do_allowTcapOps    PROTO_XT_CALLBACK_ARGS;
 187 static void do_allowTitleOps   PROTO_XT_CALLBACK_ARGS;
 188 static void do_allowWindowOps  PROTO_XT_CALLBACK_ARGS;
 189 #endif
 190
 191 #if OPT_BLINK_CURS
 192 static void do_cursorblink     PROTO_XT_CALLBACK_ARGS;
 193 #endif
 194
 195 #if OPT_BOX_CHARS
 196 static void do_font_boxchars   PROTO_XT_CALLBACK_ARGS;
 197 static void do_font_packed     PROTO_XT_CALLBACK_ARGS;
 198 #endif
 199
 200 #if OPT_DEC_CHRSET
 201 static void do_font_doublesize PROTO_XT_CALLBACK_ARGS;
 202 #endif
 203
 204 #if OPT_DEC_SOFTFONT
 205 static void do_font_loadable   PROTO_XT_CALLBACK_ARGS;
 206 #endif
 207
 208 #if OPT_HP_FUNC_KEYS
 209 static void do_hp_fkeys        PROTO_XT_CALLBACK_ARGS;
 210 #endif
 211
 212 #if OPT_MAXIMIZE
 213 static void do_fullscreen      PROTO_XT_CALLBACK_ARGS;
 214 #endif
 215
 216 #if OPT_NUM_LOCK
 217 static void do_alt_esc         PROTO_XT_CALLBACK_ARGS;
 218 static void do_num_lock        PROTO_XT_CALLBACK_ARGS;
 219 static void do_meta_esc        PROTO_XT_CALLBACK_ARGS;
 220 #endif
 221
 222 #if OPT_RENDERFONT
 223 static void do_font_renderfont PROTO_XT_CALLBACK_ARGS;
 224 #endif
 225
 226 #if OPT_SCO_FUNC_KEYS
 227 static void do_sco_fkeys       PROTO_XT_CALLBACK_ARGS;
 228 #endif
 229
 230 #if OPT_SUN_FUNC_KEYS
 231 static void do_sun_fkeys       PROTO_XT_CALLBACK_ARGS;
 232 #endif
 233
 234 #if OPT_SUNPC_KBD
 235 static void do_sun_kbd         PROTO_XT_CALLBACK_ARGS;
 236 #endif
 237
 238 #if OPT_TCAP_FKEYS
 239 static void do_tcap_fkeys      PROTO_XT_CALLBACK_ARGS;
 240 #endif
 241
 242 #if OPT_TEK4014
 243 static void do_tekcopy         PROTO_XT_CALLBACK_ARGS;
 244 static void do_tekhide         PROTO_XT_CALLBACK_ARGS;
 245 static void do_tekmode         PROTO_XT_CALLBACK_ARGS;
 246 static void do_tekonoff        PROTO_XT_CALLBACK_ARGS;
 247 static void do_tekpage         PROTO_XT_CALLBACK_ARGS;
 248 static void do_tekreset        PROTO_XT_CALLBACK_ARGS;
 249 static void do_tekshow         PROTO_XT_CALLBACK_ARGS;
 250 static void do_tektext2        PROTO_XT_CALLBACK_ARGS;
 251 static void do_tektext3        PROTO_XT_CALLBACK_ARGS;
 252 static void do_tektextlarge    PROTO_XT_CALLBACK_ARGS;
 253 static void do_tektextsmall    PROTO_XT_CALLBACK_ARGS;
 254 static void do_vthide          PROTO_XT_CALLBACK_ARGS;
 255 static void do_vtmode          PROTO_XT_CALLBACK_ARGS;
 256 static void do_vtonoff         PROTO_XT_CALLBACK_ARGS;
 257 static void do_vtshow          PROTO_XT_CALLBACK_ARGS;
 258 static void handle_tekshow     (Widget gw, Bool allowswitch);
 259 static void handle_vtshow      (Widget gw, Bool allowswitch);
 260 #endif
 261
 262 #if OPT_TOOLBAR
 263 static void do_toolbar         PROTO_XT_CALLBACK_ARGS;
 264 #endif
 265
 266 #if OPT_WIDE_CHARS
 267 static void do_font_utf8_mode  PROTO_XT_CALLBACK_ARGS;
 268 static void do_font_utf8_title PROTO_XT_CALLBACK_ARGS;
 269 #endif
 270
 271 /*
 272  * The order of entries MUST match the values given in menu.h
 273  */
 274 MenuEntry mainMenuEntries[] = {
 275 #if OPT_TOOLBAR
 276     { "toolbar",        do_toolbar,     NULL },
 277 #endif
 278 #if OPT_MAXIMIZE
 279     { "fullscreen",     do_fullscreen,  NULL },
 280 #endif
 281     { "securekbd",      do_securekbd,   NULL },
 282     { "allowsends",     do_allowsends,  NULL },
 283     { "redraw",         do_redraw,      NULL },
 284     { "line1",          NULL,           NULL },
 285 #ifdef ALLOWLOGGING
 286     { "logging",        do_logging,     NULL },
 287 #endif
 288     { "print",          do_print,       NULL },
 289     { "print-redir",    do_print_redir, NULL },
 290     { "line2",          NULL,           NULL },
 291     { "8-bit control",  do_8bit_control,NULL },
 292     { "backarrow key",  do_backarrow,   NULL },
 293 #if OPT_NUM_LOCK
 294     { "num-lock",       do_num_lock,    NULL },
 295     { "alt-esc",        do_alt_esc,     NULL },
 296     { "meta-esc",       do_meta_esc,    NULL },
 297 #endif
 298     { "delete-is-del",  do_delete_del,  NULL },
 299     { "oldFunctionKeys",do_old_fkeys,   NULL },
 300 #if OPT_TCAP_FKEYS
 301     { "tcapFunctionKeys",do_tcap_fkeys, NULL },
 302 #endif
 303 #if OPT_HP_FUNC_KEYS
 304     { "hpFunctionKeys", do_hp_fkeys,    NULL },
 305 #endif
 306 #if OPT_SCO_FUNC_KEYS
 307     { "scoFunctionKeys",do_sco_fkeys,   NULL },
 308 #endif
 309 #if OPT_SUN_FUNC_KEYS
 310     { "sunFunctionKeys",do_sun_fkeys,   NULL },
 311 #endif
 312 #if OPT_SUNPC_KBD
 313     { "sunKeyboard",    do_sun_kbd,     NULL },
 314 #endif
 315     { "line3",          NULL,           NULL },
 316     { "suspend",        do_suspend,     NULL },
 317     { "continue",       do_continue,    NULL },
 318     { "interrupt",      do_interrupt,   NULL },
 319     { "hangup",         do_hangup,      NULL },
 320     { "terminate",      do_terminate,   NULL },
 321     { "kill",           do_kill,        NULL },
 322     { "line4",          NULL,           NULL },
 323     { "quit",           do_quit,        NULL }};
 324
 325 MenuEntry vtMenuEntries[] = {
 326     { "scrollbar",      do_scrollbar,   NULL },
 327     { "jumpscroll",     do_jumpscroll,  NULL },
 328     { "reversevideo",   do_reversevideo, NULL },
 329     { "autowrap",       do_autowrap,    NULL },
 330     { "reversewrap",    do_reversewrap, NULL },
 331     { "autolinefeed",   do_autolinefeed, NULL },
 332     { "appcursor",      do_appcursor,   NULL },
 333     { "appkeypad",      do_appkeypad,   NULL },
 334     { "scrollkey",      do_scrollkey,   NULL },
 335     { "scrollttyoutput",do_scrollttyoutput, NULL },
 336     { "allow132",       do_allow132,    NULL },
 337     { "keepSelection",  do_keepSelection, NULL },
 338     { "selectToClipboard",do_selectClipboard, NULL },
 339     { "visualbell",     do_visualbell,  NULL },
 340     { "bellIsUrgent",   do_bellIsUrgent, NULL },
 341     { "poponbell",      do_poponbell,   NULL },
 342 #if OPT_BLINK_CURS
 343     { "cursorblink",    do_cursorblink, NULL },
 344 #endif
 345     { "titeInhibit",    do_titeInhibit, NULL },
 346 #ifndef NO_ACTIVE_ICON
 347     { "activeicon",     do_activeicon,  NULL },
 348 #endif /* NO_ACTIVE_ICON */
 349     { "line1",          NULL,           NULL },
 350     { "softreset",      do_softreset,   NULL },
 351     { "hardreset",      do_hardreset,   NULL },
 352     { "clearsavedlines",do_clearsavedlines, NULL },
 353     { "line2",          NULL,           NULL },
 354 #if OPT_TEK4014
 355     { "tekshow",        do_tekshow,     NULL },
 356     { "tekmode",        do_tekmode,     NULL },
 357     { "vthide",         do_vthide,      NULL },
 358 #endif
 359     { "altscreen",      do_altscreen,   NULL },
 360     };
 361
 362 MenuEntry fontMenuEntries[] = {
 363     { "fontdefault",    do_vtfont,      NULL },
 364     { "font1",          do_vtfont,      NULL },
 365     { "font2",          do_vtfont,      NULL },
 366     { "font3",          do_vtfont,      NULL },
 367     { "font4",          do_vtfont,      NULL },
 368     { "font5",          do_vtfont,      NULL },
 369     { "font6",          do_vtfont,      NULL },
 370     /* this is after the last builtin font; the other entries are special */
 371     { "fontescape",     do_vtfont,      NULL },
 372     { "fontsel",        do_vtfont,      NULL },
 373     /* down to here should match NMENUFONTS in ptyx.h */
 374
 375 #if OPT_DEC_CHRSET || OPT_BOX_CHARS || OPT_DEC_SOFTFONT
 376     { "line1",          NULL,           NULL },
 377 #if OPT_BOX_CHARS
 378     { "font-linedrawing",do_font_boxchars,NULL },
 379     { "font-packed",    do_font_packed,NULL },
 380 #endif
 381 #if OPT_DEC_CHRSET
 382     { "font-doublesize",do_font_doublesize,NULL },
 383 #endif
 384 #if OPT_DEC_SOFTFONT
 385     { "font-loadable",  do_font_loadable,NULL },
 386 #endif
 387 #endif /* toggles for DEC font extensions */
 388
 389 #if OPT_RENDERFONT || OPT_WIDE_CHARS
 390     { "line2",          NULL,           NULL },
 391 #if OPT_RENDERFONT
 392     { "render-font",    do_font_renderfont,NULL },
 393 #endif
 394 #if OPT_WIDE_CHARS
 395     { "utf8-mode",      do_font_utf8_mode,NULL },
 396     { "utf8-title",     do_font_utf8_title,NULL },
 397 #endif
 398 #endif /* toggles for other font extensions */
 399
 400 #if OPT_ALLOW_XXX_OPS
 401     { "line3",          NULL,           NULL },
 402     { "allow-color-ops",do_allowColorOps,NULL },
 403     { "allow-font-ops", do_allowFontOps,NULL },
 404     { "allow-tcap-ops", do_allowTcapOps,NULL },
 405     { "allow-title-ops",do_allowTitleOps,NULL },
 406     { "allow-window-ops",do_allowWindowOps,NULL },
 407 #endif
 408
 409     };
 410
 411 #if OPT_TEK4014
 412 MenuEntry tekMenuEntries[] = {
 413     { "tektextlarge",   do_tektextlarge, NULL },
 414     { "tektext2",       do_tektext2,    NULL },
 415     { "tektext3",       do_tektext3,    NULL },
 416     { "tektextsmall",   do_tektextsmall, NULL },
 417     { "line1",          NULL,           NULL },
 418     { "tekpage",        do_tekpage,     NULL },
 419     { "tekreset",       do_tekreset,    NULL },
 420     { "tekcopy",        do_tekcopy,     NULL },
 421     { "line2",          NULL,           NULL },
 422     { "vtshow",         do_vtshow,      NULL },
 423     { "vtmode",         do_vtmode,      NULL },
 424     { "tekhide",        do_tekhide,     NULL }};
 425 #endif
 426
 427 typedef struct {
 428     char *internal_name;
 429     MenuEntry *entry_list;
 430     Cardinal entry_len;
 431 } MenuHeader;
 432
 433     /* This table is ordered to correspond with MenuIndex */
 434 static MenuHeader menu_names[] = {
 435     { "mainMenu", mainMenuEntries, XtNumber(mainMenuEntries) },
 436     { "vtMenu",   vtMenuEntries,   XtNumber(vtMenuEntries)   },
 437     { "fontMenu", fontMenuEntries, XtNumber(fontMenuEntries) },
 438 #if OPT_TEK4014
 439     { "tekMenu",  tekMenuEntries,  XtNumber(tekMenuEntries)  },
 440 #endif
 441     { 0,          0,               0 },
 442 };
 443 /* *INDENT-ON* */
 444
 445 /*
 446  * FIXME:  These are global data rather than in the xterm widget because they
 447  * are initialized before the widget is created.
 448  */
 449 typedef struct {
 450     Widget b;                   /* the toolbar's buttons */
 451     Widget w;                   /* the popup shell activated by the button */
 452     Cardinal entries;
 453 } MenuList;
 454
 455 static MenuList vt_shell[NUM_POPUP_MENUS];
 456
 457 #if OPT_TEK4014 && OPT_TOOLBAR
 458 static MenuList tek_shell[NUM_POPUP_MENUS];
 459 #endif
 460
 461 static String
 462 setMenuLocale(Bool before, String substitute)
 463 {
 464     String result = setlocale(LC_CTYPE, 0);
 465
 466     if (before) {
 467         result = x_strdup(result);
 468     }
 469     (void) setlocale(LC_CTYPE, substitute);
 470     TRACE(("setMenuLocale %s:%s\n",
 471            (before
 472             ? "before"
 473             : "after"),
 474            NonNull(result)));
 475     if (!before) {
 476         free((void *) substitute);
 477     }
 478     return result;
 479 }
 480
 481 /*
 482  * Returns a pointer to the MenuList entry that matches the popup menu.
 483  */
 484 static MenuList *
 485 select_menu(Widget w GCC_UNUSED, MenuIndex num)
 486 {
 487 #if OPT_TEK4014 && OPT_TOOLBAR
 488     while (w != 0) {
 489         if (w == tekshellwidget) {
 490             return &tek_shell[num];
 491         }
 492         w = XtParent(w);
 493     }
 494 #endif
 495     return &vt_shell[num];
 496 }
 497
 498 /*
 499  * Returns a pointer to the given popup menu shell
 500  */
 501 static Widget
 502 obtain_menu(Widget w, MenuIndex num)
 503 {
 504     return select_menu(w, num)->w;
 505 }
 506
 507 /*
 508  * Returns the number of entries in the given popup menu shell
 509  */
 510 static Cardinal
 511 sizeof_menu(Widget w, MenuIndex num)
 512 {
 513     return select_menu(w, num)->entries;
 514 }
 515
 516 /*
 517  * create_menu - create a popup shell and stuff the menu into it.
 518  */
 519
 520 static Widget
 521 create_menu(Widget w, XtermWidget xtw, MenuIndex num)
 522 {
 523     static XtCallbackRec cb[2] =
 524     {
 525         {NULL, NULL},
 526         {NULL, NULL}};
 527     static Arg arg =
 528     {XtNcallback, (XtArgVal) cb};
 529
 530     TScreen *screen = TScreenOf(xtw);
 531     MenuHeader *data = &menu_names[num];
 532     MenuList *list = select_menu(w, num);
 533     struct _MenuEntry *entries = data->entry_list;
 534     Cardinal nentries = data->entry_len;
 535 #if !OPT_TOOLBAR
 536     String saveLocale;
 537 #endif
 538
 539     if (screen->menu_item_bitmap == None) {
 540         /*
 541          * we really want to do these dynamically
 542          */
 543 #define check_width 9
 544 #define check_height 8
 545         static unsigned char check_bits[] =
 546         {
 547             0x00, 0x01, 0x80, 0x01, 0xc0, 0x00, 0x60, 0x00,
 548             0x31, 0x00, 0x1b, 0x00, 0x0e, 0x00, 0x04, 0x00
 549         };
 550
 551         screen->menu_item_bitmap =
 552             XCreateBitmapFromData(XtDisplay(xtw),
 553                                   RootWindowOfScreen(XtScreen(xtw)),
 554                                   (char *) check_bits, check_width, check_height);
 555     }
 556 #if !OPT_TOOLBAR
 557     saveLocale = setMenuLocale(True, resource.menuLocale);
 558     list->w = XtCreatePopupShell(data->internal_name,
 559                                  simpleMenuWidgetClass,
 560                                  toplevel,
 561                                  NULL, 0);
 562 #endif
 563     if (list->w != 0) {
 564         list->entries = nentries;
 565
 566         for (; nentries > 0; nentries--, entries++) {
 567             cb[0].callback = (XtCallbackProc) entries->function;
 568             cb[0].closure = (caddr_t) entries->name;
 569             entries->widget = XtCreateManagedWidget(entries->name,
 570                                                     (entries->function
 571                                                      ? smeBSBObjectClass
 572                                                      : smeLineObjectClass),
 573                                                     list->w,
 574                                                     &arg, (Cardinal) 1);
 575         }
 576     }
 577 #if !OPT_TOOLBAR
 578     (void) setMenuLocale(False, saveLocale);
 579 #endif
 580
 581     /* do not realize at this point */
 582     return list->w;
 583 }
 584
 585 static MenuIndex
 586 indexOfMenu(String menuName)
 587 {
 588     MenuIndex me;
 589     switch (*menuName) {
 590     case 'm':
 591         me = mainMenu;
 592         break;
 593     case 'v':
 594         me = vtMenu;
 595         break;
 596     case 'f':
 597         me = fontMenu;
 598         break;
 599 #if OPT_TEK4014
 600     case 't':
 601         me = tekMenu;
 602         break;
 603 #endif
 604     default:
 605         me = noMenu;
 606     }
 607     return (me);
 608 }
 609
 610 /* ARGSUSED */
 611 static Bool
 612 domenu(Widget w,
 613        XEvent * event GCC_UNUSED,
 614        String * params,         /* mainMenu, vtMenu, or tekMenu */
 615        Cardinal *param_count)   /* 0 or 1 */
 616 {
 617     XtermWidget xw = term;
 618     TScreen *screen = TScreenOf(xw);
 619     MenuIndex me;
 620     Bool created = False;
 621     Widget mw;
 622
 623     if (*param_count != 1) {
 624         Bell(xw, XkbBI_MinorError, 0);
 625         return False;
 626     }
 627
 628     if ((me = indexOfMenu(params[0])) == noMenu) {
 629         Bell(xw, XkbBI_MinorError, 0);
 630         return False;
 631     }
 632
 633     if ((mw = obtain_menu(w, me)) == 0
 634         || sizeof_menu(w, me) == 0) {
 635         mw = create_menu(w, xw, me);
 636         created = (mw != 0);
 637     }
 638     if (mw == 0)
 639         return False;
 640
 641     TRACE(("domenu(%s) %s\n", params[0], created ? "create" : "update"));
 642     switch (me) {
 643     case mainMenu:
 644         if (created) {
 645             update_toolbar();
 646             update_fullscreen();
 647             update_securekbd();
 648             update_allowsends();
 649             update_logging();
 650             update_print_redir();
 651             update_8bit_control();
 652             update_decbkm();
 653             update_num_lock();
 654             update_alt_esc();
 655             update_meta_esc();
 656             update_delete_del();
 657             update_keyboard_type();
 658 #if OPT_NUM_LOCK
 659             if (!screen->alt_is_not_meta) {
 660                 SetItemSensitivity(mainMenuEntries[mainMenu_alt_esc].widget,
 661                                    False);
 662             }
 663 #endif
 664             if (!xtermHasPrinter(xw)) {
 665                 SetItemSensitivity(mainMenuEntries[mainMenu_print].widget,
 666                                    False);
 667                 SetItemSensitivity(mainMenuEntries[mainMenu_print_redir].widget,
 668                                    False);
 669             }
 670             if (screen->terminal_id < 200) {
 671                 SetItemSensitivity(
 672                                       mainMenuEntries[mainMenu_8bit_ctrl].widget,
 673                                       False);
 674             }
 675 #if !defined(SIGTSTP)
 676             SetItemSensitivity(
 677                                   mainMenuEntries[mainMenu_suspend].widget, False);
 678 #endif
 679 #if !defined(SIGCONT)
 680             SetItemSensitivity(
 681                                   mainMenuEntries[mainMenu_continue].widget, False);
 682 #endif
 683 #ifdef ALLOWLOGGING
 684             if (screen->inhibit & I_LOG) {
 685                 SetItemSensitivity(
 686                                       mainMenuEntries[mainMenu_logging].widget, False);
 687             }
 688 #endif
 689             if (screen->inhibit & I_SIGNAL) {
 690                 int n;
 691                 for (n = (int) mainMenu_suspend; n <= (int) mainMenu_quit; ++n) {
 692                     SetItemSensitivity(mainMenuEntries[n].widget, False);
 693                 }
 694             }
 695         }
 696         break;
 697
 698     case vtMenu:
 699         if (created) {
 700             update_scrollbar();
 701             update_jumpscroll();
 702             update_reversevideo();
 703             update_autowrap();
 704             update_reversewrap();
 705             update_autolinefeed();
 706             update_appcursor();
 707             update_appkeypad();
 708             update_scrollkey();
 709             update_scrollttyoutput();
 710             update_allow132();
 711             update_cursesemul();
 712             update_keepSelection();
 713             update_selectToClipboard();
 714             update_visualbell();
 715             update_poponbell();
 716             update_bellIsUrgent();
 717             update_cursorblink();
 718             update_altscreen();
 719             update_titeInhibit();
 720 #ifndef NO_ACTIVE_ICON
 721             if (!screen->fnt_icon.fs || !screen->iconVwin.window) {
 722                 SetItemSensitivity(
 723                                       vtMenuEntries[vtMenu_activeicon].widget,
 724                                       False);
 725             } else
 726                 update_activeicon();
 727 #endif /* NO_ACTIVE_ICON */
 728 #if OPT_TEK4014
 729             if (screen->inhibit & I_TEK) {
 730                 int n;
 731                 for (n = (int) vtMenu_tekshow; n <= (int) vtMenu_vthide; ++n) {
 732                     SetItemSensitivity(vtMenuEntries[n].widget, False);
 733                 }
 734             }
 735 #endif
 736         }
 737         break;
 738
 739     case fontMenu:
 740         if (created) {
 741             set_menu_font(True);
 742             SetItemSensitivity(
 743                                   fontMenuEntries[fontMenu_fontescape].widget,
 744                                   (screen->menu_font_names[fontMenu_fontescape][fNorm]
 745                                    ? True : False));
 746 #if OPT_BOX_CHARS
 747             update_font_boxchars();
 748             SetItemSensitivity(
 749                                   fontMenuEntries[fontMenu_font_boxchars].widget,
 750                                   True);
 751             update_font_packed();
 752             SetItemSensitivity(
 753                                   fontMenuEntries[fontMenu_font_packedfont].widget,
 754                                   True);
 755 #endif
 756 #if OPT_DEC_SOFTFONT            /* FIXME: not implemented */
 757             update_font_loadable();
 758             SetItemSensitivity(
 759                                   fontMenuEntries[fontMenu_font_loadable].widget,
 760                                   False);
 761 #endif
 762 #if OPT_DEC_CHRSET
 763             update_font_doublesize();
 764             if (TScreenOf(xw)->cache_doublesize == 0)
 765                 SetItemSensitivity(
 766                                       fontMenuEntries[fontMenu_font_doublesize].widget,
 767                                       False);
 768 #endif
 769 #if OPT_RENDERFONT
 770             update_font_renderfont();
 771 #endif
 772 #if OPT_WIDE_CHARS
 773             update_font_utf8_mode();
 774             update_font_utf8_title();
 775 #endif
 776 #if OPT_ALLOW_XXX_OPS
 777             update_menu_allowColorOps();
 778             update_menu_allowFontOps();
 779             update_menu_allowTcapOps();
 780             update_menu_allowTitleOps();
 781             update_menu_allowWindowOps();
 782             enable_allow_xxx_ops(!(screen->allowSendEvents));
 783 #endif
 784         }
 785         FindFontSelection(xw, NULL, True);
 786         SetItemSensitivity(
 787                               fontMenuEntries[fontMenu_fontsel].widget,
 788                               (screen->menu_font_names[fontMenu_fontsel]
 789                                ? True : False));
 790         break;
 791
 792 #if OPT_TEK4014
 793     case tekMenu:
 794         if (created && tekWidget) {
 795             set_tekfont_menu_item(TekScreenOf(tekWidget)->cur.fontsize, True);
 796             update_vtshow();
 797         }
 798         break;
 799 #endif
 800     case noMenu:
 801     default:
 802         break;
 803     }
 804
 805     return True;
 806 }
 807
 808 /*
 809  * public interfaces
 810  */
 811
 812 void
 813 HandleCreateMenu(Widget w,
 814                  XEvent * event,
 815                  String * params,       /* mainMenu, vtMenu, or tekMenu */
 816                  Cardinal *param_count)         /* 0 or 1 */
 817 {
 818     TRACE(("HandleCreateMenu\n"));
 819     (void) domenu(w, event, params, param_count);
 820 }
 821
 822 void
 823 HandlePopupMenu(Widget w,
 824                 XEvent * event,
 825                 String * params,        /* mainMenu, vtMenu, or tekMenu */
 826                 Cardinal *param_count)  /* 0 or 1 */
 827 {
 828     TRACE(("HandlePopupMenu\n"));
 829     if (domenu(w, event, params, param_count)) {
 830 #if OPT_TOOLBAR
 831         w = select_menu(w, mainMenu)->w;
 832 #endif
 833         XtCallActionProc(w, "XawPositionSimpleMenu", event, params, 1);
 834         XtCallActionProc(w, "MenuPopup", event, params, 1);
 835     }
 836 }
 837
 838 /*
 839  * private interfaces - keep out!
 840  */
 841
 842 /* ARGSUSED */
 843 static void
 844 handle_send_signal(Widget gw GCC_UNUSED, int sig)
 845 {
 846 #ifndef VMS
 847     TScreen *screen = TScreenOf(term);
 848
 849     if (hold_screen > 1)
 850         hold_screen = 0;
 851     if (screen->pid > 1)
 852         kill_process_group(screen->pid, sig);
 853 #endif
 854 }
 855
 856 static void
 857 UpdateMenuItem(
 858 #if OPT_TRACE
 859                   const char *func,
 860 #endif
 861                   MenuEntry * menu,
 862                   int which,
 863                   Bool val)
 864 {
 865     static Arg menuArgs =
 866     {XtNleftBitmap, (XtArgVal) 0};
 867     Widget mi = menu[which].widget;
 868
 869     if (mi) {
 870         menuArgs.value = (XtArgVal) ((val)
 871                                      ? TScreenOf(term)->menu_item_bitmap
 872                                      : None);
 873         XtSetValues(mi, &menuArgs, (Cardinal) 1);
 874     }
 875     TRACE(("%s(%d): %s\n", func, which, BtoS(val)));
 876 }
 877
 878 void
 879 SetItemSensitivity(Widget mi, Bool val)
 880 {
 881     static Arg menuArgs =
 882     {XtNsensitive, (XtArgVal) 0};
 883
 884     if (mi) {
 885         menuArgs.value = (XtArgVal) (val);
 886         XtSetValues(mi, &menuArgs, (Cardinal) 1);
 887     }
 888 }
 889
 890 /*
 891  * action routines
 892  */
 893
 894 #if OPT_MAXIMIZE
 895
 896 static void
 897 set_resize_increments(XtermWidget xw)
 898 {
 899     TScreen *screen = TScreenOf(xw);
 900     int min_width = (2 * screen->border) + screen->fullVwin.sb_info.width;
 901     int min_height = (2 * screen->border);
 902     XSizeHints sizehints;
 903
 904     memset(&sizehints, 0, sizeof(XSizeHints));
 905     sizehints.width_inc = FontWidth(screen);
 906     sizehints.height_inc = FontHeight(screen);
 907     sizehints.flags = PResizeInc;
 908     XSetWMNormalHints(screen->display, VShellWindow(xw), &sizehints);
 909
 910     XtVaSetValues(SHELL_OF(xw),
 911                   XtNbaseWidth, min_width,
 912                   XtNbaseHeight, min_height,
 913                   XtNminWidth, min_width + FontWidth(screen),
 914                   XtNminHeight, min_height + FontHeight(screen),
 915                   XtNwidthInc, FontWidth(screen),
 916                   XtNheightInc, FontHeight(screen),
 917                   (XtPointer) 0);
 918
 919     XFlush(XtDisplay(xw));
 920 }
 921
 922 static void
 923 unset_resize_increments(XtermWidget xw)
 924 {
 925     TScreen *screen = TScreenOf(xw);
 926     XSizeHints sizehints;
 927
 928     memset(&sizehints, 0, sizeof(XSizeHints));
 929     sizehints.width_inc = 1;
 930     sizehints.height_inc = 1;
 931     sizehints.flags = PResizeInc;
 932     XSetWMNormalHints(screen->display, VShellWindow(xw), &sizehints);
 933
 934     XtVaSetValues(SHELL_OF(xw),
 935                   XtNwidthInc, 1,
 936                   XtNheightInc, 1,
 937                   (XtPointer) 0);
 938
 939     XFlush(XtDisplay(xw));
 940 }
 941
 942 static void
 943 netwm_fullscreen(XtermWidget xw, int operation)
 944 {
 945     TScreen *screen = TScreenOf(xw);
 946     XEvent e;
 947     Display *dpy = screen->display;
 948     Window window = VShellWindow(xw);
 949     Atom atom_fullscreen = XInternAtom(dpy, "_NET_WM_STATE_FULLSCREEN", False);
 950     Atom atom_state = XInternAtom(dpy, "_NET_WM_STATE", False);
 951
 952     memset(&e, 0, sizeof(e));
 953     e.xclient.type = ClientMessage;
 954     e.xclient.message_type = atom_state;
 955     e.xclient.display = dpy;
 956     e.xclient.window = window;
 957     e.xclient.format = 32;
 958     e.xclient.data.l[0] = operation;
 959     e.xclient.data.l[1] = (long) atom_fullscreen;
 960
 961     XSendEvent(dpy, DefaultRootWindow(dpy), False,
 962                SubstructureRedirectMask, &e);
 963 }
 964
 965 static Boolean
 966 probe_netwm_fullscreen_capability(XtermWidget xw)
 967 {
 968     TScreen *screen = TScreenOf(xw);
 969     Display *dpy = screen->display;
 970     Atom atom_fullscreen = XInternAtom(dpy, "_NET_WM_STATE_FULLSCREEN", False);
 971     Atom atom_supported = XInternAtom(dpy, "_NET_SUPPORTED", False);
 972     Atom actual_type;
 973     int actual_format;
 974     long long_offset = 0;
 975     long long_length = 128;     /* number of items to ask for at a time */
 976     unsigned int i;
 977     unsigned long nitems, bytes_after;
 978     unsigned char *args;
 979     CARD32 *ldata;
 980     Boolean netwm_fullscreen_capability = False;
 981     int rc;
 982
 983     while (!netwm_fullscreen_capability) {
 984         rc = XGetWindowProperty(dpy,
 985                                 DefaultRootWindow(dpy),
 986                                 atom_supported,
 987                                 long_offset,
 988                                 long_length,
 989                                 False,  /* do not delete */
 990                                 AnyPropertyType,        /* req_type */
 991                                 &actual_type,   /* actual_type_return */
 992                                 &actual_format,         /* actual_format_return */
 993                                 &nitems,        /* nitems_return */
 994                                 &bytes_after,   /* bytes_after_return */
 995                                 &args   /* prop_return */
 996             );
 997         if (rc != Success
 998             || actual_type != XA_ATOM) {
 999             break;
1000         }
1001
1002         ldata = (CARD32 *) (void *) args;
1003         for (i = 0; i < nitems; i++) {
1004             if (ldata[i] == atom_fullscreen) {
1005                 netwm_fullscreen_capability = True;
1006                 break;
1007             }
1008         }
1009         XFree(ldata);
1010
1011         if (!netwm_fullscreen_capability) {
1012             if (bytes_after != 0) {
1013                 long remaining = (long) (bytes_after / sizeof(CARD32));
1014                 if (long_length > remaining)
1015                     long_length = remaining;
1016                 long_offset += (long) nitems;
1017             } else {
1018                 break;
1019             }
1020         }
1021     }
1022
1023     return netwm_fullscreen_capability;
1024 }
1025
1026 static void
1027 do_fullscreen(Widget gw GCC_UNUSED,
1028               XtPointer closure GCC_UNUSED,
1029               XtPointer data GCC_UNUSED)
1030 {
1031     XtermWidget xw = term;
1032     TScreen *screen = TScreenOf(xw);
1033
1034     static Boolean initialized = False;
1035     static Boolean netwm_fullscreen_capability = False;
1036
1037     if (!initialized) {
1038         initialized = True;
1039         netwm_fullscreen_capability = probe_netwm_fullscreen_capability(xw);
1040     }
1041
1042     if (netwm_fullscreen_capability) {
1043         if (screen->fullscreen) {
1044             set_resize_increments(xw);
1045             netwm_fullscreen(xw, 0);
1046         } else {
1047             unset_resize_increments(xw);
1048             netwm_fullscreen(xw, 1);
1049         }
1050         screen->fullscreen = !screen->fullscreen;
1051         update_fullscreen();
1052     } else {
1053         Bell(xw, XkbBI_MinorError, 100);
1054     }
1055 }
1056
1057 /* ARGSUSED */
1058 void
1059 HandleFullscreen(Widget w,
1060                  XEvent * event GCC_UNUSED,
1061                  String * params GCC_UNUSED,
1062                  Cardinal *param_count GCC_UNUSED)
1063 {
1064     do_fullscreen(w, (XtPointer) 0, (XtPointer) 0);
1065 }
1066
1067 void
1068 update_fullscreen(void)
1069 {
1070     UpdateCheckbox("update_fullscreen",
1071                    mainMenuEntries,
1072                    mainMenu_fullscreen,
1073                    TScreenOf(term)->fullscreen);
1074 }
1075
1076 #endif /* OPT_MAXIMIZE */
1077
1078 static void
1079 do_securekbd(Widget gw GCC_UNUSED,
1080              XtPointer closure GCC_UNUSED,
1081              XtPointer data GCC_UNUSED)
1082 {
1083     XtermWidget xw = term;
1084     TScreen *screen = TScreenOf(xw);
1085     Time now = CurrentTime;     /* XXX - wrong */
1086
1087     if (screen->grabbedKbd) {
1088         XUngrabKeyboard(screen->display, now);
1089         ReverseVideo(xw);
1090         screen->grabbedKbd = False;
1091     } else {
1092         if (XGrabKeyboard(screen->display, XtWindow(CURRENT_EMU()),
1093                           True, GrabModeAsync, GrabModeAsync, now)
1094             != GrabSuccess) {
1095             Bell(xw, XkbBI_MinorError, 100);
1096         } else {
1097             ReverseVideo(xw);
1098             screen->grabbedKbd = True;
1099         }
1100     }
1101     update_securekbd();
1102 }
1103
1104 /* ARGSUSED */
1105 void
1106 HandleSecure(Widget w GCC_UNUSED,
1107              XEvent * event GCC_UNUSED,         /* unused */
1108              String * params GCC_UNUSED,        /* [0] = volume */
1109              Cardinal *param_count GCC_UNUSED)  /* 0 or 1 */
1110 {
1111 #if 0
1112     Time ev_time = CurrentTime;
1113
1114     if ((event->xany.type == KeyPress) ||
1115         (event->xany.type == KeyRelease))
1116         ev_time = event->xkey.time;
1117     else if ((event->xany.type == ButtonPress) ||
1118              (event->xany.type == ButtonRelease))
1119         ev_time = event->xbutton.time;
1120 #endif
1121     do_securekbd(vt_shell[mainMenu].w, (XtPointer) 0, (XtPointer) 0);
1122 }
1123
1124 static void
1125 do_allowsends(Widget gw GCC_UNUSED,
1126               XtPointer closure GCC_UNUSED,
1127               XtPointer data GCC_UNUSED)
1128 {
1129     TScreen *screen = TScreenOf(term);
1130
1131     ToggleFlag(screen->allowSendEvents);
1132     update_allowsends();
1133 #if OPT_ALLOW_XXX_OPS
1134     enable_allow_xxx_ops(!(screen->allowSendEvents));
1135 #endif
1136 }
1137
1138 static void
1139 do_visualbell(Widget gw GCC_UNUSED,
1140               XtPointer closure GCC_UNUSED,
1141               XtPointer data GCC_UNUSED)
1142 {
1143     TScreen *screen = TScreenOf(term);
1144
1145     ToggleFlag(screen->visualbell);
1146     update_visualbell();
1147 }
1148
1149 static void
1150 do_bellIsUrgent(Widget gw GCC_UNUSED,
1151                 XtPointer closure GCC_UNUSED,
1152                 XtPointer data GCC_UNUSED)
1153 {
1154     TScreen *screen = TScreenOf(term);
1155
1156     ToggleFlag(screen->bellIsUrgent);
1157     update_bellIsUrgent();
1158 }
1159
1160 static void
1161 do_poponbell(Widget gw GCC_UNUSED,
1162              XtPointer closure GCC_UNUSED,
1163              XtPointer data GCC_UNUSED)
1164 {
1165     TScreen *screen = TScreenOf(term);
1166
1167     ToggleFlag(screen->poponbell);
1168     update_poponbell();
1169 }
1170
1171 #ifdef ALLOWLOGGING
1172 static void
1173 do_logging(Widget gw GCC_UNUSED,
1174            XtPointer closure GCC_UNUSED,
1175            XtPointer data GCC_UNUSED)
1176 {
1177     XtermWidget xw = term;
1178     TScreen *screen = TScreenOf(xw);
1179
1180     if (screen->logging) {
1181         CloseLog(xw);
1182     } else {
1183         StartLog(xw);
1184     }
1185     /* update_logging done by CloseLog and StartLog */
1186 }
1187 #endif
1188
1189 static void
1190 do_print(Widget gw GCC_UNUSED,
1191          XtPointer closure GCC_UNUSED,
1192          XtPointer data GCC_UNUSED)
1193 {
1194     xtermPrintScreen(term, True, getPrinterFlags(term, NULL, 0));
1195 }
1196
1197 static void
1198 do_print_redir(Widget gw GCC_UNUSED,
1199                XtPointer closure GCC_UNUSED,
1200                XtPointer data GCC_UNUSED)
1201 {
1202     setPrinterControlMode(term, TScreenOf(term)->printer_controlmode ? 0 : 2);
1203 }
1204
1205 static void
1206 do_redraw(Widget gw GCC_UNUSED,
1207           XtPointer closure GCC_UNUSED,
1208           XtPointer data GCC_UNUSED)
1209 {
1210     Redraw();
1211 }
1212
1213 void
1214 show_8bit_control(Bool value)
1215 {
1216     if (TScreenOf(term)->control_eight_bits != value) {
1217         TScreenOf(term)->control_eight_bits = (Boolean) value;
1218         update_8bit_control();
1219     }
1220 }
1221
1222 static void
1223 do_8bit_control(Widget gw GCC_UNUSED,
1224                 XtPointer closure GCC_UNUSED,
1225                 XtPointer data GCC_UNUSED)
1226 {
1227     show_8bit_control(!TScreenOf(term)->control_eight_bits);
1228 }
1229
1230 static void
1231 do_backarrow(Widget gw GCC_UNUSED,
1232              XtPointer closure GCC_UNUSED,
1233              XtPointer data GCC_UNUSED)
1234 {
1235     term->keyboard.flags ^= MODE_DECBKM;
1236     update_decbkm();
1237 }
1238
1239 #if OPT_NUM_LOCK
1240 static void
1241 do_num_lock(Widget gw GCC_UNUSED,
1242             XtPointer closure GCC_UNUSED,
1243             XtPointer data GCC_UNUSED)
1244 {
1245     ToggleFlag(term->misc.real_NumLock);
1246     update_num_lock();
1247 }
1248
1249 static void
1250 do_alt_esc(Widget gw GCC_UNUSED,
1251            XtPointer closure GCC_UNUSED,
1252            XtPointer data GCC_UNUSED)
1253 {
1254     ToggleFlag(TScreenOf(term)->alt_sends_esc);
1255     update_alt_esc();
1256 }
1257
1258 static void
1259 do_meta_esc(Widget gw GCC_UNUSED,
1260             XtPointer closure GCC_UNUSED,
1261             XtPointer data GCC_UNUSED)
1262 {
1263     ToggleFlag(TScreenOf(term)->meta_sends_esc);
1264     update_meta_esc();
1265 }
1266 #endif
1267
1268 static void
1269 do_delete_del(Widget gw GCC_UNUSED,
1270               XtPointer closure GCC_UNUSED,
1271               XtPointer data GCC_UNUSED)
1272 {
1273     if (xtermDeleteIsDEL(term))
1274         TScreenOf(term)->delete_is_del = False;
1275     else
1276         TScreenOf(term)->delete_is_del = True;
1277     update_delete_del();
1278 }
1279
1280 static void
1281 do_old_fkeys(Widget gw GCC_UNUSED,
1282              XtPointer closure GCC_UNUSED,
1283              XtPointer data GCC_UNUSED)
1284 {
1285     toggle_keyboard_type(term, keyboardIsLegacy);
1286 }
1287
1288 #if OPT_HP_FUNC_KEYS
1289 static void
1290 do_hp_fkeys(Widget gw GCC_UNUSED,
1291             XtPointer closure GCC_UNUSED,
1292             XtPointer data GCC_UNUSED)
1293 {
1294     toggle_keyboard_type(term, keyboardIsHP);
1295 }
1296 #endif
1297
1298 #if OPT_SCO_FUNC_KEYS
1299 static void
1300 do_sco_fkeys(Widget gw GCC_UNUSED,
1301              XtPointer closure GCC_UNUSED,
1302              XtPointer data GCC_UNUSED)
1303 {
1304     toggle_keyboard_type(term, keyboardIsSCO);
1305 }
1306 #endif
1307
1308 #if OPT_SUN_FUNC_KEYS
1309 static void
1310 do_sun_fkeys(Widget gw GCC_UNUSED,
1311              XtPointer closure GCC_UNUSED,
1312              XtPointer data GCC_UNUSED)
1313 {
1314     toggle_keyboard_type(term, keyboardIsSun);
1315 }
1316 #endif
1317
1318 #if OPT_SUNPC_KBD
1319 /*
1320  * This really means "Sun/PC keyboard emulating VT220".
1321  */
1322 static void
1323 do_sun_kbd(Widget gw GCC_UNUSED,
1324            XtPointer closure GCC_UNUSED,
1325            XtPointer data GCC_UNUSED)
1326 {
1327     toggle_keyboard_type(term, keyboardIsVT220);
1328 }
1329 #endif
1330
1331 #if OPT_TCAP_FKEYS
1332 static void
1333 do_tcap_fkeys(Widget gw GCC_UNUSED,
1334               XtPointer closure GCC_UNUSED,
1335               XtPointer data GCC_UNUSED)
1336 {
1337     toggle_keyboard_type(term, keyboardIsTermcap);
1338 }
1339 #endif
1340
1341 /*
1342  * The following cases use the pid instead of the process group so that we
1343  * don't get hosed by programs that change their process group
1344  */
1345
1346 /* ARGSUSED */
1347 static void
1348 do_suspend(Widget gw,
1349            XtPointer closure GCC_UNUSED,
1350            XtPointer data GCC_UNUSED)
1351 {
1352 #if defined(SIGTSTP)
1353     handle_send_signal(gw, SIGTSTP);
1354 #endif
1355 }
1356
1357 /* ARGSUSED */
1358 static void
1359 do_continue(Widget gw,
1360             XtPointer closure GCC_UNUSED,
1361             XtPointer data GCC_UNUSED)
1362 {
1363 #if defined(SIGCONT)
1364     handle_send_signal(gw, SIGCONT);
1365 #endif
1366 }
1367
1368 /* ARGSUSED */
1369 static void
1370 do_interrupt(Widget gw,
1371              XtPointer closure GCC_UNUSED,
1372              XtPointer data GCC_UNUSED)
1373 {
1374     handle_send_signal(gw, SIGINT);
1375 }
1376
1377 /* ARGSUSED */
1378 void
1379 do_hangup(Widget gw,
1380           XtPointer closure GCC_UNUSED,
1381           XtPointer data GCC_UNUSED)
1382 {
1383     handle_send_signal(gw, SIGHUP);
1384 }
1385
1386 /* ARGSUSED */
1387 static void
1388 do_terminate(Widget gw,
1389              XtPointer closure GCC_UNUSED,
1390              XtPointer data GCC_UNUSED)
1391 {
1392     handle_send_signal(gw, SIGTERM);
1393 }
1394
1395 /* ARGSUSED */
1396 static void
1397 do_kill(Widget gw,
1398         XtPointer closure GCC_UNUSED,
1399         XtPointer data GCC_UNUSED)
1400 {
1401     handle_send_signal(gw, SIGKILL);
1402 }
1403
1404 static void
1405 do_quit(Widget gw GCC_UNUSED,
1406         XtPointer closure GCC_UNUSED,
1407         XtPointer data GCC_UNUSED)
1408 {
1409     Cleanup(SIGHUP);
1410 }
1411
1412 /*
1413  * vt menu callbacks
1414  */
1415
1416 static void
1417 do_scrollbar(Widget gw GCC_UNUSED,
1418              XtPointer closure GCC_UNUSED,
1419              XtPointer data GCC_UNUSED)
1420 {
1421     ToggleScrollBar(term);
1422 }
1423
1424 static void
1425 do_jumpscroll(Widget gw GCC_UNUSED,
1426               XtPointer closure GCC_UNUSED,
1427               XtPointer data GCC_UNUSED)
1428 {
1429     TScreen *screen = TScreenOf(term);
1430
1431     term->flags ^= SMOOTHSCROLL;
1432     if (term->flags & SMOOTHSCROLL) {
1433         screen->jumpscroll = False;
1434         if (screen->scroll_amt)
1435             FlushScroll(term);
1436     } else {
1437         screen->jumpscroll = True;
1438     }
1439     update_jumpscroll();
1440 }
1441
1442 static void
1443 do_reversevideo(Widget gw GCC_UNUSED,
1444                 XtPointer closure GCC_UNUSED,
1445                 XtPointer data GCC_UNUSED)
1446 {
1447     ReverseVideo(term);
1448 }
1449
1450 static void
1451 do_autowrap(Widget gw GCC_UNUSED,
1452             XtPointer closure GCC_UNUSED,
1453             XtPointer data GCC_UNUSED)
1454 {
1455     term->flags ^= WRAPAROUND;
1456     update_autowrap();
1457 }
1458
1459 static void
1460 do_reversewrap(Widget gw GCC_UNUSED,
1461                XtPointer closure GCC_UNUSED,
1462                XtPointer data GCC_UNUSED)
1463 {
1464     term->flags ^= REVERSEWRAP;
1465     update_reversewrap();
1466 }
1467
1468 static void
1469 do_autolinefeed(Widget gw GCC_UNUSED,
1470                 XtPointer closure GCC_UNUSED,
1471                 XtPointer data GCC_UNUSED)
1472 {
1473     term->flags ^= LINEFEED;
1474     update_autolinefeed();
1475 }
1476
1477 static void
1478 do_appcursor(Widget gw GCC_UNUSED,
1479              XtPointer closure GCC_UNUSED,
1480              XtPointer data GCC_UNUSED)
1481 {
1482     term->keyboard.flags ^= MODE_DECCKM;
1483     update_appcursor();
1484 }
1485
1486 static void
1487 do_appkeypad(Widget gw GCC_UNUSED,
1488              XtPointer closure GCC_UNUSED,
1489              XtPointer data GCC_UNUSED)
1490 {
1491     term->keyboard.flags ^= MODE_DECKPAM;
1492     update_appkeypad();
1493 }
1494
1495 static void
1496 do_scrollkey(Widget gw GCC_UNUSED,
1497              XtPointer closure GCC_UNUSED,
1498              XtPointer data GCC_UNUSED)
1499 {
1500     TScreen *screen = TScreenOf(term);
1501
1502     ToggleFlag(screen->scrollkey);
1503     update_scrollkey();
1504 }
1505
1506 static void
1507 do_scrollttyoutput(Widget gw GCC_UNUSED,
1508                    XtPointer closure GCC_UNUSED,
1509                    XtPointer data GCC_UNUSED)
1510 {
1511     TScreen *screen = TScreenOf(term);
1512
1513     ToggleFlag(screen->scrollttyoutput);
1514     update_scrollttyoutput();
1515 }
1516
1517 static void
1518 do_keepSelection(Widget gw GCC_UNUSED,
1519                  XtPointer closure GCC_UNUSED,
1520                  XtPointer data GCC_UNUSED)
1521 {
1522     TScreen *screen = TScreenOf(term);
1523
1524     ToggleFlag(screen->keepSelection);
1525     update_keepSelection();
1526 }
1527
1528 static void
1529 do_selectClipboard(Widget gw GCC_UNUSED,
1530                    XtPointer closure GCC_UNUSED,
1531                    XtPointer data GCC_UNUSED)
1532 {
1533     TScreen *screen = TScreenOf(term);
1534
1535     ToggleFlag(screen->selectToClipboard);
1536     update_selectToClipboard();
1537 }
1538
1539 static void
1540 do_allow132(Widget gw GCC_UNUSED,
1541             XtPointer closure GCC_UNUSED,
1542             XtPointer data GCC_UNUSED)
1543 {
1544     TScreen *screen = TScreenOf(term);
1545
1546     ToggleFlag(screen->c132);
1547     update_allow132();
1548 }
1549
1550 static void
1551 do_cursesemul(Widget gw GCC_UNUSED,
1552               XtPointer closure GCC_UNUSED,
1553               XtPointer data GCC_UNUSED)
1554 {
1555     TScreen *screen = TScreenOf(term);
1556
1557     ToggleFlag(screen->curses);
1558     update_cursesemul();
1559 }
1560
1561 static void
1562 do_marginbell(Widget gw GCC_UNUSED,
1563               XtPointer closure GCC_UNUSED,
1564               XtPointer data GCC_UNUSED)
1565 {
1566     TScreen *screen = TScreenOf(term);
1567
1568     if ((ToggleFlag(screen->marginbell)) == 0)
1569         screen->bellArmed = -1;
1570     update_marginbell();
1571 }
1572
1573 #if OPT_TEK4014
1574 static void
1575 handle_tekshow(Widget gw GCC_UNUSED, Bool allowswitch)
1576 {
1577     XtermWidget xw = term;
1578     TScreen *screen = TScreenOf(xw);
1579
1580     TRACE(("Show tek-window\n"));
1581     if (!TEK4014_SHOWN(xw)) {   /* not showing, turn on */
1582         set_tek_visibility(True);
1583     } else if (screen->Vshow || allowswitch) {  /* is showing, turn off */
1584         set_tek_visibility(False);
1585         end_tek_mode();         /* WARNING: this does a longjmp */
1586     } else
1587         Bell(xw, XkbBI_MinorError, 0);
1588 }
1589
1590 /* ARGSUSED */
1591 static void
1592 do_tekshow(Widget gw,
1593            XtPointer closure GCC_UNUSED,
1594            XtPointer data GCC_UNUSED)
1595 {
1596     handle_tekshow(gw, True);
1597 }
1598
1599 /* ARGSUSED */
1600 static void
1601 do_tekonoff(Widget gw,
1602             XtPointer closure GCC_UNUSED,
1603             XtPointer data GCC_UNUSED)
1604 {
1605     handle_tekshow(gw, False);
1606 }
1607 #endif /* OPT_TEK4014 */
1608
1609 #if OPT_BLINK_CURS
1610 /* ARGSUSED */
1611 static void
1612 do_cursorblink(Widget gw GCC_UNUSED,
1613                XtPointer closure GCC_UNUSED,
1614                XtPointer data GCC_UNUSED)
1615 {
1616     TScreen *screen = TScreenOf(term);
1617     ToggleCursorBlink(screen);
1618 }
1619 #endif
1620
1621 /* ARGSUSED */
1622 static void
1623 do_altscreen(Widget gw GCC_UNUSED,
1624              XtPointer closure GCC_UNUSED,
1625              XtPointer data GCC_UNUSED)
1626 {
1627     ToggleAlternate(term);
1628 }
1629
1630 /* ARGSUSED */
1631 static void
1632 do_titeInhibit(Widget gw GCC_UNUSED,
1633                XtPointer closure GCC_UNUSED,
1634                XtPointer data GCC_UNUSED)
1635 {
1636     ToggleFlag(term->misc.titeInhibit);
1637     update_titeInhibit();
1638 }
1639
1640 #ifndef NO_ACTIVE_ICON
1641 /* ARGSUSED */
1642 static void
1643 do_activeicon(Widget gw GCC_UNUSED,
1644               XtPointer closure GCC_UNUSED,
1645               XtPointer data GCC_UNUSED)
1646 {
1647     TScreen *screen = TScreenOf(term);
1648
1649     if (screen->iconVwin.window) {
1650         Widget shell = XtParent(term);
1651         ToggleFlag(term->misc.active_icon);
1652         XtVaSetValues(shell, XtNiconWindow,
1653                       term->misc.active_icon ? screen->iconVwin.window : None,
1654                       (XtPointer) 0);
1655         update_activeicon();
1656     }
1657 }
1658 #endif /* NO_ACTIVE_ICON */
1659
1660 static void
1661 do_softreset(Widget gw GCC_UNUSED,
1662              XtPointer closure GCC_UNUSED,
1663              XtPointer data GCC_UNUSED)
1664 {
1665     VTReset(term, False, False);
1666 }
1667
1668 static void
1669 do_hardreset(Widget gw GCC_UNUSED,
1670              XtPointer closure GCC_UNUSED,
1671              XtPointer data GCC_UNUSED)
1672 {
1673     VTReset(term, True, False);
1674 }
1675
1676 static void
1677 do_clearsavedlines(Widget gw GCC_UNUSED,
1678                    XtPointer closure GCC_UNUSED,
1679                    XtPointer data GCC_UNUSED)
1680 {
1681     VTReset(term, True, True);
1682 }
1683
1684 #if OPT_TEK4014
1685 static void
1686 do_tekmode(Widget gw GCC_UNUSED,
1687            XtPointer closure GCC_UNUSED,
1688            XtPointer data GCC_UNUSED)
1689 {
1690     switch_modes(TEK4014_ACTIVE(term));         /* switch to tek mode */
1691 }
1692
1693 /* ARGSUSED */
1694 static void
1695 do_vthide(Widget gw GCC_UNUSED,
1696           XtPointer closure GCC_UNUSED,
1697           XtPointer data GCC_UNUSED)
1698 {
1699     hide_vt_window();
1700 }
1701 #endif /* OPT_TEK4014 */
1702
1703 /*
1704  * vtfont menu
1705  */
1706
1707 static void
1708 do_vtfont(Widget gw GCC_UNUSED,
1709           XtPointer closure,
1710           XtPointer data GCC_UNUSED)
1711 {
1712     XtermWidget xw = term;
1713     char *entryname = (char *) closure;
1714     int i;
1715
1716     for (i = 0; i < NMENUFONTS; i++) {
1717         if (strcmp(entryname, fontMenuEntries[i].name) == 0) {
1718             SetVTFont(xw, i, True, NULL);
1719             return;
1720         }
1721     }
1722     Bell(xw, XkbBI_MinorError, 0);
1723 }
1724
1725 #if OPT_DEC_CHRSET
1726 static void
1727 do_font_doublesize(Widget gw GCC_UNUSED,
1728                    XtPointer closure GCC_UNUSED,
1729                    XtPointer data GCC_UNUSED)
1730 {
1731     XtermWidget xw = term;
1732
1733     if (TScreenOf(xw)->cache_doublesize != 0)
1734         ToggleFlag(TScreenOf(xw)->font_doublesize);
1735     update_font_doublesize();
1736     Redraw();
1737 }
1738 #endif
1739
1740 #if OPT_BOX_CHARS
1741 static void
1742 do_font_boxchars(Widget gw GCC_UNUSED,
1743                  XtPointer closure GCC_UNUSED,
1744                  XtPointer data GCC_UNUSED)
1745 {
1746     ToggleFlag(TScreenOf(term)->force_box_chars);
1747     update_font_boxchars();
1748     Redraw();
1749 }
1750
1751 static void
1752 do_font_packed(Widget gw GCC_UNUSED,
1753                XtPointer closure GCC_UNUSED,
1754                XtPointer data GCC_UNUSED)
1755 {
1756     ToggleFlag(TScreenOf(term)->force_packed);
1757     update_font_packed();
1758     SetVTFont(term, TScreenOf(term)->menu_font_number, True, NULL);
1759 }
1760 #endif
1761
1762 #if OPT_DEC_SOFTFONT
1763 static void
1764 do_font_loadable(Widget gw GCC_UNUSED,
1765                  XtPointer closure GCC_UNUSED,
1766                  XtPointer data GCC_UNUSED)
1767 {
1768     ToggleFlag(term->misc.font_loadable);
1769     update_font_loadable();
1770 }
1771 #endif
1772
1773 #if OPT_RENDERFONT
1774 static void
1775 do_font_renderfont(Widget gw GCC_UNUSED,
1776                    XtPointer closure GCC_UNUSED,
1777                    XtPointer data GCC_UNUSED)
1778 {
1779     XtermWidget xw = (XtermWidget) term;
1780     TScreen *screen = TScreenOf(xw);
1781     int fontnum = screen->menu_font_number;
1782     String name = TScreenOf(xw)->MenuFontName(fontnum);
1783
1784     DefaultRenderFont(xw);
1785     ToggleFlag(xw->misc.render_font);
1786     update_font_renderfont();
1787     xtermLoadFont(xw, xtermFontName(name), True, fontnum);
1788     ScrnRefresh(term, 0, 0,
1789                 MaxRows(screen),
1790                 MaxCols(screen), True);
1791 }
1792 #endif
1793
1794 #if OPT_WIDE_CHARS
1795 static void
1796 do_font_utf8_mode(Widget gw GCC_UNUSED,
1797                   XtPointer closure GCC_UNUSED,
1798                   XtPointer data GCC_UNUSED)
1799 {
1800     TScreen *screen = TScreenOf(term);
1801
1802     /*
1803      * If xterm was started with -wc option, it might not have the wide fonts.
1804      * If xterm was not started with -wc, it might not have wide cells.
1805      */
1806     if (!screen->utf8_mode) {
1807         if (screen->wide_chars) {
1808             if (xtermLoadWideFonts(term, True)) {
1809                 SetVTFont(term, screen->menu_font_number, True, NULL);
1810             }
1811         } else {
1812             ChangeToWide(term);
1813         }
1814     }
1815     switchPtyData(screen, !screen->utf8_mode);
1816     /*
1817      * We don't repaint the screen when switching UTF-8 on/off.  When switching
1818      * on - the Latin-1 codes should paint as-is.  When switching off, that's
1819      * hard to do properly.
1820      */
1821 }
1822
1823 static void
1824 do_font_utf8_title(Widget gw GCC_UNUSED,
1825                    XtPointer closure GCC_UNUSED,
1826                    XtPointer data GCC_UNUSED)
1827 {
1828     TScreen *screen = TScreenOf(term);
1829
1830     ToggleFlag(screen->utf8_title);
1831     update_font_utf8_title();
1832 }
1833 #endif
1834
1835 /*
1836  * tek menu
1837  */
1838
1839 #if OPT_TEK4014
1840 static void
1841 do_tektextlarge(Widget gw,
1842                 XtPointer closure GCC_UNUSED,
1843                 XtPointer data GCC_UNUSED)
1844 {
1845     TekSetFontSize(getTekWidget(gw), True, tekMenu_tektextlarge);
1846 }
1847
1848 static void
1849 do_tektext2(Widget gw,
1850             XtPointer closure GCC_UNUSED,
1851             XtPointer data GCC_UNUSED)
1852 {
1853     TekSetFontSize(getTekWidget(gw), True, tekMenu_tektext2);
1854 }
1855
1856 static void
1857 do_tektext3(Widget gw,
1858             XtPointer closure GCC_UNUSED,
1859             XtPointer data GCC_UNUSED)
1860 {
1861     TekSetFontSize(getTekWidget(gw), True, tekMenu_tektext3);
1862 }
1863
1864 static void
1865 do_tektextsmall(Widget gw,
1866                 XtPointer closure GCC_UNUSED,
1867                 XtPointer data GCC_UNUSED)
1868 {
1869     TekSetFontSize(getTekWidget(gw), True, tekMenu_tektextsmall);
1870 }
1871
1872 static void
1873 do_tekpage(Widget gw,
1874            XtPointer closure GCC_UNUSED,
1875            XtPointer data GCC_UNUSED)
1876 {
1877     TekSimulatePageButton(getTekWidget(gw), False);
1878 }
1879
1880 static void
1881 do_tekreset(Widget gw,
1882             XtPointer closure GCC_UNUSED,
1883             XtPointer data GCC_UNUSED)
1884 {
1885     TekSimulatePageButton(getTekWidget(gw), True);
1886 }
1887
1888 static void
1889 do_tekcopy(Widget gw,
1890            XtPointer closure GCC_UNUSED,
1891            XtPointer data GCC_UNUSED)
1892 {
1893     TekCopy(getTekWidget(gw));
1894 }
1895
1896 static void
1897 handle_vtshow(Widget gw GCC_UNUSED, Bool allowswitch)
1898 {
1899     XtermWidget xw = term;
1900     TScreen *screen = TScreenOf(xw);
1901
1902     TRACE(("Show vt-window\n"));
1903     if (!screen->Vshow) {       /* not showing, turn on */
1904         set_vt_visibility(True);
1905     } else if (TEK4014_SHOWN(xw) || allowswitch) {      /* is showing, turn off */
1906         set_vt_visibility(False);
1907         if (!TEK4014_ACTIVE(xw) && tekRefreshList)
1908             TekRefresh(tekWidget);
1909         end_vt_mode();          /* WARNING: this does a longjmp... */
1910     } else
1911         Bell(xw, XkbBI_MinorError, 0);
1912 }
1913
1914 static void
1915 do_vtshow(Widget gw,
1916           XtPointer closure GCC_UNUSED,
1917           XtPointer data GCC_UNUSED)
1918 {
1919     handle_vtshow(gw, True);
1920 }
1921
1922 static void
1923 do_vtonoff(Widget gw,
1924            XtPointer closure GCC_UNUSED,
1925            XtPointer data GCC_UNUSED)
1926 {
1927     handle_vtshow(gw, False);
1928 }
1929
1930 static void
1931 do_vtmode(Widget gw GCC_UNUSED,
1932           XtPointer closure GCC_UNUSED,
1933           XtPointer data GCC_UNUSED)
1934 {
1935     switch_modes(TEK4014_ACTIVE(term));         /* switch to vt, or from */
1936 }
1937
1938 /* ARGSUSED */
1939 static void
1940 do_tekhide(Widget gw GCC_UNUSED,
1941            XtPointer closure GCC_UNUSED,
1942            XtPointer data GCC_UNUSED)
1943 {
1944     hide_tek_window();
1945 }
1946 #endif /* OPT_TEK4014 */
1947
1948 /*
1949  * public handler routines
1950  */
1951
1952 static void
1953 handle_toggle(void (*proc) PROTO_XT_CALLBACK_ARGS,
1954               int var,
1955               String * params,
1956               Cardinal nparams,
1957               Widget w,
1958               XtPointer closure,
1959               XtPointer data)
1960 {
1961     XtermWidget xw = term;
1962     int dir = -2;
1963
1964     switch (nparams) {
1965     case 0:
1966         dir = -1;
1967         break;
1968     case 1:
1969         if (XmuCompareISOLatin1(params[0], "on") == 0)
1970             dir = 1;
1971         else if (XmuCompareISOLatin1(params[0], "off") == 0)
1972             dir = 0;
1973         else if (XmuCompareISOLatin1(params[0], "toggle") == 0)
1974             dir = -1;
1975         break;
1976     }
1977
1978     switch (dir) {
1979     case -2:
1980         Bell(xw, XkbBI_MinorError, 0);
1981         break;
1982
1983     case -1:
1984         (*proc) (w, closure, data);
1985         break;
1986
1987     case 0:
1988         if (var)
1989             (*proc) (w, closure, data);
1990         else
1991             Bell(xw, XkbBI_MinorError, 0);
1992         break;
1993
1994     case 1:
1995         if (!var)
1996             (*proc) (w, closure, data);
1997         else
1998             Bell(xw, XkbBI_MinorError, 0);
1999         break;
2000     }
2001     return;
2002 }
2003
2004 #define handle_vt_toggle(proc, var, params, nparams, w) \
2005         handle_toggle(proc, (int) (var), params, nparams, w, (XtPointer)0, (XtPointer)0)
2006
2007 #define HANDLE_VT_TOGGLE(name) \
2008         handle_vt_toggle(do_##name, TScreenOf(term)->name, params, *param_count, w)
2009
2010 #define handle_tek_toggle(proc, var, params, nparams, w) \
2011         handle_toggle(proc, (int) (var), params, nparams, w, (XtPointer)0, (XtPointer)0)
2012
2013 void
2014 HandleAllowSends(Widget w,
2015                  XEvent * event GCC_UNUSED,
2016                  String * params,
2017                  Cardinal *param_count)
2018 {
2019     handle_vt_toggle(do_allowsends, TScreenOf(term)->allowSendEvents,
2020                      params, *param_count, w);
2021 }
2022
2023 void
2024 HandleSetVisualBell(Widget w,
2025                     XEvent * event GCC_UNUSED,
2026                     String * params,
2027                     Cardinal *param_count)
2028 {
2029     HANDLE_VT_TOGGLE(visualbell);
2030 }
2031
2032 void
2033 HandleSetPopOnBell(Widget w,
2034                    XEvent * event GCC_UNUSED,
2035                    String * params,
2036                    Cardinal *param_count)
2037 {
2038     HANDLE_VT_TOGGLE(poponbell);
2039 }
2040
2041 #ifdef ALLOWLOGGING
2042 void
2043 HandleLogging(Widget w,
2044               XEvent * event GCC_UNUSED,
2045               String * params,
2046               Cardinal *param_count)
2047 {
2048     HANDLE_VT_TOGGLE(logging);
2049 }
2050 #endif
2051
2052 /* ARGSUSED */
2053 void
2054 HandlePrintScreen(Widget w GCC_UNUSED,
2055                   XEvent * event GCC_UNUSED,
2056                   String * params GCC_UNUSED,
2057                   Cardinal *param_count GCC_UNUSED)
2058 {
2059     xtermPrintScreen(term, True, getPrinterFlags(term, params, param_count));
2060 }
2061
2062 /* ARGSUSED */
2063 void
2064 HandlePrintEverything(Widget w GCC_UNUSED,
2065                       XEvent * event GCC_UNUSED,
2066                       String * params,
2067                       Cardinal *param_count)
2068 {
2069     xtermPrintEverything(term, getPrinterFlags(term, params, param_count));
2070 }
2071
2072 /* ARGSUSED */
2073 void
2074 HandlePrintControlMode(Widget w,
2075                        XEvent * event GCC_UNUSED,
2076                        String * params GCC_UNUSED,
2077                        Cardinal *param_count GCC_UNUSED)
2078 {
2079     do_print_redir(w, (XtPointer) 0, (XtPointer) 0);
2080 }
2081
2082 /* ARGSUSED */
2083 void
2084 HandleRedraw(Widget w,
2085              XEvent * event GCC_UNUSED,
2086              String * params GCC_UNUSED,
2087              Cardinal *param_count GCC_UNUSED)
2088 {
2089     do_redraw(w, (XtPointer) 0, (XtPointer) 0);
2090 }
2091
2092 /* ARGSUSED */
2093 void
2094 HandleSendSignal(Widget w,
2095                  XEvent * event GCC_UNUSED,
2096                  String * params,
2097                  Cardinal *param_count)
2098 {
2099     /* *INDENT-OFF* */
2100     static struct sigtab {
2101         const char *name;
2102         int sig;
2103     } signals[] = {
2104 #ifdef SIGTSTP
2105         { "suspend",    SIGTSTP },
2106         { "tstp",       SIGTSTP },
2107 #endif
2108 #ifdef SIGCONT
2109         { "cont",       SIGCONT },
2110 #endif
2111         { "int",        SIGINT },
2112         { "hup",        SIGHUP },
2113         { "quit",       SIGQUIT },
2114         { "alrm",       SIGALRM },
2115         { "alarm",      SIGALRM },
2116         { "term",       SIGTERM },
2117         { "kill",       SIGKILL },
2118         { NULL, 0 },
2119     };
2120     /* *INDENT-ON* */
2121
2122     if (*param_count == 1) {
2123         struct sigtab *st;
2124
2125         for (st = signals; st->name; st++) {
2126             if (XmuCompareISOLatin1(st->name, params[0]) == 0) {
2127                 handle_send_signal(w, st->sig);
2128                 return;
2129             }
2130         }
2131         /* one could allow numeric values, but that would be a security hole */
2132     }
2133
2134     Bell(term, XkbBI_MinorError, 0);
2135 }
2136
2137 /* ARGSUSED */
2138 void
2139 HandleQuit(Widget w,
2140            XEvent * event GCC_UNUSED,
2141            String * params GCC_UNUSED,
2142            Cardinal *param_count GCC_UNUSED)
2143 {
2144     do_quit(w, (XtPointer) 0, (XtPointer) 0);
2145 }
2146
2147 void
2148 Handle8BitControl(Widget w,
2149                   XEvent * event GCC_UNUSED,
2150                   String * params,
2151                   Cardinal *param_count)
2152 {
2153     handle_vt_toggle(do_8bit_control, TScreenOf(term)->control_eight_bits,
2154                      params, *param_count, w);
2155 }
2156
2157 void
2158 HandleBackarrow(Widget w,
2159                 XEvent * event GCC_UNUSED,
2160                 String * params,
2161                 Cardinal *param_count)
2162 {
2163     handle_vt_toggle(do_backarrow, term->keyboard.flags & MODE_DECBKM,
2164                      params, *param_count, w);
2165 }
2166
2167 #if OPT_SUN_FUNC_KEYS
2168 void
2169 HandleSunFunctionKeys(Widget w,
2170                       XEvent * event GCC_UNUSED,
2171                       String * params,
2172                       Cardinal *param_count)
2173 {
2174     handle_vt_toggle(do_sun_fkeys, term->keyboard.type == keyboardIsSun,
2175                      params, *param_count, w);
2176 }
2177 #endif
2178
2179 #if OPT_NUM_LOCK
2180 void
2181 HandleNumLock(Widget w,
2182               XEvent * event GCC_UNUSED,
2183               String * params,
2184               Cardinal *param_count)
2185 {
2186     handle_vt_toggle(do_num_lock, term->misc.real_NumLock,
2187                      params, *param_count, w);
2188 }
2189
2190 void
2191 HandleAltEsc(Widget w,
2192              XEvent * event GCC_UNUSED,
2193              String * params,
2194              Cardinal *param_count)
2195 {
2196     handle_vt_toggle(do_alt_esc, !TScreenOf(term)->input_eight_bits,
2197                      params, *param_count, w);
2198 }
2199
2200 void
2201 HandleMetaEsc(Widget w,
2202               XEvent * event GCC_UNUSED,
2203               String * params,
2204               Cardinal *param_count)
2205 {
2206     handle_vt_toggle(do_meta_esc, TScreenOf(term)->meta_sends_esc,
2207                      params, *param_count, w);
2208 }
2209 #endif
2210
2211 void
2212 HandleDeleteIsDEL(Widget w,
2213                   XEvent * event GCC_UNUSED,
2214                   String * params,
2215                   Cardinal *param_count)
2216 {
2217     handle_vt_toggle(do_delete_del, TScreenOf(term)->delete_is_del,
2218                      params, *param_count, w);
2219 }
2220
2221 void
2222 HandleOldFunctionKeys(Widget w,
2223                       XEvent * event GCC_UNUSED,
2224                       String * params,
2225                       Cardinal *param_count)
2226 {
2227     handle_vt_toggle(do_old_fkeys, term->keyboard.type == keyboardIsLegacy,
2228                      params, *param_count, w);
2229 }
2230
2231 #if OPT_SUNPC_KBD
2232 void
2233 HandleSunKeyboard(Widget w,
2234                   XEvent * event GCC_UNUSED,
2235                   String * params,
2236                   Cardinal *param_count)
2237 {
2238     handle_vt_toggle(do_sun_kbd, term->keyboard.type == keyboardIsVT220,
2239                      params, *param_count, w);
2240 }
2241 #endif
2242
2243 #if OPT_HP_FUNC_KEYS
2244 void
2245 HandleHpFunctionKeys(Widget w,
2246                      XEvent * event GCC_UNUSED,
2247                      String * params,
2248                      Cardinal *param_count)
2249 {
2250     handle_vt_toggle(do_hp_fkeys, term->keyboard.type == keyboardIsHP,
2251                      params, *param_count, w);
2252 }
2253 #endif
2254
2255 #if OPT_SCO_FUNC_KEYS
2256 void
2257 HandleScoFunctionKeys(Widget w,
2258                       XEvent * event GCC_UNUSED,
2259                       String * params,
2260                       Cardinal *param_count)
2261 {
2262     handle_vt_toggle(do_sco_fkeys, term->keyboard.type == keyboardIsSCO,
2263                      params, *param_count, w);
2264 }
2265 #endif
2266
2267 void
2268 HandleScrollbar(Widget w,
2269                 XEvent * event GCC_UNUSED,
2270                 String * params,
2271                 Cardinal *param_count)
2272 {
2273     XtermWidget xw = term;
2274
2275     if (IsIcon(TScreenOf(xw))) {
2276         Bell(xw, XkbBI_MinorError, 0);
2277     } else {
2278         handle_vt_toggle(do_scrollbar, TScreenOf(xw)->fullVwin.sb_info.width,
2279                          params, *param_count, w);
2280     }
2281 }
2282
2283 void
2284 HandleJumpscroll(Widget w,
2285                  XEvent * event GCC_UNUSED,
2286                  String * params,
2287                  Cardinal *param_count)
2288 {
2289     HANDLE_VT_TOGGLE(jumpscroll);
2290 }
2291
2292 void
2293 HandleKeepSelection(Widget w,
2294                     XEvent * event GCC_UNUSED,
2295                     String * params,
2296                     Cardinal *param_count)
2297 {
2298     HANDLE_VT_TOGGLE(keepSelection);
2299 }
2300
2301 void
2302 HandleSetSelect(Widget w,
2303                 XEvent * event GCC_UNUSED,
2304                 String * params,
2305                 Cardinal *param_count)
2306 {
2307     handle_vt_toggle(do_selectClipboard, TScreenOf(term)->selectToClipboard,
2308                      params, *param_count, w);
2309 }
2310
2311 void
2312 HandleReverseVideo(Widget w,
2313                    XEvent * event GCC_UNUSED,
2314                    String * params,
2315                    Cardinal *param_count)
2316 {
2317     handle_vt_toggle(do_reversevideo, (term->misc.re_verse0),
2318                      params, *param_count, w);
2319 }
2320
2321 void
2322 HandleAutoWrap(Widget w,
2323                XEvent * event GCC_UNUSED,
2324                String * params,
2325                Cardinal *param_count)
2326 {
2327     handle_vt_toggle(do_autowrap, (term->flags & WRAPAROUND),
2328                      params, *param_count, w);
2329 }
2330
2331 void
2332 HandleReverseWrap(Widget w,
2333                   XEvent * event GCC_UNUSED,
2334                   String * params,
2335                   Cardinal *param_count)
2336 {
2337     handle_vt_toggle(do_reversewrap, (term->flags & REVERSEWRAP),
2338                      params, *param_count, w);
2339 }
2340
2341 void
2342 HandleAutoLineFeed(Widget w,
2343                    XEvent * event GCC_UNUSED,
2344                    String * params,
2345                    Cardinal *param_count)
2346 {
2347     handle_vt_toggle(do_autolinefeed, (term->flags & LINEFEED),
2348                      params, *param_count, w);
2349 }
2350
2351 void
2352 HandleAppCursor(Widget w,
2353                 XEvent * event GCC_UNUSED,
2354                 String * params,
2355                 Cardinal *param_count)
2356 {
2357     handle_vt_toggle(do_appcursor, (term->keyboard.flags & MODE_DECCKM),
2358                      params, *param_count, w);
2359 }
2360
2361 void
2362 HandleAppKeypad(Widget w,
2363                 XEvent * event GCC_UNUSED,
2364                 String * params,
2365                 Cardinal *param_count)
2366 {
2367     handle_vt_toggle(do_appkeypad, (term->keyboard.flags & MODE_DECKPAM),
2368                      params, *param_count, w);
2369 }
2370
2371 void
2372 HandleScrollKey(Widget w,
2373                 XEvent * event GCC_UNUSED,
2374                 String * params,
2375                 Cardinal *param_count)
2376 {
2377     HANDLE_VT_TOGGLE(scrollkey);
2378 }
2379
2380 void
2381 HandleScrollTtyOutput(Widget w,
2382                       XEvent * event GCC_UNUSED,
2383                       String * params,
2384                       Cardinal *param_count)
2385 {
2386     HANDLE_VT_TOGGLE(scrollttyoutput);
2387 }
2388
2389 void
2390 HandleAllow132(Widget w,
2391                XEvent * event GCC_UNUSED,
2392                String * params,
2393                Cardinal *param_count)
2394 {
2395     handle_vt_toggle(do_allow132, TScreenOf(term)->c132,
2396                      params, *param_count, w);
2397 }
2398
2399 void
2400 HandleCursesEmul(Widget w,
2401                  XEvent * event GCC_UNUSED,
2402                  String * params,
2403                  Cardinal *param_count)
2404 {
2405     handle_vt_toggle(do_cursesemul, TScreenOf(term)->curses,
2406                      params, *param_count, w);
2407 }
2408
2409 void
2410 HandleBellIsUrgent(Widget w,
2411                    XEvent * event GCC_UNUSED,
2412                    String * params,
2413                    Cardinal *param_count)
2414 {
2415     HANDLE_VT_TOGGLE(bellIsUrgent);
2416 }
2417
2418 void
2419 HandleMarginBell(Widget w,
2420                  XEvent * event GCC_UNUSED,
2421                  String * params,
2422                  Cardinal *param_count)
2423 {
2424     HANDLE_VT_TOGGLE(marginbell);
2425 }
2426
2427 #if OPT_BLINK_CURS
2428 void
2429 HandleCursorBlink(Widget w,
2430                   XEvent * event GCC_UNUSED,
2431                   String * params,
2432                   Cardinal *param_count)
2433 {
2434     /* eventually want to see if sensitive or not */
2435     handle_vt_toggle(do_cursorblink, TScreenOf(term)->cursor_blink,
2436                      params, *param_count, w);
2437 }
2438 #endif
2439
2440 void
2441 HandleAltScreen(Widget w,
2442                 XEvent * event GCC_UNUSED,
2443                 String * params,
2444                 Cardinal *param_count)
2445 {
2446     /* eventually want to see if sensitive or not */
2447     handle_vt_toggle(do_altscreen, TScreenOf(term)->whichBuf,
2448                      params, *param_count, w);
2449 }
2450
2451 void
2452 HandleTiteInhibit(Widget w,
2453                   XEvent * event GCC_UNUSED,
2454                   String * params,
2455                   Cardinal *param_count)
2456 {
2457     /* eventually want to see if sensitive or not */
2458     handle_vt_toggle(do_titeInhibit, !(term->misc.titeInhibit),
2459                      params, *param_count, w);
2460 }
2461
2462 /* ARGSUSED */
2463 void
2464 HandleSoftReset(Widget w,
2465                 XEvent * event GCC_UNUSED,
2466                 String * params GCC_UNUSED,
2467                 Cardinal *param_count GCC_UNUSED)
2468 {
2469     do_softreset(w, (XtPointer) 0, (XtPointer) 0);
2470 }
2471
2472 /* ARGSUSED */
2473 void
2474 HandleHardReset(Widget w,
2475                 XEvent * event GCC_UNUSED,
2476                 String * params GCC_UNUSED,
2477                 Cardinal *param_count GCC_UNUSED)
2478 {
2479     do_hardreset(w, (XtPointer) 0, (XtPointer) 0);
2480 }
2481
2482 /* ARGSUSED */
2483 void
2484 HandleClearSavedLines(Widget w,
2485                       XEvent * event GCC_UNUSED,
2486                       String * params GCC_UNUSED,
2487                       Cardinal *param_count GCC_UNUSED)
2488 {
2489     do_clearsavedlines(w, (XtPointer) 0, (XtPointer) 0);
2490 }
2491
2492 #if OPT_DEC_CHRSET
2493 void
2494 HandleFontDoublesize(Widget w,
2495                      XEvent * event GCC_UNUSED,
2496                      String * params,
2497                      Cardinal *param_count)
2498 {
2499     HANDLE_VT_TOGGLE(font_doublesize);
2500 }
2501 #endif
2502
2503 #if OPT_BOX_CHARS
2504 void
2505 HandleFontBoxChars(Widget w,
2506                    XEvent * event GCC_UNUSED,
2507                    String * params,
2508                    Cardinal *param_count)
2509 {
2510     handle_vt_toggle(do_font_boxchars, TScreenOf(term)->force_box_chars,
2511                      params, *param_count, w);
2512 }
2513
2514 void
2515 HandleFontPacked(Widget w,
2516                  XEvent * event GCC_UNUSED,
2517                  String * params,
2518                  Cardinal *param_count)
2519 {
2520     handle_vt_toggle(do_font_packed, TScreenOf(term)->force_packed,
2521                      params, *param_count, w);
2522 }
2523 #endif
2524
2525 #if OPT_DEC_SOFTFONT
2526 void
2527 HandleFontLoading(Widget w,
2528                   XEvent * event GCC_UNUSED,
2529                   String * params,
2530                   Cardinal *param_count)
2531 {
2532     handle_vt_toggle(do_font_loadable, term->misc.font_loadable,
2533                      params, *param_count, w);
2534 }
2535 #endif
2536
2537 #if OPT_RENDERFONT
2538 void
2539 HandleRenderFont(Widget w,
2540                  XEvent * event GCC_UNUSED,
2541                  String * params,
2542                  Cardinal *param_count)
2543 {
2544     XtermWidget xw = (XtermWidget) term;
2545
2546     DefaultRenderFont(xw);
2547
2548     handle_vt_toggle(do_font_renderfont, xw->misc.render_font,
2549                      params, *param_count, w);
2550 }
2551 #endif
2552
2553 #if OPT_WIDE_CHARS
2554 void
2555 HandleUTF8Mode(Widget w,
2556                XEvent * event GCC_UNUSED,
2557                String * params,
2558                Cardinal *param_count)
2559 {
2560     handle_vt_toggle(do_font_utf8_mode, TScreenOf(term)->utf8_mode,
2561                      params, *param_count, w);
2562 }
2563
2564 void
2565 HandleUTF8Title(Widget w,
2566                 XEvent * event GCC_UNUSED,
2567                 String * params,
2568                 Cardinal *param_count)
2569 {
2570     handle_vt_toggle(do_font_utf8_title, TScreenOf(term)->utf8_title,
2571                      params, *param_count, w);
2572 }
2573 #endif
2574
2575 #if OPT_TEK4014
2576 void
2577 HandleSetTerminalType(Widget w,
2578                       XEvent * event GCC_UNUSED,
2579                       String * params,
2580                       Cardinal *param_count)
2581 {
2582     XtermWidget xw = term;
2583
2584     if (*param_count == 1) {
2585         switch (params[0][0]) {
2586         case 'v':
2587         case 'V':
2588             if (TEK4014_ACTIVE(xw))
2589                 do_vtmode(w, (XtPointer) 0, (XtPointer) 0);
2590             break;
2591         case 't':
2592         case 'T':
2593             if (!TEK4014_ACTIVE(xw))
2594                 do_tekmode(w, (XtPointer) 0, (XtPointer) 0);
2595             break;
2596         default:
2597             Bell(xw, XkbBI_MinorError, 0);
2598         }
2599     } else {
2600         Bell(xw, XkbBI_MinorError, 0);
2601     }
2602 }
2603
2604 void
2605 HandleVisibility(Widget w,
2606                  XEvent * event GCC_UNUSED,
2607                  String * params,
2608                  Cardinal *param_count)
2609 {
2610     XtermWidget xw = term;
2611
2612     if (*param_count == 2) {
2613         switch (params[0][0]) {
2614         case 'v':
2615         case 'V':
2616             handle_tek_toggle(do_vtonoff, (int) TScreenOf(xw)->Vshow,
2617                               params + 1, (*param_count) - 1, w);
2618             break;
2619         case 't':
2620         case 'T':
2621             handle_tek_toggle(do_tekonoff, (int) TEK4014_SHOWN(xw),
2622                               params + 1, (*param_count) - 1, w);
2623             break;
2624         default:
2625             Bell(xw, XkbBI_MinorError, 0);
2626         }
2627     } else {
2628         Bell(xw, XkbBI_MinorError, 0);
2629     }
2630 }
2631
2632 /* ARGSUSED */
2633 void
2634 HandleSetTekText(Widget w,
2635                  XEvent * event GCC_UNUSED,
2636                  String * params,
2637                  Cardinal *param_count)
2638 {
2639     XtermWidget xw = term;
2640     void (*proc) PROTO_XT_CALLBACK_ARGS = 0;
2641
2642     switch (*param_count) {
2643     case 0:
2644         proc = do_tektextlarge;
2645         break;
2646     case 1:
2647         switch (TekGetFontSize(params[0])) {
2648         case TEK_FONT_LARGE:
2649             proc = do_tektextlarge;
2650             break;
2651         case TEK_FONT_2:
2652             proc = do_tektext2;
2653             break;
2654         case TEK_FONT_3:
2655             proc = do_tektext3;
2656             break;
2657         case TEK_FONT_SMALL:
2658             proc = do_tektextsmall;
2659             break;
2660         }
2661         break;
2662     }
2663     if (proc)
2664         (*proc) (w, (XtPointer) 0, (XtPointer) 0);
2665     else
2666         Bell(xw, XkbBI_MinorError, 0);
2667 }
2668
2669 /* ARGSUSED */
2670 void
2671 HandleTekPage(Widget w,
2672               XEvent * event GCC_UNUSED,
2673               String * params GCC_UNUSED,
2674               Cardinal *param_count GCC_UNUSED)
2675 {
2676     do_tekpage(w, (XtPointer) 0, (XtPointer) 0);
2677 }
2678
2679 /* ARGSUSED */
2680 void
2681 HandleTekReset(Widget w,
2682                XEvent * event GCC_UNUSED,
2683                String * params GCC_UNUSED,
2684                Cardinal *param_count GCC_UNUSED)
2685 {
2686     do_tekreset(w, (XtPointer) 0, (XtPointer) 0);
2687 }
2688
2689 /* ARGSUSED */
2690 void
2691 HandleTekCopy(Widget w,
2692               XEvent * event GCC_UNUSED,
2693               String * params GCC_UNUSED,
2694               Cardinal *param_count GCC_UNUSED)
2695 {
2696     do_tekcopy(w, (XtPointer) 0, (XtPointer) 0);
2697 }
2698 #endif /* OPT_TEK4014 */
2699
2700 #if OPT_TOOLBAR
2701 /*
2702  * The normal style of xterm popup menu delays initialization until the menu is
2703  * first requested.  When using a toolbar, we can use the same initialization,
2704  * though on the first popup there will be a little geometry layout jitter,
2705  * since the menu is already managed when this callback is invoked.
2706  */
2707 static void
2708 InitPopup(Widget gw,
2709           XtPointer closure,
2710           XtPointer data GCC_UNUSED)
2711 {
2712     String params[2];
2713     Cardinal count = 1;
2714
2715     params[0] = (char *) closure;
2716     params[1] = 0;
2717     TRACE(("InitPopup(%s)\n", params[0]));
2718
2719     domenu(gw, (XEvent *) 0, params, &count);
2720
2721     if (gw)
2722         XtRemoveCallback(gw, XtNpopupCallback, InitPopup, closure);
2723 }
2724
2725 static Dimension
2726 SetupShell(Widget *menus, MenuList * shell, int n, int m)
2727 {
2728     char temp[80];
2729     char *external_name = 0;
2730     Dimension button_height;
2731     Dimension button_border;
2732     String saveLocale = setMenuLocale(True, resource.menuLocale);
2733
2734     shell[n].w = XtVaCreatePopupShell(menu_names[n].internal_name,
2735                                       simpleMenuWidgetClass,
2736                                       *menus,
2737                                       XtNgeometry, NULL,
2738                                       (XtPointer) 0);
2739
2740     XtAddCallback(shell[n].w, XtNpopupCallback, InitPopup, menu_names[n].internal_name);
2741     XtVaGetValues(shell[n].w,
2742                   XtNlabel, &external_name,
2743                   (XtPointer) 0);
2744
2745     TRACE(("...SetupShell(%s) -> %s -> %#lx\n",
2746            menu_names[n].internal_name,
2747            external_name,
2748            (long) shell[n].w));
2749
2750     sprintf(temp, "%sButton", menu_names[n].internal_name);
2751     shell[n].b = XtVaCreateManagedWidget(temp,
2752                                          menuButtonWidgetClass,
2753                                          *menus,
2754                                          XtNfromHoriz, ((m >= 0)
2755                                                         ? shell[m].b
2756                                                         : 0),
2757                                          XtNmenuName, menu_names[n].internal_name,
2758                                          XtNlabel, external_name,
2759                                          (XtPointer) 0);
2760     XtVaGetValues(shell[n].b,
2761                   XtNheight, &button_height,
2762                   XtNborderWidth, &button_border,
2763                   (XtPointer) 0);
2764
2765     (void) setMenuLocale(False, saveLocale);
2766     return (Dimension) (button_height + (button_border * 2));
2767 }
2768 #endif /* OPT_TOOLBAR */
2769
2770 void
2771 SetupMenus(Widget shell, Widget *forms, Widget *menus, Dimension * menu_high)
2772 {
2773 #if OPT_TOOLBAR
2774     Dimension button_height = 0;
2775     Dimension toolbar_hSpace;
2776     Arg args[10];
2777 #endif
2778
2779     TRACE(("SetupMenus(%s)\n", shell == toplevel ? "vt100" : "tek4014"));
2780
2781     *menu_high = 0;
2782
2783     if (shell == toplevel) {
2784         XawSimpleMenuAddGlobalActions(app_con);
2785         XtRegisterGrabAction(HandlePopupMenu, True,
2786                              (ButtonPressMask | ButtonReleaseMask),
2787                              GrabModeAsync, GrabModeAsync);
2788     }
2789 #if OPT_TOOLBAR
2790     *forms = XtVaCreateManagedWidget("form",
2791                                      formWidgetClass, shell,
2792                                      (XtPointer) 0);
2793     xtermAddInput(*forms);
2794
2795     /*
2796      * Set a nominal value for the preferred pane size, which lets the
2797      * buttons determine the actual height of the menu bar.  We don't show
2798      * the grip, because it's too easy to make the toolbar look bad that
2799      * way.
2800      */
2801     XtSetArg(args[0], XtNorientation, XtorientHorizontal);
2802     XtSetArg(args[1], XtNtop, XawChainTop);
2803     XtSetArg(args[2], XtNbottom, XawChainTop);
2804     XtSetArg(args[3], XtNleft, XawChainLeft);
2805     XtSetArg(args[4], XtNright, XawChainLeft);
2806
2807     if (resource.toolBar) {
2808         *menus = XtCreateManagedWidget("menubar", boxWidgetClass, *forms,
2809                                        args, 5);
2810     } else {
2811         *menus = XtCreateWidget("menubar", boxWidgetClass, *forms, args, 5);
2812     }
2813
2814     /*
2815      * The toolbar widget's height is not necessarily known yet.  If the
2816      * toolbar is not created as a managed widget, we can still make a good
2817      * guess about its height by collecting the widget's other resource values.
2818      */
2819     XtVaGetValues(*menus,
2820                   XtNhSpace, &toolbar_hSpace,
2821                   (XtPointer) 0);
2822
2823     if (shell == toplevel) {    /* vt100 */
2824         int j;
2825         for (j = mainMenu; j <= fontMenu; j++) {
2826             button_height = SetupShell(menus, vt_shell, j, j - 1);
2827         }
2828     }
2829 #if OPT_TEK4014
2830     else {                      /* tek4014 */
2831         (void) SetupShell(menus, tek_shell, mainMenu, -1);
2832         button_height = SetupShell(menus, tek_shell, tekMenu, mainMenu);
2833     }
2834 #endif
2835
2836     /*
2837      * Tell the main program how high the toolbar is, to help with the initial
2838      * layout.
2839      */
2840     *menu_high = (Dimension) (button_height + 2 * (toolbar_hSpace));
2841     TRACE(("...menuHeight:%d = (%d + 2 * %d)\n",
2842            *menu_high, button_height, toolbar_hSpace));
2843
2844 #else /* !OPT_TOOLBAR */
2845     *forms = shell;
2846     *menus = shell;
2847 #endif
2848
2849     TRACE(("...shell=%#lx\n", (long) shell));
2850     TRACE(("...forms=%#lx\n", (long) *forms));
2851     TRACE(("...menus=%#lx\n", (long) *menus));
2852 }
2853
2854 void
2855 repairSizeHints(void)
2856 {
2857     XtermWidget xw = term;
2858     TScreen *screen = TScreenOf(xw);
2859
2860     if (XtIsRealized((Widget) xw)) {
2861         getXtermSizeHints(xw);
2862         xtermSizeHints(xw, ScrollbarWidth(screen));
2863
2864         XSetWMNormalHints(screen->display, VShellWindow(xw), &xw->hints);
2865     }
2866 }
2867
2868 #if OPT_TOOLBAR
2869 #define INIT_POPUP(s, n) InitPopup(s[n].w, menu_names[n].internal_name, 0)
2870
2871 static Bool
2872 InitWidgetMenu(Widget shell)
2873 {
2874     Bool result = False;
2875
2876     TRACE(("InitWidgetMenu(%p)\n", (void *) shell));
2877     if (term != 0) {
2878         if (shell == toplevel) {        /* vt100 */
2879             if (!term->init_menu) {
2880                 INIT_POPUP(vt_shell, mainMenu);
2881                 INIT_POPUP(vt_shell, vtMenu);
2882                 INIT_POPUP(vt_shell, fontMenu);
2883                 term->init_menu = True;
2884                 TRACE(("...InitWidgetMenu(vt)\n"));
2885             }
2886             result = term->init_menu;
2887         }
2888 #if OPT_TEK4014
2889         else if (tekWidget) {   /* tek4014 */
2890             if (!tekWidget->init_menu) {
2891                 INIT_POPUP(tek_shell, mainMenu);
2892                 INIT_POPUP(tek_shell, tekMenu);
2893                 tekWidget->init_menu = True;
2894                 TRACE(("...InitWidgetMenu(tek)\n"));
2895             }
2896             result = tekWidget->init_menu;
2897         }
2898 #endif
2899     }
2900     TRACE(("...InitWidgetMenu ->%d\n", result));
2901     return result;
2902 }
2903
2904 static TbInfo *
2905 toolbar_info(Widget w)
2906 {
2907     TRACE(("...getting toolbar_info\n"));
2908 #if OPT_TEK4014
2909     if (w != (Widget) term)
2910         return &(tekWidget->tek.tb_info);
2911 #else
2912     (void) w;
2913 #endif
2914     return &(WhichVWin(TScreenOf(term))->tb_info);
2915 }
2916
2917 static void
2918 hide_toolbar(Widget w)
2919 {
2920     if (w != 0) {
2921         TbInfo *info = toolbar_info(w);
2922
2923         TRACE(("hiding toolbar\n"));
2924         XtVaSetValues(w,
2925                       XtNfromVert, (Widget) 0,
2926                       (XtPointer) 0);
2927
2928         if (info->menu_bar != 0) {
2929             repairSizeHints();
2930             XtUnmanageChild(info->menu_bar);
2931             if (XtIsRealized(info->menu_bar)) {
2932                 XtUnmapWidget(info->menu_bar);
2933             }
2934         }
2935         TRACE(("...hiding toolbar (done)\n"));
2936     }
2937 }
2938
2939 static void
2940 show_toolbar(Widget w)
2941 {
2942     if (w != 0) {
2943         TbInfo *info = toolbar_info(w);
2944
2945         TRACE(("showing toolbar\n"));
2946         if (info->menu_bar != 0) {
2947             XtVaSetValues(w,
2948                           XtNfromVert, info->menu_bar,
2949                           (XtPointer) 0);
2950             if (XtIsRealized(info->menu_bar))
2951                 repairSizeHints();
2952             XtManageChild(info->menu_bar);
2953             if (XtIsRealized(info->menu_bar)) {
2954                 XtMapWidget(info->menu_bar);
2955             }
2956         }
2957         /*
2958          * This is needed to make the terminal widget move down below the
2959          * toolbar.
2960          */
2961         XawFormDoLayout(XtParent(w), True);
2962         TRACE(("...showing toolbar (done)\n"));
2963     }
2964 }
2965
2966 /*
2967  * Make the toolbar visible or invisible in the current window(s).
2968  */
2969 void
2970 ShowToolbar(Bool enable)
2971 {
2972     XtermWidget xw = term;
2973
2974     TRACE(("ShowToolbar(%d)\n", enable));
2975
2976     if (IsIcon(TScreenOf(xw))) {
2977         Bell(xw, XkbBI_MinorError, 0);
2978     } else {
2979         if (enable) {
2980             if (InitWidgetMenu(toplevel))
2981                 show_toolbar((Widget) xw);
2982 #if OPT_TEK4014
2983             if (InitWidgetMenu(tekshellwidget))
2984                 show_toolbar((Widget) tekWidget);
2985 #endif
2986         } else {
2987             hide_toolbar((Widget) xw);
2988 #if OPT_TEK4014
2989             hide_toolbar((Widget) tekWidget);
2990 #endif
2991         }
2992         resource.toolBar = (Boolean) enable;
2993         update_toolbar();
2994     }
2995 }
2996
2997 void
2998 HandleToolbar(Widget w,
2999               XEvent * event GCC_UNUSED,
3000               String * params GCC_UNUSED,
3001               Cardinal *param_count GCC_UNUSED)
3002 {
3003     XtermWidget xw = term;
3004
3005     if (IsIcon(TScreenOf(xw))) {
3006         Bell(xw, XkbBI_MinorError, 0);
3007     } else {
3008         handle_vt_toggle(do_toolbar, resource.toolBar,
3009                          params, *param_count, w);
3010     }
3011 }
3012
3013 /* ARGSUSED */
3014 static void
3015 do_toolbar(Widget gw GCC_UNUSED,
3016            XtPointer closure GCC_UNUSED,
3017            XtPointer data GCC_UNUSED)
3018 {
3019     XtermWidget xw = term;
3020
3021     /*
3022      * Toggle toolbars for both vt100 and tek windows, since they share the
3023      * menu which contains the checkbox indicating whether the toolbar is
3024      * active.
3025      */
3026     if (IsIcon(TScreenOf(xw))) {
3027         Bell(xw, XkbBI_MinorError, 0);
3028     } else {
3029         ShowToolbar(ToggleFlag(resource.toolBar));
3030     }
3031 }
3032
3033 void
3034 update_toolbar(void)
3035 {
3036     UpdateCheckbox("update_toolbar",
3037                    mainMenuEntries,
3038                    mainMenu_toolbar,
3039                    resource.toolBar);
3040 }
3041 #endif /* OPT_TOOLBAR */
3042
3043 void
3044 update_securekbd(void)
3045 {
3046     UpdateCheckbox("update_securekbd",
3047                    mainMenuEntries,
3048                    mainMenu_securekbd,
3049                    TScreenOf(term)->grabbedKbd);
3050 }
3051
3052 void
3053 update_allowsends(void)
3054 {
3055     UpdateCheckbox("update_allowsends",
3056                    mainMenuEntries,
3057                    mainMenu_allowsends,
3058                    TScreenOf(term)->allowSendEvents);
3059 }
3060
3061 #ifdef ALLOWLOGGING
3062 void
3063 update_logging(void)
3064 {
3065     UpdateCheckbox("update_logging",
3066                    mainMenuEntries,
3067                    mainMenu_logging,
3068                    TScreenOf(term)->logging);
3069 }
3070 #endif
3071
3072 void
3073 update_print_redir(void)
3074 {
3075     UpdateCheckbox("update_print_redir",
3076                    mainMenuEntries,
3077                    mainMenu_print_redir,
3078                    TScreenOf(term)->printer_controlmode);
3079 }
3080
3081 void
3082 update_8bit_control(void)
3083 {
3084     UpdateCheckbox("update_8bit_control",
3085                    mainMenuEntries,
3086                    mainMenu_8bit_ctrl,
3087                    TScreenOf(term)->control_eight_bits);
3088 }
3089
3090 void
3091 update_decbkm(void)
3092 {
3093     UpdateCheckbox("update_decbkm",
3094                    mainMenuEntries,
3095                    mainMenu_backarrow,
3096                    (term->keyboard.flags & MODE_DECBKM) != 0);
3097 }
3098
3099 #if OPT_NUM_LOCK
3100 void
3101 update_num_lock(void)
3102 {
3103     UpdateCheckbox("update_num_lock",
3104                    mainMenuEntries,
3105                    mainMenu_num_lock,
3106                    term->misc.real_NumLock);
3107 }
3108
3109 void
3110 update_alt_esc(void)
3111 {
3112     UpdateCheckbox("update_alt_esc",
3113                    mainMenuEntries,
3114                    mainMenu_alt_esc,
3115                    TScreenOf(term)->alt_sends_esc);
3116 }
3117
3118 void
3119 update_meta_esc(void)
3120 {
3121     UpdateCheckbox("update_meta_esc",
3122                    mainMenuEntries,
3123                    mainMenu_meta_esc,
3124                    TScreenOf(term)->meta_sends_esc);
3125 }
3126 #endif
3127
3128 #if OPT_SUN_FUNC_KEYS
3129 void
3130 update_sun_fkeys(void)
3131 {
3132     UpdateCheckbox("update_sun_fkeys",
3133                    mainMenuEntries,
3134                    mainMenu_sun_fkeys,
3135                    term->keyboard.type == keyboardIsSun);
3136 }
3137 #endif
3138
3139 #if OPT_TCAP_FKEYS
3140 void
3141 update_tcap_fkeys(void)
3142 {
3143     UpdateCheckbox("update_tcap_fkeys",
3144                    mainMenuEntries,
3145                    mainMenu_tcap_fkeys,
3146                    term->keyboard.type == keyboardIsTermcap);
3147 }
3148 #endif
3149
3150 void
3151 update_old_fkeys(void)
3152 {
3153     UpdateCheckbox("update_old_fkeys",
3154                    mainMenuEntries,
3155                    mainMenu_old_fkeys,
3156                    term->keyboard.type == keyboardIsLegacy);
3157 }
3158
3159 void
3160 update_delete_del(void)
3161 {
3162     UpdateCheckbox("update_delete_del",
3163                    mainMenuEntries,
3164                    mainMenu_delete_del,
3165                    xtermDeleteIsDEL(term));
3166 }
3167
3168 #if OPT_SUNPC_KBD
3169 void
3170 update_sun_kbd(void)
3171 {
3172     UpdateCheckbox("update_sun_kbd",
3173                    mainMenuEntries,
3174                    mainMenu_sun_kbd,
3175                    term->keyboard.type == keyboardIsVT220);
3176 }
3177 #endif
3178
3179 #if OPT_HP_FUNC_KEYS
3180 void
3181 update_hp_fkeys(void)
3182 {
3183     UpdateCheckbox("update_hp_fkeys",
3184                    mainMenuEntries,
3185                    mainMenu_hp_fkeys,
3186                    term->keyboard.type == keyboardIsHP);
3187 }
3188 #endif
3189
3190 #if OPT_SCO_FUNC_KEYS
3191 void
3192 update_sco_fkeys(void)
3193 {
3194     UpdateCheckbox("update_sco_fkeys",
3195                    mainMenuEntries,
3196                    mainMenu_sco_fkeys,
3197                    term->keyboard.type == keyboardIsSCO);
3198 }
3199 #endif
3200
3201 void
3202 update_scrollbar(void)
3203 {
3204     UpdateCheckbox("update_scrollbar",
3205                    vtMenuEntries,
3206                    vtMenu_scrollbar,
3207                    ScrollbarWidth(TScreenOf(term)));
3208 }
3209
3210 void
3211 update_jumpscroll(void)
3212 {
3213     UpdateCheckbox("update_jumpscroll",
3214                    vtMenuEntries,
3215                    vtMenu_jumpscroll,
3216                    TScreenOf(term)->jumpscroll);
3217 }
3218
3219 void
3220 update_reversevideo(void)
3221 {
3222     UpdateCheckbox("update_reversevideo",
3223                    vtMenuEntries,
3224                    vtMenu_reversevideo,
3225                    (term->misc.re_verse));
3226 }
3227
3228 void
3229 update_autowrap(void)
3230 {
3231     UpdateCheckbox("update_autowrap",
3232                    vtMenuEntries,
3233                    vtMenu_autowrap,
3234                    (term->flags & WRAPAROUND) != 0);
3235 }
3236
3237 void
3238 update_reversewrap(void)
3239 {
3240     UpdateCheckbox("update_reversewrap",
3241                    vtMenuEntries,
3242                    vtMenu_reversewrap,
3243                    (term->flags & REVERSEWRAP) != 0);
3244 }
3245
3246 void
3247 update_autolinefeed(void)
3248 {
3249     UpdateCheckbox("update_autolinefeed",
3250                    vtMenuEntries,
3251                    vtMenu_autolinefeed,
3252                    (term->flags & LINEFEED) != 0);
3253 }
3254
3255 void
3256 update_appcursor(void)
3257 {
3258     UpdateCheckbox("update_appcursor",
3259                    vtMenuEntries,
3260                    vtMenu_appcursor,
3261                    (term->keyboard.flags & MODE_DECCKM) != 0);
3262 }
3263
3264 void
3265 update_appkeypad(void)
3266 {
3267     UpdateCheckbox("update_appkeypad",
3268                    vtMenuEntries,
3269                    vtMenu_appkeypad,
3270                    (term->keyboard.flags & MODE_DECKPAM) != 0);
3271 }
3272
3273 void
3274 update_scrollkey(void)
3275 {
3276     UpdateCheckbox("update_scrollkey",
3277                    vtMenuEntries,
3278                    vtMenu_scrollkey,
3279                    TScreenOf(term)->scrollkey);
3280 }
3281
3282 void
3283 update_scrollttyoutput(void)
3284 {
3285     UpdateCheckbox("update_scrollttyoutput",
3286                    vtMenuEntries,
3287                    vtMenu_scrollttyoutput,
3288                    TScreenOf(term)->scrollttyoutput);
3289 }
3290
3291 void
3292 update_keepSelection(void)
3293 {
3294     UpdateCheckbox("update_keepSelection",
3295                    vtMenuEntries,
3296                    vtMenu_keepSelection,
3297                    TScreenOf(term)->keepSelection);
3298 }
3299
3300 void
3301 update_selectToClipboard(void)
3302 {
3303     UpdateCheckbox("update_selectToClipboard",
3304                    vtMenuEntries,
3305                    vtMenu_selectToClipboard,
3306                    TScreenOf(term)->selectToClipboard);
3307 }
3308
3309 void
3310 update_allow132(void)
3311 {
3312     UpdateCheckbox("update_allow132",
3313                    vtMenuEntries,
3314                    vtMenu_allow132,
3315                    TScreenOf(term)->c132);
3316 }
3317
3318 void
3319 update_cursesemul(void)
3320 {
3321 #if 0                           /* 2006-2-12: no longer menu entry */
3322     UpdateMenuItem("update_cursesemul", vtMenuEntries, vtMenu_cursesemul,
3323                    TScreenOf(term)->curses);
3324 #endif
3325 }
3326
3327 void
3328 update_visualbell(void)
3329 {
3330     UpdateCheckbox("update_visualbell",
3331                    vtMenuEntries,
3332                    vtMenu_visualbell,
3333                    TScreenOf(term)->visualbell);
3334 }
3335
3336 void
3337 update_bellIsUrgent(void)
3338 {
3339     UpdateCheckbox("update_bellIsUrgent",
3340                    vtMenuEntries,
3341                    vtMenu_bellIsUrgent,
3342                    TScreenOf(term)->bellIsUrgent);
3343 }
3344
3345 void
3346 update_poponbell(void)
3347 {
3348     UpdateCheckbox("update_poponbell",
3349                    vtMenuEntries,
3350                    vtMenu_poponbell,
3351                    TScreenOf(term)->poponbell);
3352 }
3353
3354 #ifndef update_marginbell       /* 2007-3-7: no longer menu entry */
3355 void
3356 update_marginbell(void)
3357 {
3358     UpdateCheckbox("update_marginbell",
3359                    vtMenuEntries,
3360                    vtMenu_marginbell,
3361                    TScreenOf(term)->marginbell);
3362 }
3363 #endif
3364
3365 #if OPT_BLINK_CURS
3366 void
3367 update_cursorblink(void)
3368 {
3369     UpdateCheckbox("update_cursorblink",
3370                    vtMenuEntries,
3371                    vtMenu_cursorblink,
3372                    TScreenOf(term)->cursor_blink);
3373 }
3374 #endif
3375
3376 void
3377 update_altscreen(void)
3378 {
3379     UpdateCheckbox("update_altscreen",
3380                    vtMenuEntries,
3381                    vtMenu_altscreen,
3382                    TScreenOf(term)->whichBuf);
3383 }
3384
3385 void
3386 update_titeInhibit(void)
3387 {
3388     UpdateCheckbox("update_titeInhibit",
3389                    vtMenuEntries,
3390                    vtMenu_titeInhibit,
3391                    !(term->misc.titeInhibit));
3392 }
3393
3394 #ifndef NO_ACTIVE_ICON
3395 void
3396 update_activeicon(void)
3397 {
3398     UpdateCheckbox("update_activeicon",
3399                    vtMenuEntries,
3400                    vtMenu_activeicon,
3401                    term->misc.active_icon);
3402 }
3403 #endif /* NO_ACTIVE_ICON */
3404
3405 #if OPT_DEC_CHRSET
3406 void
3407 update_font_doublesize(void)
3408 {
3409     UpdateCheckbox("update_font_doublesize",
3410                    fontMenuEntries,
3411                    fontMenu_font_doublesize,
3412                    TScreenOf(term)->font_doublesize);
3413 }
3414 #endif
3415
3416 #if OPT_BOX_CHARS
3417 void
3418 update_font_boxchars(void)
3419 {
3420     UpdateCheckbox("update_font_boxchars",
3421                    fontMenuEntries,
3422                    fontMenu_font_boxchars,
3423                    TScreenOf(term)->force_box_chars);
3424 }
3425
3426 void
3427 update_font_packed(void)
3428 {
3429     UpdateCheckbox("update_font_packed",
3430                    fontMenuEntries,
3431                    fontMenu_font_packedfont,
3432                    TScreenOf(term)->force_packed);
3433 }
3434 #endif
3435
3436 #if OPT_DEC_SOFTFONT
3437 void
3438 update_font_loadable(void)
3439 {
3440     UpdateCheckbox("update_font_loadable",
3441                    fontMenuEntries,
3442                    fontMenu_font_loadable,
3443                    term->misc.font_loadable);
3444 }
3445 #endif
3446
3447 #if OPT_RENDERFONT
3448 void
3449 update_font_renderfont(void)
3450 {
3451     UpdateCheckbox("update_font_renderfont",
3452                    fontMenuEntries,
3453                    fontMenu_render_font,
3454                    (term->misc.render_font == True));
3455     SetItemSensitivity(fontMenuEntries[fontMenu_render_font].widget,
3456                        !IsEmpty(term->misc.face_name));
3457 }
3458 #endif
3459
3460 #if OPT_WIDE_CHARS
3461 void
3462 update_font_utf8_mode(void)
3463 {
3464     Bool active = (TScreenOf(term)->utf8_mode != uAlways);
3465     Bool enable = (TScreenOf(term)->utf8_mode != uFalse);
3466
3467     TRACE(("update_font_utf8_mode active %d, enable %d\n", active, enable));
3468     SetItemSensitivity(fontMenuEntries[fontMenu_wide_chars].widget, active);
3469     UpdateCheckbox("update_font_utf8_mode",
3470                    fontMenuEntries,
3471                    fontMenu_wide_chars,
3472                    enable);
3473 }
3474
3475 void
3476 update_font_utf8_title(void)
3477 {
3478     Bool active = (TScreenOf(term)->utf8_mode != uFalse);
3479     Bool enable = (TScreenOf(term)->utf8_title);
3480
3481     TRACE(("update_font_utf8_title active %d, enable %d\n", active, enable));
3482     SetItemSensitivity(fontMenuEntries[fontMenu_wide_title].widget, active);
3483     UpdateCheckbox("update_font_utf8_title",
3484                    fontMenuEntries,
3485                    fontMenu_wide_title,
3486                    enable);
3487 }
3488 #endif
3489
3490 #if OPT_ALLOW_XXX_OPS
3491 static void
3492 enable_allow_xxx_ops(Bool enable)
3493 {
3494     SetItemSensitivity(fontMenuEntries[fontMenu_allowFontOps].widget, enable);
3495     SetItemSensitivity(fontMenuEntries[fontMenu_allowTcapOps].widget, enable);
3496     SetItemSensitivity(fontMenuEntries[fontMenu_allowTitleOps].widget, enable);
3497     SetItemSensitivity(fontMenuEntries[fontMenu_allowWindowOps].widget, enable);
3498 }
3499
3500 static void
3501 do_allowColorOps(Widget w,
3502                  XtPointer closure GCC_UNUSED,
3503                  XtPointer data GCC_UNUSED)
3504 {
3505     XtermWidget xw = getXtermWidget(w);
3506     if (xw != 0) {
3507         ToggleFlag(TScreenOf(xw)->allowColorOps);
3508         update_menu_allowColorOps();
3509     }
3510 }
3511
3512 static void
3513 do_allowFontOps(Widget w,
3514                 XtPointer closure GCC_UNUSED,
3515                 XtPointer data GCC_UNUSED)
3516 {
3517     XtermWidget xw = getXtermWidget(w);
3518     if (xw != 0) {
3519         ToggleFlag(TScreenOf(xw)->allowFontOps);
3520         update_menu_allowFontOps();
3521     }
3522 }
3523
3524 static void
3525 do_allowTcapOps(Widget w,
3526                 XtPointer closure GCC_UNUSED,
3527                 XtPointer data GCC_UNUSED)
3528 {
3529     XtermWidget xw = getXtermWidget(w);
3530     if (xw != 0) {
3531         ToggleFlag(TScreenOf(xw)->allowTcapOps);
3532         update_menu_allowTcapOps();
3533     }
3534 }
3535
3536 static void
3537 do_allowTitleOps(Widget w,
3538                  XtPointer closure GCC_UNUSED,
3539                  XtPointer data GCC_UNUSED)
3540 {
3541     XtermWidget xw = getXtermWidget(w);
3542     if (xw != 0) {
3543         ToggleFlag(TScreenOf(xw)->allowTitleOps);
3544         update_menu_allowTitleOps();
3545     }
3546 }
3547
3548 static void
3549 do_allowWindowOps(Widget w,
3550                   XtPointer closure GCC_UNUSED,
3551                   XtPointer data GCC_UNUSED)
3552 {
3553     XtermWidget xw = getXtermWidget(w);
3554     if (xw != 0) {
3555         ToggleFlag(TScreenOf(xw)->allowWindowOps);
3556         update_menu_allowWindowOps();
3557     }
3558 }
3559
3560 void
3561 HandleAllowColorOps(Widget w,
3562                     XEvent * event GCC_UNUSED,
3563                     String * params,
3564                     Cardinal *param_count)
3565 {
3566     HANDLE_VT_TOGGLE(allowColorOps);
3567 }
3568
3569 void
3570 HandleAllowFontOps(Widget w,
3571                    XEvent * event GCC_UNUSED,
3572                    String * params,
3573                    Cardinal *param_count)
3574 {
3575     HANDLE_VT_TOGGLE(allowFontOps);
3576 }
3577
3578 void
3579 HandleAllowTcapOps(Widget w,
3580                    XEvent * event GCC_UNUSED,
3581                    String * params,
3582                    Cardinal *param_count)
3583 {
3584     HANDLE_VT_TOGGLE(allowTcapOps);
3585 }
3586
3587 void
3588 HandleAllowTitleOps(Widget w,
3589                     XEvent * event GCC_UNUSED,
3590                     String * params,
3591                     Cardinal *param_count)
3592 {
3593     HANDLE_VT_TOGGLE(allowTitleOps);
3594 }
3595
3596 void
3597 HandleAllowWindowOps(Widget w,
3598                      XEvent * event GCC_UNUSED,
3599                      String * params,
3600                      Cardinal *param_count)
3601 {
3602     HANDLE_VT_TOGGLE(allowWindowOps);
3603 }
3604
3605 void
3606 update_menu_allowColorOps(void)
3607 {
3608     UpdateCheckbox("update_menu_allowColorOps",
3609                    fontMenuEntries,
3610                    fontMenu_allowColorOps,
3611                    TScreenOf(term)->allowColorOps);
3612 }
3613
3614 void
3615 update_menu_allowFontOps(void)
3616 {
3617     UpdateCheckbox("update_menu_allowFontOps",
3618                    fontMenuEntries,
3619                    fontMenu_allowFontOps,
3620                    TScreenOf(term)->allowFontOps);
3621 }
3622
3623 void
3624 update_menu_allowTcapOps(void)
3625 {
3626     UpdateCheckbox("update_menu_allowTcapOps",
3627                    fontMenuEntries,
3628                    fontMenu_allowTcapOps,
3629                    TScreenOf(term)->allowTcapOps);
3630 }
3631
3632 void
3633 update_menu_allowTitleOps(void)
3634 {
3635     UpdateCheckbox("update_menu_allowTitleOps",
3636                    fontMenuEntries,
3637                    fontMenu_allowTitleOps,
3638                    TScreenOf(term)->allowTitleOps);
3639 }
3640
3641 void
3642 update_menu_allowWindowOps(void)
3643 {
3644     UpdateCheckbox("update_menu_allowWindowOps",
3645                    fontMenuEntries,
3646                    fontMenu_allowWindowOps,
3647                    TScreenOf(term)->allowWindowOps);
3648 }
3649 #endif
3650
3651 #if OPT_TEK4014
3652 void
3653 update_tekshow(void)
3654 {
3655     if (!(TScreenOf(term)->inhibit & I_TEK)) {
3656         UpdateCheckbox("update_tekshow",
3657                        vtMenuEntries,
3658                        vtMenu_tekshow,
3659                        TEK4014_SHOWN(term));
3660     }
3661 }
3662
3663 void
3664 update_vttekmode(void)
3665 {
3666     if (!(TScreenOf(term)->inhibit & I_TEK)) {
3667         UpdateCheckbox("update_vtmode",
3668                        vtMenuEntries,
3669                        vtMenu_tekmode,
3670                        TEK4014_ACTIVE(term));
3671         UpdateCheckbox("update_tekmode",
3672                        tekMenuEntries,
3673                        tekMenu_vtmode,
3674                        !TEK4014_ACTIVE(term));
3675     }
3676 }
3677
3678 void
3679 update_vtshow(void)
3680 {
3681     if (!(TScreenOf(term)->inhibit & I_TEK)) {
3682         UpdateCheckbox("update_vtshow",
3683                        tekMenuEntries,
3684                        tekMenu_vtshow,
3685                        TScreenOf(term)->Vshow);
3686     }
3687 }
3688
3689 void
3690 set_vthide_sensitivity(void)
3691 {
3692     if (!(TScreenOf(term)->inhibit & I_TEK)) {
3693         SetItemSensitivity(
3694                               vtMenuEntries[vtMenu_vthide].widget,
3695                               TEK4014_SHOWN(term));
3696     }
3697 }
3698
3699 void
3700 set_tekhide_sensitivity(void)
3701 {
3702     if (!(TScreenOf(term)->inhibit & I_TEK)) {
3703         SetItemSensitivity(
3704                               tekMenuEntries[tekMenu_tekhide].widget,
3705                               TScreenOf(term)->Vshow);
3706     }
3707 }
3708
3709 void
3710 set_tekfont_menu_item(int n, int val)
3711 {
3712     if (!(TScreenOf(term)->inhibit & I_TEK)) {
3713         UpdateCheckbox("set_tekfont_menu_item", tekMenuEntries, FS2MI(n),
3714                        (val));
3715     }
3716 }
3717 #endif /* OPT_TEK4014 */
3718
3719 void
3720 set_menu_font(int val)
3721 {
3722     UpdateCheckbox("set_menu_font",
3723                    fontMenuEntries,
3724                    TScreenOf(term)->menu_font_number,
3725                    (val));
3726 }