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