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