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