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