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