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