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