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