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