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