← Back to branch summary

~ubuntu-branches/ubuntu/hardy/xterm/hardy-updates

« back to all changes in this revision

Viewing changes to menu.c

  • Committer: Bazaar Package Importer
  • Author(s): Rodrigo Parra Novo
  • Date: 2006-08-04 07:58:43 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20060804075843-tu25sluj2147ifyp
Tags: 216-0ubuntu1
* New Upstream release
* Updated xterm.faq.html to latest version available

Show diffs side-by-side

added added

removed removed

Lines of Context:
menu.c
1
 
/* $XTermId: menu.c,v 1.204 2006/03/13 01:27:59 tom Exp $ */
 
1
/* $XTermId: menu.c,v 1.217 2006/07/23 20:13:22 tom Exp $ */
2
2
 
3
3
/*
4
4
 
46
46
in this Software without prior written authorization from The Open Group.
47
47
 
48
48
*/
49
 
/* $XFree86: xc/programs/xterm/menu.c,v 3.67 2006/03/13 01:27:59 dickey Exp $ */
 
49
/* $XFree86: xc/programs/xterm/menu.c,v 3.68 2006/04/10 00:34:36 dickey Exp $ */
50
50
 
51
51
#include <xterm.h>
52
52
#include <data.h>
142
142
static void do_securekbd       PROTO_XT_CALLBACK_ARGS;
143
143
static void do_selectClipboard PROTO_XT_CALLBACK_ARGS;
144
144
static void do_softreset       PROTO_XT_CALLBACK_ARGS;
145
 
static void do_sun_fkeys       PROTO_XT_CALLBACK_ARGS;
146
145
static void do_suspend         PROTO_XT_CALLBACK_ARGS;
147
146
static void do_terminate       PROTO_XT_CALLBACK_ARGS;
148
147
static void do_titeInhibit     PROTO_XT_CALLBACK_ARGS;
192
191
static void do_sco_fkeys       PROTO_XT_CALLBACK_ARGS;
193
192
#endif
194
193
 
 
194
#if OPT_SUN_FUNC_KEYS
 
195
static void do_sun_fkeys       PROTO_XT_CALLBACK_ARGS;
 
196
#endif
 
197
 
195
198
#if OPT_SUNPC_KBD
196
199
static void do_sun_kbd         PROTO_XT_CALLBACK_ARGS;
197
200
#endif
257
260
#if OPT_SCO_FUNC_KEYS
258
261
    { "scoFunctionKeys",do_sco_fkeys,   NULL },
259
262
#endif
 
263
#if OPT_SUN_FUNC_KEYS
260
264
    { "sunFunctionKeys",do_sun_fkeys,   NULL },
 
265
#endif
261
266
#if OPT_SUNPC_KBD
262
267
    { "sunKeyboard",    do_sun_kbd,     NULL },
263
268
#endif
573
578
            update_delete_del();
574
579
            update_keyboard_type();
575
580
            if (!xtermHasPrinter()) {
576
 
                set_sensitivity(mw,
577
 
                                mainMenuEntries[mainMenu_print].widget,
578
 
                                False);
579
 
                set_sensitivity(mw,
580
 
                                mainMenuEntries[mainMenu_print_redir].widget,
581
 
                                False);
 
581
                SetItemSensitivity(mainMenuEntries[mainMenu_print].widget,
 
582
                                   False);
 
583
                SetItemSensitivity(mainMenuEntries[mainMenu_print_redir].widget,
 
584
                                   False);
582
585
            }
583
586
            if (screen->terminal_id < 200) {
584
 
                set_sensitivity(mw,
585
 
                                mainMenuEntries[mainMenu_8bit_ctrl].widget,
586
 
                                False);
 
587
                SetItemSensitivity(
 
588
                                      mainMenuEntries[mainMenu_8bit_ctrl].widget,
 
589
                                      False);
587
590
            }
588
591
#if !defined(SIGTSTP)
589
 
            set_sensitivity(mw,
590
 
                            mainMenuEntries[mainMenu_suspend].widget, False);
 
592
            SetItemSensitivity(
 
593
                                  mainMenuEntries[mainMenu_suspend].widget, False);
591
594
#endif
592
595
#if !defined(SIGCONT)
593
 
            set_sensitivity(mw,
594
 
                            mainMenuEntries[mainMenu_continue].widget, False);
 
596
            SetItemSensitivity(
 
597
                                  mainMenuEntries[mainMenu_continue].widget, False);
595
598
#endif
596
599
#ifdef ALLOWLOGGING
597
600
            if (screen->inhibit & I_LOG) {
598
 
                set_sensitivity(mw,
599
 
                                mainMenuEntries[mainMenu_logging].widget, False);
 
601
                SetItemSensitivity(
 
602
                                      mainMenuEntries[mainMenu_logging].widget, False);
600
603
            }
601
604
#endif
602
605
            if (screen->inhibit & I_SIGNAL) {
603
606
                int n;
604
607
                for (n = (int) mainMenu_suspend; n <= (int) mainMenu_quit; ++n) {
605
 
                    set_sensitivity(mw, mainMenuEntries[n].widget, False);
 
608
                    SetItemSensitivity(mainMenuEntries[n].widget, False);
606
609
                }
607
610
            }
608
611
        }
622
625
            update_scrollttyoutput();
623
626
            update_allow132();
624
627
            update_cursesemul();
 
628
            update_selectToClipboard();
625
629
            update_visualbell();
626
630
            update_poponbell();
627
631
            update_marginbell();
630
634
            update_titeInhibit();
631
635
#ifndef NO_ACTIVE_ICON
632
636
            if (!screen->fnt_icon || !screen->iconVwin.window) {
633
 
                set_sensitivity(mw,
634
 
                                vtMenuEntries[vtMenu_activeicon].widget,
635
 
                                False);
 
637
                SetItemSensitivity(
 
638
                                      vtMenuEntries[vtMenu_activeicon].widget,
 
639
                                      False);
636
640
            } else
637
641
                update_activeicon();
638
642
#endif /* NO_ACTIVE_ICON */
640
644
            if (screen->inhibit & I_TEK) {
641
645
                int n;
642
646
                for (n = (int) vtMenu_tekshow; n <= (int) vtMenu_vthide; ++n) {
643
 
                    set_sensitivity(mw, vtMenuEntries[n].widget, False);
 
647
                    SetItemSensitivity(vtMenuEntries[n].widget, False);
644
648
                }
645
649
            }
646
650
#endif
650
654
    case fontMenu:
651
655
        if (created) {
652
656
            set_menu_font(True);
653
 
            set_sensitivity(mw,
654
 
                            fontMenuEntries[fontMenu_fontescape].widget,
655
 
                            (screen->menu_font_names[fontMenu_fontescape]
656
 
                             ? True : False));
 
657
            SetItemSensitivity(
 
658
                                  fontMenuEntries[fontMenu_fontescape].widget,
 
659
                                  (screen->menu_font_names[fontMenu_fontescape]
 
660
                                   ? True : False));
657
661
#if OPT_BOX_CHARS
658
662
            update_font_boxchars();
659
 
            set_sensitivity(mw,
660
 
                            fontMenuEntries[fontMenu_font_boxchars].widget,
661
 
                            True);
 
663
            SetItemSensitivity(
 
664
                                  fontMenuEntries[fontMenu_font_boxchars].widget,
 
665
                                  True);
662
666
#endif
663
667
#if OPT_DEC_SOFTFONT            /* FIXME: not implemented */
664
668
            update_font_loadable();
665
 
            set_sensitivity(mw,
666
 
                            fontMenuEntries[fontMenu_font_loadable].widget,
667
 
                            False);
 
669
            SetItemSensitivity(
 
670
                                  fontMenuEntries[fontMenu_font_loadable].widget,
 
671
                                  False);
668
672
#endif
669
673
#if OPT_DEC_CHRSET
670
674
            update_font_doublesize();
671
675
            if (term->screen.cache_doublesize == 0)
672
 
                set_sensitivity(mw,
673
 
                                fontMenuEntries[fontMenu_font_doublesize].widget,
674
 
                                False);
 
676
                SetItemSensitivity(
 
677
                                      fontMenuEntries[fontMenu_font_doublesize].widget,
 
678
                                      False);
675
679
#endif
676
680
#if OPT_RENDERFONT
677
681
            update_font_renderfont();
678
682
            if (term->misc.face_name == 0) {
679
 
                set_sensitivity(mw,
680
 
                                fontMenuEntries[fontMenu_render_font].widget,
681
 
                                False);
 
683
                SetItemSensitivity(
 
684
                                      fontMenuEntries[fontMenu_render_font].widget,
 
685
                                      False);
682
686
            }
683
687
#endif
684
688
#if OPT_WIDE_CHARS
686
690
            update_font_utf8_title();
687
691
#endif
688
692
        }
689
 
        FindFontSelection(NULL, True);
690
 
        set_sensitivity(mw,
691
 
                        fontMenuEntries[fontMenu_fontsel].widget,
692
 
                        (screen->menu_font_names[fontMenu_fontsel]
693
 
                         ? True : False));
 
693
        FindFontSelection(term, NULL, True);
 
694
        SetItemSensitivity(
 
695
                              fontMenuEntries[fontMenu_fontsel].widget,
 
696
                              (screen->menu_font_names[fontMenu_fontsel]
 
697
                               ? True : False));
694
698
        break;
695
699
 
696
700
#if OPT_TEK4014
935
939
              XtPointer closure GCC_UNUSED,
936
940
              XtPointer data GCC_UNUSED)
937
941
{
938
 
    if (xtermDeleteIsDEL())
 
942
    if (xtermDeleteIsDEL(term))
939
943
        term->screen.delete_is_del = False;
940
944
    else
941
945
        term->screen.delete_is_del = True;
947
951
             XtPointer closure GCC_UNUSED,
948
952
             XtPointer data GCC_UNUSED)
949
953
{
950
 
    toggle_keyboard_type(keyboardIsLegacy);
 
954
    toggle_keyboard_type(term, keyboardIsLegacy);
951
955
}
952
956
 
953
957
#if OPT_HP_FUNC_KEYS
956
960
            XtPointer closure GCC_UNUSED,
957
961
            XtPointer data GCC_UNUSED)
958
962
{
959
 
    toggle_keyboard_type(keyboardIsHP);
 
963
    toggle_keyboard_type(term, keyboardIsHP);
960
964
}
961
965
#endif
962
966
 
966
970
             XtPointer closure GCC_UNUSED,
967
971
             XtPointer data GCC_UNUSED)
968
972
{
969
 
    toggle_keyboard_type(keyboardIsSCO);
 
973
    toggle_keyboard_type(term, keyboardIsSCO);
970
974
}
971
975
#endif
972
976
 
 
977
#if OPT_SUN_FUNC_KEYS
973
978
static void
974
979
do_sun_fkeys(Widget gw GCC_UNUSED,
975
980
             XtPointer closure GCC_UNUSED,
976
981
             XtPointer data GCC_UNUSED)
977
982
{
978
 
    toggle_keyboard_type(keyboardIsSun);
 
983
    toggle_keyboard_type(term, keyboardIsSun);
979
984
}
 
985
#endif
980
986
 
981
987
#if OPT_SUNPC_KBD
982
988
/*
987
993
           XtPointer closure GCC_UNUSED,
988
994
           XtPointer data GCC_UNUSED)
989
995
{
990
 
    toggle_keyboard_type(keyboardIsVT220);
 
996
    toggle_keyboard_type(term, keyboardIsVT220);
991
997
}
992
998
#endif
993
999
 
1085
1091
    if (term->flags & SMOOTHSCROLL) {
1086
1092
        screen->jumpscroll = False;
1087
1093
        if (screen->scroll_amt)
1088
 
            FlushScroll(screen);
 
1094
            FlushScroll(term);
1089
1095
    } else {
1090
1096
        screen->jumpscroll = True;
1091
1097
    }
1265
1271
             XtPointer closure GCC_UNUSED,
1266
1272
             XtPointer data GCC_UNUSED)
1267
1273
{
1268
 
    TScreen *screen = &term->screen;
1269
 
    ToggleAlternate(screen);
 
1274
    ToggleAlternate(term);
1270
1275
}
1271
1276
 
1272
1277
/* ARGSUSED */
1304
1309
             XtPointer closure GCC_UNUSED,
1305
1310
             XtPointer data GCC_UNUSED)
1306
1311
{
1307
 
    VTReset(False, False);
 
1312
    VTReset(term, False, False);
1308
1313
}
1309
1314
 
1310
1315
static void
1312
1317
             XtPointer closure GCC_UNUSED,
1313
1318
             XtPointer data GCC_UNUSED)
1314
1319
{
1315
 
    VTReset(True, False);
 
1320
    VTReset(term, True, False);
1316
1321
}
1317
1322
 
1318
1323
static void
1320
1325
                   XtPointer closure GCC_UNUSED,
1321
1326
                   XtPointer data GCC_UNUSED)
1322
1327
{
1323
 
    VTReset(True, True);
 
1328
    VTReset(term, True, True);
1324
1329
}
1325
1330
 
1326
1331
#if OPT_TEK4014
1414
1419
    term->misc.render_font = !term->misc.render_font;
1415
1420
    update_font_renderfont();
1416
1421
    xtermLoadFont(term, xtermFontName(name), True, fontnum);
1417
 
    ScrnRefresh(screen, 0, 0,
 
1422
    ScrnRefresh(term, 0, 0,
1418
1423
                MaxRows(screen),
1419
1424
                MaxCols(screen), True);
1420
1425
}
1438
1443
                SetVTFont(term, screen->menu_font_number, TRUE, NULL);
1439
1444
            }
1440
1445
        } else {
1441
 
            ChangeToWide(screen);
 
1446
            ChangeToWide(term);
1442
1447
        }
1443
1448
    }
1444
1449
    switchPtyData(screen, !screen->utf8_mode);
1784
1789
                     params, *param_count, w);
1785
1790
}
1786
1791
 
 
1792
#if OPT_SUN_FUNC_KEYS
1787
1793
void
1788
1794
HandleSunFunctionKeys(Widget w,
1789
1795
                      XEvent * event GCC_UNUSED,
1793
1799
    handle_vt_toggle(do_sun_fkeys, term->keyboard.type == keyboardIsSun,
1794
1800
                     params, *param_count, w);
1795
1801
}
 
1802
#endif
1796
1803
 
1797
1804
#if OPT_NUM_LOCK
1798
1805
void
2283
2290
}
2284
2291
#endif /* OPT_TEK4014 */
2285
2292
 
2286
 
void
 
2293
static void
2287
2294
UpdateMenuItem(Widget mi, XtArgVal val)
2288
2295
{
2289
2296
    static Arg menuArgs =
2468
2475
{
2469
2476
    TScreen *screen = &term->screen;
2470
2477
 
2471
 
    XSizeHints sizehints;
2472
 
 
2473
2478
    if (XtIsRealized((Widget) term)) {
2474
 
        bzero(&sizehints, sizeof(sizehints));
2475
 
        xtermSizeHints(term, &sizehints, ScrollbarWidth(screen));
 
2479
        bzero(&term->hints, sizeof(term->hints));
 
2480
        xtermSizeHints(term, ScrollbarWidth(screen));
2476
2481
 
2477
 
        XSetWMNormalHints(screen->display, XtWindow(SHELL_OF(term)), &sizehints);
 
2482
        XSetWMNormalHints(screen->display, XtWindow(SHELL_OF(term)), &term->hints);
2478
2483
    }
2479
2484
}
2480
2485
 
2489
2494
    TRACE(("InitWidgetMenu(%p)\n", shell));
2490
2495
    if (term != 0) {
2491
2496
        if (shell == toplevel) {        /* vt100 */
2492
 
            if (!term->init_vt_menu) {
 
2497
            if (!term->init_menu) {
2493
2498
                INIT_POPUP(vt_shell, mainMenu);
2494
2499
                INIT_POPUP(vt_shell, vtMenu);
2495
2500
                INIT_POPUP(vt_shell, fontMenu);
2496
 
                term->init_vt_menu = True;
 
2501
                term->init_menu = True;
2497
2502
                TRACE(("...InitWidgetMenu(vt)\n"));
2498
2503
            }
2499
 
            result = term->init_vt_menu;
 
2504
            result = term->init_menu;
2500
2505
        }
2501
2506
#if OPT_TEK4014
2502
2507
        else if (tekWidget) {   /* tek4014 */
2503
 
            if (!term->init_tek_menu) {
 
2508
            if (!tekWidget->init_menu) {
2504
2509
                INIT_POPUP(tek_shell, mainMenu);
2505
2510
                INIT_POPUP(tek_shell, tekMenu);
2506
 
                term->init_tek_menu = True;
 
2511
                tekWidget->init_menu = True;
2507
2512
                TRACE(("...InitWidgetMenu(tek)\n"));
2508
2513
            }
2509
 
            result = term->init_tek_menu;
 
2514
            result = tekWidget->init_menu;
2510
2515
        }
2511
2516
#endif
2512
2517
    }
2638
2643
void
2639
2644
update_toolbar(void)
2640
2645
{
2641
 
    update_menu_item(term->screen.mainMenu,
2642
 
                     mainMenuEntries[mainMenu_toolbar].widget,
2643
 
                     resource.toolBar);
 
2646
    UpdateMenuItem(mainMenuEntries[mainMenu_toolbar].widget,
 
2647
                   resource.toolBar);
2644
2648
}
2645
2649
#endif /* OPT_TOOLBAR */
2646
2650
 
2647
2651
void
2648
2652
update_securekbd(void)
2649
2653
{
2650
 
    update_menu_item(term->screen.mainMenu,
2651
 
                     mainMenuEntries[mainMenu_securekbd].widget,
2652
 
                     term->screen.grabbedKbd);
 
2654
    UpdateMenuItem(mainMenuEntries[mainMenu_securekbd].widget,
 
2655
                   term->screen.grabbedKbd);
2653
2656
}
2654
2657
 
2655
2658
void
2656
2659
update_allowsends(void)
2657
2660
{
2658
 
    update_menu_item(term->screen.mainMenu,
2659
 
                     mainMenuEntries[mainMenu_allowsends].widget,
2660
 
                     term->screen.allowSendEvents);
 
2661
    UpdateMenuItem(mainMenuEntries[mainMenu_allowsends].widget,
 
2662
                   term->screen.allowSendEvents);
2661
2663
}
2662
2664
 
2663
2665
#ifdef ALLOWLOGGING
2664
2666
void
2665
2667
update_logging(void)
2666
2668
{
2667
 
    update_menu_item(term->screen.mainMenu,
2668
 
                     mainMenuEntries[mainMenu_logging].widget,
2669
 
                     term->screen.logging);
 
2669
    UpdateMenuItem(mainMenuEntries[mainMenu_logging].widget,
 
2670
                   term->screen.logging);
2670
2671
}
2671
2672
#endif
2672
2673
 
2673
2674
void
2674
2675
update_print_redir(void)
2675
2676
{
2676
 
    update_menu_item(term->screen.mainMenu,
2677
 
                     mainMenuEntries[mainMenu_print_redir].widget,
2678
 
                     term->screen.printer_controlmode);
 
2677
    UpdateMenuItem(mainMenuEntries[mainMenu_print_redir].widget,
 
2678
                   term->screen.printer_controlmode);
2679
2679
}
2680
2680
 
2681
2681
void
2682
2682
update_8bit_control(void)
2683
2683
{
2684
 
    update_menu_item(term->screen.mainMenu,
2685
 
                     mainMenuEntries[mainMenu_8bit_ctrl].widget,
2686
 
                     term->screen.control_eight_bits);
 
2684
    UpdateMenuItem(mainMenuEntries[mainMenu_8bit_ctrl].widget,
 
2685
                   term->screen.control_eight_bits);
2687
2686
}
2688
2687
 
2689
2688
void
2690
2689
update_decbkm(void)
2691
2690
{
2692
 
    update_menu_item(term->screen.mainMenu,
2693
 
                     mainMenuEntries[mainMenu_backarrow].widget,
2694
 
                     (term->keyboard.flags & MODE_DECBKM) != 0);
 
2691
    UpdateMenuItem(mainMenuEntries[mainMenu_backarrow].widget,
 
2692
                   (term->keyboard.flags & MODE_DECBKM) != 0);
2695
2693
}
2696
2694
 
2697
2695
#if OPT_NUM_LOCK
2698
2696
void
2699
2697
update_num_lock(void)
2700
2698
{
2701
 
    update_menu_item(term->screen.mainMenu,
2702
 
                     mainMenuEntries[mainMenu_num_lock].widget,
2703
 
                     term->misc.real_NumLock);
 
2699
    UpdateMenuItem(mainMenuEntries[mainMenu_num_lock].widget,
 
2700
                   term->misc.real_NumLock);
2704
2701
}
2705
2702
 
2706
2703
void
2707
2704
update_alt_esc(void)
2708
2705
{
2709
 
    update_menu_item(term->screen.mainMenu,
2710
 
                     mainMenuEntries[mainMenu_alt_esc].widget,
2711
 
                     !term->screen.input_eight_bits);
 
2706
    UpdateMenuItem(mainMenuEntries[mainMenu_alt_esc].widget,
 
2707
                   !term->screen.input_eight_bits);
2712
2708
}
2713
2709
 
2714
2710
void
2715
2711
update_meta_esc(void)
2716
2712
{
2717
 
    update_menu_item(term->screen.mainMenu,
2718
 
                     mainMenuEntries[mainMenu_meta_esc].widget,
2719
 
                     term->screen.meta_sends_esc);
 
2713
    UpdateMenuItem(mainMenuEntries[mainMenu_meta_esc].widget,
 
2714
                   term->screen.meta_sends_esc);
2720
2715
}
2721
2716
#endif
2722
2717
 
 
2718
#if OPT_SUN_FUNC_KEYS
2723
2719
void
2724
2720
update_sun_fkeys(void)
2725
2721
{
2726
 
    update_menu_item(term->screen.mainMenu,
2727
 
                     mainMenuEntries[mainMenu_sun_fkeys].widget,
2728
 
                     term->keyboard.type == keyboardIsSun);
 
2722
    UpdateMenuItem(mainMenuEntries[mainMenu_sun_fkeys].widget,
 
2723
                   term->keyboard.type == keyboardIsSun);
2729
2724
}
 
2725
#endif
2730
2726
 
2731
2727
void
2732
2728
update_old_fkeys(void)
2733
2729
{
2734
 
    update_menu_item(term->screen.mainMenu,
2735
 
                     mainMenuEntries[mainMenu_old_fkeys].widget,
2736
 
                     term->keyboard.type == keyboardIsLegacy);
 
2730
    UpdateMenuItem(mainMenuEntries[mainMenu_old_fkeys].widget,
 
2731
                   term->keyboard.type == keyboardIsLegacy);
2737
2732
}
2738
2733
 
2739
2734
void
2740
2735
update_delete_del(void)
2741
2736
{
2742
 
    update_menu_item(term->screen.mainMenu,
2743
 
                     mainMenuEntries[mainMenu_delete_del].widget,
2744
 
                     xtermDeleteIsDEL());
 
2737
    UpdateMenuItem(mainMenuEntries[mainMenu_delete_del].widget,
 
2738
                   xtermDeleteIsDEL(term));
2745
2739
}
2746
2740
 
2747
2741
#if OPT_SUNPC_KBD
2748
2742
void
2749
2743
update_sun_kbd(void)
2750
2744
{
2751
 
    update_menu_item(term->screen.mainMenu,
2752
 
                     mainMenuEntries[mainMenu_sun_kbd].widget,
2753
 
                     term->keyboard.type == keyboardIsVT220);
 
2745
    UpdateMenuItem(mainMenuEntries[mainMenu_sun_kbd].widget,
 
2746
                   term->keyboard.type == keyboardIsVT220);
2754
2747
}
2755
2748
#endif
2756
2749
 
2758
2751
void
2759
2752
update_hp_fkeys(void)
2760
2753
{
2761
 
    update_menu_item(term->screen.mainMenu,
2762
 
                     mainMenuEntries[mainMenu_hp_fkeys].widget,
2763
 
                     term->keyboard.type == keyboardIsHP);
 
2754
    UpdateMenuItem(mainMenuEntries[mainMenu_hp_fkeys].widget,
 
2755
                   term->keyboard.type == keyboardIsHP);
2764
2756
}
2765
2757
#endif
2766
2758
 
2768
2760
void
2769
2761
update_sco_fkeys(void)
2770
2762
{
2771
 
    update_menu_item(term->screen.mainMenu,
2772
 
                     mainMenuEntries[mainMenu_sco_fkeys].widget,
2773
 
                     term->keyboard.type == keyboardIsSCO);
 
2763
    UpdateMenuItem(mainMenuEntries[mainMenu_sco_fkeys].widget,
 
2764
                   term->keyboard.type == keyboardIsSCO);
2774
2765
}
2775
2766
#endif
2776
2767
 
2777
2768
void
2778
2769
update_scrollbar(void)
2779
2770
{
2780
 
    update_menu_item(term->screen.vtMenu,
2781
 
                     vtMenuEntries[vtMenu_scrollbar].widget,
2782
 
                     ScrollbarWidth(&term->screen));
 
2771
    UpdateMenuItem(vtMenuEntries[vtMenu_scrollbar].widget,
 
2772
                   ScrollbarWidth(&term->screen));
2783
2773
}
2784
2774
 
2785
2775
void
2786
2776
update_jumpscroll(void)
2787
2777
{
2788
 
    update_menu_item(term->screen.vtMenu,
2789
 
                     vtMenuEntries[vtMenu_jumpscroll].widget,
2790
 
                     term->screen.jumpscroll);
 
2778
    UpdateMenuItem(vtMenuEntries[vtMenu_jumpscroll].widget,
 
2779
                   term->screen.jumpscroll);
2791
2780
}
2792
2781
 
2793
2782
void
2794
2783
update_reversevideo(void)
2795
2784
{
2796
 
    update_menu_item(term->screen.vtMenu,
2797
 
                     vtMenuEntries[vtMenu_reversevideo].widget,
2798
 
                     (term->misc.re_verse));
 
2785
    UpdateMenuItem(vtMenuEntries[vtMenu_reversevideo].widget,
 
2786
                   (term->misc.re_verse));
2799
2787
}
2800
2788
 
2801
2789
void
2802
2790
update_autowrap(void)
2803
2791
{
2804
 
    update_menu_item(term->screen.vtMenu,
2805
 
                     vtMenuEntries[vtMenu_autowrap].widget,
2806
 
                     (term->flags & WRAPAROUND) != 0);
 
2792
    UpdateMenuItem(vtMenuEntries[vtMenu_autowrap].widget,
 
2793
                   (term->flags & WRAPAROUND) != 0);
2807
2794
}
2808
2795
 
2809
2796
void
2810
2797
update_reversewrap(void)
2811
2798
{
2812
 
    update_menu_item(term->screen.vtMenu,
2813
 
                     vtMenuEntries[vtMenu_reversewrap].widget,
2814
 
                     (term->flags & REVERSEWRAP) != 0);
 
2799
    UpdateMenuItem(vtMenuEntries[vtMenu_reversewrap].widget,
 
2800
                   (term->flags & REVERSEWRAP) != 0);
2815
2801
}
2816
2802
 
2817
2803
void
2818
2804
update_autolinefeed(void)
2819
2805
{
2820
 
    update_menu_item(term->screen.vtMenu,
2821
 
                     vtMenuEntries[vtMenu_autolinefeed].widget,
2822
 
                     (term->flags & LINEFEED) != 0);
 
2806
    UpdateMenuItem(vtMenuEntries[vtMenu_autolinefeed].widget,
 
2807
                   (term->flags & LINEFEED) != 0);
2823
2808
}
2824
2809
 
2825
2810
void
2826
2811
update_appcursor(void)
2827
2812
{
2828
 
    update_menu_item(term->screen.vtMenu,
2829
 
                     vtMenuEntries[vtMenu_appcursor].widget,
2830
 
                     (term->keyboard.flags & MODE_DECCKM) != 0);
 
2813
    UpdateMenuItem(vtMenuEntries[vtMenu_appcursor].widget,
 
2814
                   (term->keyboard.flags & MODE_DECCKM) != 0);
2831
2815
}
2832
2816
 
2833
2817
void
2834
2818
update_appkeypad(void)
2835
2819
{
2836
 
    update_menu_item(term->screen.vtMenu,
2837
 
                     vtMenuEntries[vtMenu_appkeypad].widget,
2838
 
                     (term->keyboard.flags & MODE_DECKPAM) != 0);
 
2820
    UpdateMenuItem(vtMenuEntries[vtMenu_appkeypad].widget,
 
2821
                   (term->keyboard.flags & MODE_DECKPAM) != 0);
2839
2822
}
2840
2823
 
2841
2824
void
2842
2825
update_scrollkey(void)
2843
2826
{
2844
 
    update_menu_item(term->screen.vtMenu,
2845
 
                     vtMenuEntries[vtMenu_scrollkey].widget,
2846
 
                     term->screen.scrollkey);
 
2827
    UpdateMenuItem(vtMenuEntries[vtMenu_scrollkey].widget,
 
2828
                   term->screen.scrollkey);
2847
2829
}
2848
2830
 
2849
2831
void
2850
2832
update_scrollttyoutput(void)
2851
2833
{
2852
 
    update_menu_item(term->screen.vtMenu,
2853
 
                     vtMenuEntries[vtMenu_scrollttyoutput].widget,
2854
 
                     term->screen.scrollttyoutput);
 
2834
    UpdateMenuItem(vtMenuEntries[vtMenu_scrollttyoutput].widget,
 
2835
                   term->screen.scrollttyoutput);
2855
2836
}
2856
2837
 
2857
2838
void
2858
2839
update_selectToClipboard(void)
2859
2840
{
2860
 
    update_menu_item(term->screen.vtMenu,
2861
 
                     vtMenuEntries[vtMenu_selectToClipboard].widget,
2862
 
                     term->screen.selectToClipboard);
 
2841
    UpdateMenuItem(vtMenuEntries[vtMenu_selectToClipboard].widget,
 
2842
                   term->screen.selectToClipboard);
2863
2843
}
2864
2844
 
2865
2845
void
2866
2846
update_allow132(void)
2867
2847
{
2868
 
    update_menu_item(term->screen.vtMenu,
2869
 
                     vtMenuEntries[vtMenu_allow132].widget,
2870
 
                     term->screen.c132);
 
2848
    UpdateMenuItem(vtMenuEntries[vtMenu_allow132].widget,
 
2849
                   term->screen.c132);
2871
2850
}
2872
2851
 
2873
2852
void
2874
2853
update_cursesemul(void)
2875
2854
{
2876
2855
#if 0                           /* 2006-2-12: no longer menu entry */
2877
 
    update_menu_item(term->screen.vtMenu,
2878
 
                     vtMenuEntries[vtMenu_cursesemul].widget,
2879
 
                     term->screen.curses);
 
2856
    UpdateMenuItem(vtMenuEntries[vtMenu_cursesemul].widget,
 
2857
                   term->screen.curses);
2880
2858
#endif
2881
2859
}
2882
2860
 
2883
2861
void
2884
2862
update_visualbell(void)
2885
2863
{
2886
 
    update_menu_item(term->screen.vtMenu,
2887
 
                     vtMenuEntries[vtMenu_visualbell].widget,
2888
 
                     term->screen.visualbell);
 
2864
    UpdateMenuItem(vtMenuEntries[vtMenu_visualbell].widget,
 
2865
                   term->screen.visualbell);
2889
2866
}
2890
2867
 
2891
2868
void
2892
2869
update_poponbell(void)
2893
2870
{
2894
 
    update_menu_item(term->screen.vtMenu,
2895
 
                     vtMenuEntries[vtMenu_poponbell].widget,
2896
 
                     term->screen.poponbell);
 
2871
    UpdateMenuItem(vtMenuEntries[vtMenu_poponbell].widget,
 
2872
                   term->screen.poponbell);
2897
2873
}
2898
2874
 
2899
2875
void
2900
2876
update_marginbell(void)
2901
2877
{
2902
 
    update_menu_item(term->screen.vtMenu,
2903
 
                     vtMenuEntries[vtMenu_marginbell].widget,
2904
 
                     term->screen.marginbell);
 
2878
    UpdateMenuItem(vtMenuEntries[vtMenu_marginbell].widget,
 
2879
                   term->screen.marginbell);
2905
2880
}
2906
2881
 
2907
2882
#if OPT_BLINK_CURS
2908
2883
void
2909
2884
update_cursorblink(void)
2910
2885
{
2911
 
    update_menu_item(term->screen.vtMenu,
2912
 
                     vtMenuEntries[vtMenu_cursorblink].widget,
2913
 
                     term->screen.cursor_blink);
 
2886
    UpdateMenuItem(vtMenuEntries[vtMenu_cursorblink].widget,
 
2887
                   term->screen.cursor_blink);
2914
2888
}
2915
2889
#endif
2916
2890
 
2917
2891
void
2918
2892
update_altscreen(void)
2919
2893
{
2920
 
    update_menu_item(term->screen.vtMenu,
2921
 
                     vtMenuEntries[vtMenu_altscreen].widget,
2922
 
                     term->screen.alternate);
 
2894
    UpdateMenuItem(vtMenuEntries[vtMenu_altscreen].widget,
 
2895
                   term->screen.alternate);
2923
2896
}
2924
2897
 
2925
2898
void
2926
2899
update_titeInhibit(void)
2927
2900
{
2928
 
    update_menu_item(term->screen.vtMenu,
2929
 
                     vtMenuEntries[vtMenu_titeInhibit].widget,
2930
 
                     !(term->misc.titeInhibit));
 
2901
    UpdateMenuItem(vtMenuEntries[vtMenu_titeInhibit].widget,
 
2902
                   !(term->misc.titeInhibit));
2931
2903
}
2932
2904
 
2933
2905
#ifndef NO_ACTIVE_ICON
2934
2906
void
2935
2907
update_activeicon(void)
2936
2908
{
2937
 
    update_menu_item(term->screen.vtMenu,
2938
 
                     vtMenuEntries[vtMenu_activeicon].widget,
2939
 
                     term->misc.active_icon);
 
2909
    UpdateMenuItem(vtMenuEntries[vtMenu_activeicon].widget,
 
2910
                   term->misc.active_icon);
2940
2911
}
2941
2912
#endif /* NO_ACTIVE_ICON */
2942
2913
 
2944
2915
void
2945
2916
update_font_doublesize(void)
2946
2917
{
2947
 
    update_menu_item(term->screen.fontMenu,
2948
 
                     fontMenuEntries[fontMenu_font_doublesize].widget,
2949
 
                     term->screen.font_doublesize);
 
2918
    UpdateMenuItem(fontMenuEntries[fontMenu_font_doublesize].widget,
 
2919
                   term->screen.font_doublesize);
2950
2920
}
2951
2921
#endif
2952
2922
 
2954
2924
void
2955
2925
update_font_boxchars(void)
2956
2926
{
2957
 
    update_menu_item(term->screen.fontMenu,
2958
 
                     fontMenuEntries[fontMenu_font_boxchars].widget,
2959
 
                     term->screen.force_box_chars);
 
2927
    UpdateMenuItem(fontMenuEntries[fontMenu_font_boxchars].widget,
 
2928
                   term->screen.force_box_chars);
2960
2929
}
2961
2930
#endif
2962
2931
 
2964
2933
void
2965
2934
update_font_loadable(void)
2966
2935
{
2967
 
    update_menu_item(term->screen.fontMenu,
2968
 
                     fontMenuEntries[fontMenu_font_loadable].widget,
2969
 
                     term->misc.font_loadable);
 
2936
    UpdateMenuItem(fontMenuEntries[fontMenu_font_loadable].widget,
 
2937
                   term->misc.font_loadable);
2970
2938
}
2971
2939
#endif
2972
2940
 
2974
2942
void
2975
2943
update_font_renderfont(void)
2976
2944
{
2977
 
    update_menu_item(term->screen.fontMenu,
2978
 
                     fontMenuEntries[fontMenu_render_font].widget,
2979
 
                     term->misc.render_font);
 
2945
    UpdateMenuItem(fontMenuEntries[fontMenu_render_font].widget,
 
2946
                   term->misc.render_font);
2980
2947
}
2981
2948
#endif
2982
2949
 
2989
2956
    Bool enable = (term->screen.utf8_mode != uFalse);
2990
2957
 
2991
2958
    TRACE(("update_font_utf8_mode active %d, enable %d\n", active, enable));
2992
 
    set_sensitivity(term->screen.fontMenu, iw, active);
2993
 
    update_menu_item(term->screen.fontMenu, iw, enable);
 
2959
    SetItemSensitivity(iw, active);
 
2960
    UpdateMenuItem(iw, enable);
2994
2961
}
2995
2962
 
2996
2963
void
3001
2968
    Bool enable = (term->screen.utf8_title);
3002
2969
 
3003
2970
    TRACE(("update_font_utf8_title active %d, enable %d\n", active, enable));
3004
 
    set_sensitivity(term->screen.fontMenu, iw, active);
3005
 
    update_menu_item(term->screen.fontMenu, iw, enable);
 
2971
    SetItemSensitivity(iw, active);
 
2972
    UpdateMenuItem(iw, enable);
3006
2973
}
3007
2974
#endif
3008
2975
 
3011
2978
update_tekshow(void)
3012
2979
{
3013
2980
    if (!(term->screen.inhibit & I_TEK)) {
3014
 
        update_menu_item(term->screen.vtMenu,
3015
 
                         vtMenuEntries[vtMenu_tekshow].widget,
3016
 
                         term->screen.Tshow);
 
2981
        UpdateMenuItem(vtMenuEntries[vtMenu_tekshow].widget,
 
2982
                       term->screen.Tshow);
3017
2983
    }
3018
2984
}
3019
2985
 
3021
2987
update_vttekmode(void)
3022
2988
{
3023
2989
    if (!(term->screen.inhibit & I_TEK)) {
3024
 
        update_menu_item(term->screen.vtMenu,
3025
 
                         vtMenuEntries[vtMenu_tekmode].widget,
3026
 
                         term->screen.TekEmu);
3027
 
        update_menu_item(term->screen.tekMenu,
3028
 
                         tekMenuEntries[tekMenu_vtmode].widget,
3029
 
                         !term->screen.TekEmu);
 
2990
        UpdateMenuItem(vtMenuEntries[vtMenu_tekmode].widget,
 
2991
                       term->screen.TekEmu);
 
2992
        UpdateMenuItem(tekMenuEntries[tekMenu_vtmode].widget,
 
2993
                       !term->screen.TekEmu);
3030
2994
    }
3031
2995
}
3032
2996
 
3034
2998
update_vtshow(void)
3035
2999
{
3036
3000
    if (!(term->screen.inhibit & I_TEK)) {
3037
 
        update_menu_item(term->screen.tekMenu,
3038
 
                         tekMenuEntries[tekMenu_vtshow].widget,
3039
 
                         term->screen.Vshow);
 
3001
        UpdateMenuItem(tekMenuEntries[tekMenu_vtshow].widget,
 
3002
                       term->screen.Vshow);
3040
3003
    }
3041
3004
}
3042
3005
 
3044
3007
set_vthide_sensitivity(void)
3045
3008
{
3046
3009
    if (!(term->screen.inhibit & I_TEK)) {
3047
 
        set_sensitivity(term->screen.vtMenu,
3048
 
                        vtMenuEntries[vtMenu_vthide].widget,
3049
 
                        term->screen.Tshow);
 
3010
        SetItemSensitivity(
 
3011
                              vtMenuEntries[vtMenu_vthide].widget,
 
3012
                              term->screen.Tshow);
3050
3013
    }
3051
3014
}
3052
3015
 
3054
3017
set_tekhide_sensitivity(void)
3055
3018
{
3056
3019
    if (!(term->screen.inhibit & I_TEK)) {
3057
 
        set_sensitivity(term->screen.tekMenu,
3058
 
                        tekMenuEntries[tekMenu_tekhide].widget,
3059
 
                        term->screen.Vshow);
 
3020
        SetItemSensitivity(
 
3021
                              tekMenuEntries[tekMenu_tekhide].widget,
 
3022
                              term->screen.Vshow);
3060
3023
    }
3061
3024
}
3062
3025
 
3064
3027
set_tekfont_menu_item(int n, int val)
3065
3028
{
3066
3029
    if (!(term->screen.inhibit & I_TEK)) {
3067
 
        update_menu_item(term->screen.tekMenu,
3068
 
                         tekMenuEntries[FS2MI(n)].widget,
3069
 
                         (val));
 
3030
        UpdateMenuItem(tekMenuEntries[FS2MI(n)].widget,
 
3031
                       (val));
3070
3032
    }
3071
3033
}
3072
3034
#endif /* OPT_TEK4014 */
3074
3036
void
3075
3037
set_menu_font(int val)
3076
3038
{
3077
 
    update_menu_item(term->screen.fontMenu,
3078
 
                     fontMenuEntries[term->screen.menu_font_number].widget,
3079
 
                     (val));
 
3039
    UpdateMenuItem(fontMenuEntries[term->screen.menu_font_number].widget,
 
3040
                   (val));
3080
3041
}