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