aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/programs/xterm/menu.c
diff options
context:
space:
mode:
Diffstat (limited to 'nx-X11/programs/xterm/menu.c')
-rw-r--r--nx-X11/programs/xterm/menu.c2959
1 files changed, 2959 insertions, 0 deletions
diff --git a/nx-X11/programs/xterm/menu.c b/nx-X11/programs/xterm/menu.c
new file mode 100644
index 000000000..4f451d660
--- /dev/null
+++ b/nx-X11/programs/xterm/menu.c
@@ -0,0 +1,2959 @@
+/* $XTermId: menu.c,v 1.191 2005/11/13 23:10:36 tom Exp $ */
+
+/* $Xorg: menu.c,v 1.4 2001/02/09 02:06:03 xorgcvs Exp $ */
+/*
+
+Copyright 1999-2004,2005 by Thomas E. Dickey
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of the above listed
+copyright holder(s) not be used in advertising or publicity pertaining
+to distribution of the software without specific, written prior
+permission.
+
+THE ABOVE LISTED COPYRIGHT HOLDER(S) DISCLAIM ALL WARRANTIES WITH REGARD
+TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS, IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT HOLDER(S) BE
+LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+Copyright 1989 The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/* $XFree86: xc/programs/xterm/menu.c,v 3.64 2005/11/13 23:10:36 dickey Exp $ */
+
+#include <xterm.h>
+#include <data.h>
+#include <menu.h>
+#include <fontutils.h>
+
+#include <X11/Xmu/CharSet.h>
+
+#define app_con Xaw_app_con /* quiet a warning from SimpleMenu.h */
+
+#if defined(HAVE_LIB_XAW)
+
+#include <X11/Xaw/SimpleMenu.h>
+#include <X11/Xaw/Box.h>
+#include <X11/Xaw/SmeBSB.h>
+#include <X11/Xaw/SmeLine.h>
+
+#if OPT_TOOLBAR
+#include <X11/Xaw/MenuButton.h>
+#include <X11/Xaw/Form.h>
+#endif
+
+#elif defined(HAVE_LIB_XAW3D)
+
+#include <X11/Xaw3d/SimpleMenu.h>
+#include <X11/Xaw3d/Box.h>
+#include <X11/Xaw3d/SmeBSB.h>
+#include <X11/Xaw3d/SmeLine.h>
+
+#if OPT_TOOLBAR
+#include <X11/Xaw3d/MenuButton.h>
+#include <X11/Xaw3d/Form.h>
+#endif
+
+#elif defined(HAVE_LIB_NEXTAW)
+
+#include <X11/neXtaw/SimpleMenu.h>
+#include <X11/neXtaw/Box.h>
+#include <X11/neXtaw/SmeBSB.h>
+#include <X11/neXtaw/SmeLine.h>
+
+#if OPT_TOOLBAR
+#include <X11/neXtaw/MenuButton.h>
+#include <X11/neXtaw/Form.h>
+#endif
+
+#elif defined(HAVE_LIB_XAWPLUS)
+
+#include <X11/XawPlus/SimpleMenu.h>
+#include <X11/XawPlus/Box.h>
+#include <X11/XawPlus/SmeBSB.h>
+#include <X11/XawPlus/SmeLine.h>
+
+#if OPT_TOOLBAR
+#include <X11/XawPlus/MenuButton.h>
+#include <X11/XawPlus/Form.h>
+#endif
+
+#endif
+
+#undef app_con
+
+#include <stdio.h>
+#include <signal.h>
+/* *INDENT-OFF* */
+static void do_8bit_control PROTO_XT_CALLBACK_ARGS;
+static void do_allow132 PROTO_XT_CALLBACK_ARGS;
+static void do_allowsends PROTO_XT_CALLBACK_ARGS;
+static void do_altscreen PROTO_XT_CALLBACK_ARGS;
+static void do_appcursor PROTO_XT_CALLBACK_ARGS;
+static void do_appkeypad PROTO_XT_CALLBACK_ARGS;
+static void do_autolinefeed PROTO_XT_CALLBACK_ARGS;
+static void do_autowrap PROTO_XT_CALLBACK_ARGS;
+static void do_backarrow PROTO_XT_CALLBACK_ARGS;
+static void do_clearsavedlines PROTO_XT_CALLBACK_ARGS;
+static void do_continue PROTO_XT_CALLBACK_ARGS;
+static void do_cursesemul PROTO_XT_CALLBACK_ARGS;
+static void do_delete_del PROTO_XT_CALLBACK_ARGS;
+static void do_hardreset PROTO_XT_CALLBACK_ARGS;
+static void do_interrupt PROTO_XT_CALLBACK_ARGS;
+static void do_jumpscroll PROTO_XT_CALLBACK_ARGS;
+static void do_kill PROTO_XT_CALLBACK_ARGS;
+static void do_marginbell PROTO_XT_CALLBACK_ARGS;
+static void do_old_fkeys PROTO_XT_CALLBACK_ARGS;
+static void do_print PROTO_XT_CALLBACK_ARGS;
+static void do_print_redir PROTO_XT_CALLBACK_ARGS;
+static void do_quit PROTO_XT_CALLBACK_ARGS;
+static void do_redraw PROTO_XT_CALLBACK_ARGS;
+static void do_reversevideo PROTO_XT_CALLBACK_ARGS;
+static void do_reversewrap PROTO_XT_CALLBACK_ARGS;
+static void do_scrollbar PROTO_XT_CALLBACK_ARGS;
+static void do_scrollkey PROTO_XT_CALLBACK_ARGS;
+static void do_scrollttyoutput PROTO_XT_CALLBACK_ARGS;
+static void do_securekbd PROTO_XT_CALLBACK_ARGS;
+static void do_softreset PROTO_XT_CALLBACK_ARGS;
+static void do_sun_fkeys PROTO_XT_CALLBACK_ARGS;
+static void do_suspend PROTO_XT_CALLBACK_ARGS;
+static void do_terminate PROTO_XT_CALLBACK_ARGS;
+static void do_titeInhibit PROTO_XT_CALLBACK_ARGS;
+static void do_visualbell PROTO_XT_CALLBACK_ARGS;
+static void do_poponbell PROTO_XT_CALLBACK_ARGS;
+static void do_vtfont PROTO_XT_CALLBACK_ARGS;
+
+#ifdef ALLOWLOGGING
+static void do_logging PROTO_XT_CALLBACK_ARGS;
+#endif
+
+#ifndef NO_ACTIVE_ICON
+static void do_activeicon PROTO_XT_CALLBACK_ARGS;
+#endif /* NO_ACTIVE_ICON */
+
+#if OPT_BLINK_CURS
+static void do_cursorblink PROTO_XT_CALLBACK_ARGS;
+#endif
+
+#if OPT_BOX_CHARS
+static void do_font_boxchars PROTO_XT_CALLBACK_ARGS;
+#endif
+
+#if OPT_DEC_CHRSET
+static void do_font_doublesize PROTO_XT_CALLBACK_ARGS;
+#endif
+
+#if OPT_DEC_SOFTFONT
+static void do_font_loadable PROTO_XT_CALLBACK_ARGS;
+#endif
+
+#if OPT_HP_FUNC_KEYS
+static void do_hp_fkeys PROTO_XT_CALLBACK_ARGS;
+#endif
+
+#if OPT_NUM_LOCK
+static void do_alt_esc PROTO_XT_CALLBACK_ARGS;
+static void do_num_lock PROTO_XT_CALLBACK_ARGS;
+static void do_meta_esc PROTO_XT_CALLBACK_ARGS;
+#endif
+
+#if OPT_RENDERFONT
+static void do_font_renderfont PROTO_XT_CALLBACK_ARGS;
+#endif
+
+#if OPT_SCO_FUNC_KEYS
+static void do_sco_fkeys PROTO_XT_CALLBACK_ARGS;
+#endif
+
+#if OPT_SUNPC_KBD
+static void do_sun_kbd PROTO_XT_CALLBACK_ARGS;
+#endif
+
+#if OPT_TEK4014
+static void do_tekcopy PROTO_XT_CALLBACK_ARGS;
+static void do_tekhide PROTO_XT_CALLBACK_ARGS;
+static void do_tekmode PROTO_XT_CALLBACK_ARGS;
+static void do_tekonoff PROTO_XT_CALLBACK_ARGS;
+static void do_tekpage PROTO_XT_CALLBACK_ARGS;
+static void do_tekreset PROTO_XT_CALLBACK_ARGS;
+static void do_tekshow PROTO_XT_CALLBACK_ARGS;
+static void do_tektext2 PROTO_XT_CALLBACK_ARGS;
+static void do_tektext3 PROTO_XT_CALLBACK_ARGS;
+static void do_tektextlarge PROTO_XT_CALLBACK_ARGS;
+static void do_tektextsmall PROTO_XT_CALLBACK_ARGS;
+static void do_vthide PROTO_XT_CALLBACK_ARGS;
+static void do_vtmode PROTO_XT_CALLBACK_ARGS;
+static void do_vtonoff PROTO_XT_CALLBACK_ARGS;
+static void do_vtshow PROTO_XT_CALLBACK_ARGS;
+static void handle_tekshow (Widget gw, Bool allowswitch);
+static void handle_vtshow (Widget gw, Bool allowswitch);
+#endif
+
+#if OPT_TOOLBAR
+static void do_toolbar PROTO_XT_CALLBACK_ARGS;
+#endif
+
+#if OPT_WIDE_CHARS
+static void do_font_utf8_mode PROTO_XT_CALLBACK_ARGS;
+#endif
+
+/*
+ * The order of entries MUST match the values given in menu.h
+ */
+MenuEntry mainMenuEntries[] = {
+#if OPT_TOOLBAR
+ { "toolbar", do_toolbar, NULL },
+#endif
+ { "securekbd", do_securekbd, NULL },
+ { "allowsends", do_allowsends, NULL },
+ { "redraw", do_redraw, NULL },
+ { "line1", NULL, NULL },
+#ifdef ALLOWLOGGING
+ { "logging", do_logging, NULL },
+#endif
+ { "print", do_print, NULL },
+ { "print-redirect", do_print_redir, NULL },
+ { "line2", NULL, NULL },
+ { "8-bit control", do_8bit_control,NULL },
+ { "backarrow key", do_backarrow, NULL },
+#if OPT_NUM_LOCK
+ { "num-lock", do_num_lock, NULL },
+ { "alt-esc", do_alt_esc, NULL },
+ { "meta-esc", do_meta_esc, NULL },
+#endif
+ { "delete-is-del", do_delete_del, NULL },
+ { "oldFunctionKeys",do_old_fkeys, NULL },
+#if OPT_HP_FUNC_KEYS
+ { "hpFunctionKeys", do_hp_fkeys, NULL },
+#endif
+#if OPT_SCO_FUNC_KEYS
+ { "scoFunctionKeys",do_sco_fkeys, NULL },
+#endif
+ { "sunFunctionKeys",do_sun_fkeys, NULL },
+#if OPT_SUNPC_KBD
+ { "sunKeyboard", do_sun_kbd, NULL },
+#endif
+ { "line3", NULL, NULL },
+ { "suspend", do_suspend, NULL },
+ { "continue", do_continue, NULL },
+ { "interrupt", do_interrupt, NULL },
+ { "hangup", do_hangup, NULL },
+ { "terminate", do_terminate, NULL },
+ { "kill", do_kill, NULL },
+ { "line4", NULL, NULL },
+ { "quit", do_quit, NULL }};
+
+MenuEntry vtMenuEntries[] = {
+ { "scrollbar", do_scrollbar, NULL },
+ { "jumpscroll", do_jumpscroll, NULL },
+ { "reversevideo", do_reversevideo, NULL },
+ { "autowrap", do_autowrap, NULL },
+ { "reversewrap", do_reversewrap, NULL },
+ { "autolinefeed", do_autolinefeed, NULL },
+ { "appcursor", do_appcursor, NULL },
+ { "appkeypad", do_appkeypad, NULL },
+ { "scrollkey", do_scrollkey, NULL },
+ { "scrollttyoutput",do_scrollttyoutput, NULL },
+ { "allow132", do_allow132, NULL },
+ { "cursesemul", do_cursesemul, NULL },
+ { "visualbell", do_visualbell, NULL },
+ { "poponbell", do_poponbell, NULL },
+ { "marginbell", do_marginbell, NULL },
+#if OPT_BLINK_CURS
+ { "cursorblink", do_cursorblink, NULL },
+#endif
+ { "titeInhibit", do_titeInhibit, NULL },
+#ifndef NO_ACTIVE_ICON
+ { "activeicon", do_activeicon, NULL },
+#endif /* NO_ACTIVE_ICON */
+ { "line1", NULL, NULL },
+ { "softreset", do_softreset, NULL },
+ { "hardreset", do_hardreset, NULL },
+ { "clearsavedlines",do_clearsavedlines, NULL },
+ { "line2", NULL, NULL },
+#if OPT_TEK4014
+ { "tekshow", do_tekshow, NULL },
+ { "tekmode", do_tekmode, NULL },
+ { "vthide", do_vthide, NULL },
+#endif
+ { "altscreen", do_altscreen, NULL },
+ };
+
+MenuEntry fontMenuEntries[] = {
+ { "fontdefault", do_vtfont, NULL },
+ { "font1", do_vtfont, NULL },
+ { "font2", do_vtfont, NULL },
+ { "font3", do_vtfont, NULL },
+ { "font4", do_vtfont, NULL },
+ { "font5", do_vtfont, NULL },
+ { "font6", do_vtfont, NULL },
+ /* this is after the last builtin font; the other entries are special */
+ { "fontescape", do_vtfont, NULL },
+ { "fontsel", do_vtfont, NULL },
+ /* down to here should match NMENUFONTS in ptyx.h */
+
+#if OPT_DEC_CHRSET || OPT_BOX_CHARS || OPT_DEC_SOFTFONT
+ { "line1", NULL, NULL },
+#if OPT_BOX_CHARS
+ { "font-linedrawing",do_font_boxchars,NULL },
+#endif
+#if OPT_DEC_CHRSET
+ { "font-doublesize",do_font_doublesize,NULL },
+#endif
+#if OPT_DEC_SOFTFONT
+ { "font-loadable", do_font_loadable,NULL },
+#endif
+#endif /* toggles for DEC font extensions */
+
+#if OPT_RENDERFONT || OPT_WIDE_CHARS
+ { "line2", NULL, NULL },
+#if OPT_RENDERFONT
+ { "render-font", do_font_renderfont,NULL },
+#endif
+#if OPT_WIDE_CHARS
+ { "utf8-mode", do_font_utf8_mode,NULL },
+#endif
+#endif /* toggles for other font extensions */
+
+ };
+
+#if OPT_TEK4014
+MenuEntry tekMenuEntries[] = {
+ { "tektextlarge", do_tektextlarge, NULL },
+ { "tektext2", do_tektext2, NULL },
+ { "tektext3", do_tektext3, NULL },
+ { "tektextsmall", do_tektextsmall, NULL },
+ { "line1", NULL, NULL },
+ { "tekpage", do_tekpage, NULL },
+ { "tekreset", do_tekreset, NULL },
+ { "tekcopy", do_tekcopy, NULL },
+ { "line2", NULL, NULL },
+ { "vtshow", do_vtshow, NULL },
+ { "vtmode", do_vtmode, NULL },
+ { "tekhide", do_tekhide, NULL }};
+#endif
+
+typedef struct {
+ char *internal_name;
+ MenuEntry *entry_list;
+ Cardinal entry_len;
+} MenuHeader;
+
+ /* This table is ordered to correspond with MenuIndex */
+static MenuHeader menu_names[] = {
+ { "mainMenu", mainMenuEntries, XtNumber(mainMenuEntries) },
+ { "vtMenu", vtMenuEntries, XtNumber(vtMenuEntries) },
+ { "fontMenu", fontMenuEntries, XtNumber(fontMenuEntries) },
+#if OPT_TEK4014
+ { "tekMenu", tekMenuEntries, XtNumber(tekMenuEntries) },
+#endif
+ { 0, 0, 0 },
+};
+/* *INDENT-ON* */
+
+/*
+ * FIXME: These are global data rather than in the xterm widget because they
+ * are initialized before the widget is created.
+ */
+typedef struct {
+ Widget b; /* the toolbar's buttons */
+ Widget w; /* the popup shell activated by the button */
+ Cardinal entries;
+} MenuList;
+
+static MenuList vt_shell[NUM_POPUP_MENUS];
+
+#if OPT_TEK4014 && OPT_TOOLBAR
+static MenuList tek_shell[NUM_POPUP_MENUS];
+#endif
+
+/*
+ * Returns a pointer to the MenuList entry that matches the popup menu.
+ */
+static MenuList *
+select_menu(Widget w GCC_UNUSED, MenuIndex num)
+{
+#if OPT_TEK4014 && OPT_TOOLBAR
+ while (w != 0) {
+ if (w == tekshellwidget) {
+ return &tek_shell[num];
+ }
+ w = XtParent(w);
+ }
+#endif
+ return &vt_shell[num];
+}
+
+/*
+ * Returns a pointer to the given popup menu shell
+ */
+static Widget
+obtain_menu(Widget w, MenuIndex num)
+{
+ return select_menu(w, num)->w;
+}
+
+/*
+ * Returns the number of entries in the given popup menu shell
+ */
+static Cardinal
+sizeof_menu(Widget w, MenuIndex num)
+{
+ return select_menu(w, num)->entries;
+}
+
+/*
+ * create_menu - create a popup shell and stuff the menu into it.
+ */
+
+static Widget
+create_menu(Widget w, XtermWidget xtw, MenuIndex num)
+{
+ static XtCallbackRec cb[2] =
+ {
+ {NULL, NULL},
+ {NULL, NULL}};
+ static Arg arg =
+ {XtNcallback, (XtArgVal) cb};
+
+ Widget m;
+ TScreen *screen = &xtw->screen;
+ MenuHeader *data = &menu_names[num];
+ MenuList *list = select_menu(w, num);
+ struct _MenuEntry *entries = data->entry_list;
+ int nentries = data->entry_len;
+
+ if (screen->menu_item_bitmap == None) {
+ /*
+ * we really want to do these dynamically
+ */
+#define check_width 9
+#define check_height 8
+ static unsigned char check_bits[] =
+ {
+ 0x00, 0x01, 0x80, 0x01, 0xc0, 0x00, 0x60, 0x00,
+ 0x31, 0x00, 0x1b, 0x00, 0x0e, 0x00, 0x04, 0x00
+ };
+
+ screen->menu_item_bitmap =
+ XCreateBitmapFromData(XtDisplay(xtw),
+ RootWindowOfScreen(XtScreen(xtw)),
+ (char *) check_bits, check_width, check_height);
+ }
+#if OPT_TOOLBAR
+ m = list->w;
+ if (m == 0) {
+ return m;
+ }
+#else
+ m = XtCreatePopupShell(data->internal_name,
+ simpleMenuWidgetClass,
+ toplevel,
+ NULL, 0);
+ list->w = m;
+#endif
+ list->entries = nentries;
+
+ for (; nentries > 0; nentries--, entries++) {
+ cb[0].callback = (XtCallbackProc) entries->function;
+ cb[0].closure = (caddr_t) entries->name;
+ entries->widget = XtCreateManagedWidget(entries->name,
+ (entries->function ?
+ smeBSBObjectClass :
+ smeLineObjectClass), m,
+ &arg, (Cardinal) 1);
+ }
+
+ /* do not realize at this point */
+ return m;
+}
+
+static MenuIndex
+indexOfMenu(String menuName)
+{
+ MenuIndex me;
+ switch (*menuName) {
+ case 'm':
+ me = mainMenu;
+ break;
+ case 'v':
+ me = vtMenu;
+ break;
+ case 'f':
+ me = fontMenu;
+ break;
+#if OPT_TEK4014
+ case 't':
+ me = tekMenu;
+ break;
+#endif
+ default:
+ me = noMenu;
+ }
+ return (me);
+}
+
+/*
+ * public interfaces
+ */
+
+/* ARGSUSED */
+static Bool
+domenu(Widget w GCC_UNUSED,
+ XEvent * event GCC_UNUSED,
+ String * params, /* mainMenu, vtMenu, or tekMenu */
+ Cardinal *param_count) /* 0 or 1 */
+{
+ TScreen *screen = &term->screen;
+ MenuIndex me;
+ Bool created = False;
+ Widget mw;
+
+ if (*param_count != 1) {
+ Bell(XkbBI_MinorError, 0);
+ return False;
+ }
+
+ if ((me = indexOfMenu(params[0])) == noMenu) {
+ Bell(XkbBI_MinorError, 0);
+ return False;
+ }
+
+ if ((mw = obtain_menu(w, me)) == 0
+ || sizeof_menu(w, me) == 0) {
+ mw = create_menu(w, term, me);
+ created = (mw != 0);
+ }
+ if (mw == 0)
+ return False;
+
+ TRACE(("domenu(%s) %s\n", params[0], created ? "create" : "update"));
+ switch (me) {
+ case mainMenu:
+ if (created) {
+ update_toolbar();
+ update_securekbd();
+ update_allowsends();
+ update_logging();
+ update_print_redir();
+ update_8bit_control();
+ update_decbkm();
+ update_num_lock();
+ update_alt_esc();
+ update_meta_esc();
+ update_delete_del();
+ update_keyboard_type();
+ if (!xtermHasPrinter()) {
+ set_sensitivity(mw,
+ mainMenuEntries[mainMenu_print].widget,
+ False);
+ set_sensitivity(mw,
+ mainMenuEntries[mainMenu_print_redir].widget,
+ False);
+ }
+ if (screen->terminal_id < 200) {
+ set_sensitivity(mw,
+ mainMenuEntries[mainMenu_8bit_ctrl].widget,
+ False);
+ }
+#if !defined(SIGTSTP)
+ set_sensitivity(mw,
+ mainMenuEntries[mainMenu_suspend].widget, False);
+#endif
+#if !defined(SIGCONT)
+ set_sensitivity(mw,
+ mainMenuEntries[mainMenu_continue].widget, False);
+#endif
+#ifdef ALLOWLOGGING
+ if (screen->inhibit & I_LOG) {
+ set_sensitivity(mw,
+ mainMenuEntries[mainMenu_logging].widget, False);
+ }
+#endif
+ if (screen->inhibit & I_SIGNAL) {
+ int n;
+ for (n = (int) mainMenu_suspend; n <= (int) mainMenu_quit; ++n) {
+ set_sensitivity(mw, mainMenuEntries[n].widget, False);
+ }
+ }
+ }
+ break;
+
+ case vtMenu:
+ if (created) {
+ update_scrollbar();
+ update_jumpscroll();
+ update_reversevideo();
+ update_autowrap();
+ update_reversewrap();
+ update_autolinefeed();
+ update_appcursor();
+ update_appkeypad();
+ update_scrollkey();
+ update_scrollttyoutput();
+ update_allow132();
+ update_cursesemul();
+ update_visualbell();
+ update_poponbell();
+ update_marginbell();
+ update_cursorblink();
+ update_altscreen();
+ update_titeInhibit();
+#ifndef NO_ACTIVE_ICON
+ if (!screen->fnt_icon || !screen->iconVwin.window) {
+ set_sensitivity(mw,
+ vtMenuEntries[vtMenu_activeicon].widget,
+ False);
+ } else
+ update_activeicon();
+#endif /* NO_ACTIVE_ICON */
+#if OPT_TEK4014
+ if (screen->inhibit & I_TEK) {
+ int n;
+ for (n = (int) vtMenu_tekshow; n <= (int) vtMenu_vthide; ++n) {
+ set_sensitivity(mw, vtMenuEntries[n].widget, False);
+ }
+ }
+#endif
+ }
+ break;
+
+ case fontMenu:
+ if (created) {
+ set_menu_font(True);
+ set_sensitivity(mw,
+ fontMenuEntries[fontMenu_fontescape].widget,
+ (screen->menu_font_names[fontMenu_fontescape]
+ ? True : False));
+#if OPT_BOX_CHARS
+ update_font_boxchars();
+ set_sensitivity(mw,
+ fontMenuEntries[fontMenu_font_boxchars].widget,
+ True);
+#endif
+#if OPT_DEC_SOFTFONT /* FIXME: not implemented */
+ update_font_loadable();
+ set_sensitivity(mw,
+ fontMenuEntries[fontMenu_font_loadable].widget,
+ False);
+#endif
+#if OPT_DEC_CHRSET
+ update_font_doublesize();
+ if (term->screen.cache_doublesize == 0)
+ set_sensitivity(mw,
+ fontMenuEntries[fontMenu_font_doublesize].widget,
+ False);
+#endif
+#if OPT_RENDERFONT
+ update_font_renderfont();
+ if (term->misc.face_name == 0) {
+ set_sensitivity(mw,
+ fontMenuEntries[fontMenu_render_font].widget,
+ False);
+ }
+#endif
+#if OPT_WIDE_CHARS
+ update_font_utf8_mode();
+#endif
+ }
+ FindFontSelection(NULL, True);
+ set_sensitivity(mw,
+ fontMenuEntries[fontMenu_fontsel].widget,
+ (screen->menu_font_names[fontMenu_fontsel]
+ ? True : False));
+ break;
+
+#if OPT_TEK4014
+ case tekMenu:
+ if (created) {
+ set_tekfont_menu_item(screen->cur.fontsize, True);
+ update_vtshow();
+ }
+ break;
+#endif
+ default:
+ break;
+ }
+
+ return True;
+}
+
+void
+HandleCreateMenu(Widget w,
+ XEvent * event,
+ String * params, /* mainMenu, vtMenu, or tekMenu */
+ Cardinal *param_count) /* 0 or 1 */
+{
+ TRACE(("HandleCreateMenu\n"));
+ (void) domenu(w, event, params, param_count);
+}
+
+void
+HandlePopupMenu(Widget w,
+ XEvent * event,
+ String * params, /* mainMenu, vtMenu, or tekMenu */
+ Cardinal *param_count) /* 0 or 1 */
+{
+ TRACE(("HandlePopupMenu\n"));
+ if (domenu(w, event, params, param_count)) {
+#if OPT_TOOLBAR
+ w = select_menu(w, mainMenu)->w;
+#endif
+ XtCallActionProc(w, "XawPositionSimpleMenu", event, params, 1);
+ XtCallActionProc(w, "MenuPopup", event, params, 1);
+ }
+}
+
+/*
+ * private interfaces - keep out!
+ */
+
+/* ARGSUSED */
+static void
+handle_send_signal(Widget gw GCC_UNUSED, int sig)
+{
+#ifndef VMS
+ TScreen *screen = &term->screen;
+
+ if (hold_screen > 1)
+ hold_screen = 0;
+ if (screen->pid > 1)
+ kill_process_group(screen->pid, sig);
+#endif
+}
+
+/*
+ * action routines
+ */
+
+/* ARGSUSED */
+void
+DoSecureKeyboard(Time tp GCC_UNUSED)
+{
+ do_securekbd(vt_shell[mainMenu].w, (XtPointer) 0, (XtPointer) 0);
+}
+
+static void
+do_securekbd(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TScreen *screen = &term->screen;
+ Time now = CurrentTime; /* XXX - wrong */
+
+ if (screen->grabbedKbd) {
+ XUngrabKeyboard(screen->display, now);
+ ReverseVideo(term);
+ screen->grabbedKbd = False;
+ } else {
+ if (XGrabKeyboard(screen->display, XtWindow(CURRENT_EMU(screen)),
+ True, GrabModeAsync, GrabModeAsync, now)
+ != GrabSuccess) {
+ Bell(XkbBI_MinorError, 100);
+ } else {
+ ReverseVideo(term);
+ screen->grabbedKbd = True;
+ }
+ }
+ update_securekbd();
+}
+
+static void
+do_allowsends(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TScreen *screen = &term->screen;
+
+ screen->allowSendEvents = !screen->allowSendEvents;
+ update_allowsends();
+}
+
+static void
+do_visualbell(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TScreen *screen = &term->screen;
+
+ screen->visualbell = !screen->visualbell;
+ update_visualbell();
+}
+
+static void
+do_poponbell(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TScreen *screen = &term->screen;
+
+ screen->poponbell = !screen->poponbell;
+ update_poponbell();
+}
+
+#ifdef ALLOWLOGGING
+static void
+do_logging(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TScreen *screen = &term->screen;
+
+ if (screen->logging) {
+ CloseLog(screen);
+ } else {
+ StartLog(screen);
+ }
+ /* update_logging done by CloseLog and StartLog */
+}
+#endif
+
+static void
+do_print(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ xtermPrintScreen(True);
+}
+
+static void
+do_print_redir(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ setPrinterControlMode(term->screen.printer_controlmode ? 0 : 2);
+}
+
+static void
+do_redraw(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ Redraw();
+}
+
+void
+show_8bit_control(Bool value)
+{
+ if (term->screen.control_eight_bits != value) {
+ term->screen.control_eight_bits = value;
+ update_8bit_control();
+ }
+}
+
+static void
+do_8bit_control(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ show_8bit_control(!term->screen.control_eight_bits);
+}
+
+static void
+do_backarrow(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ term->keyboard.flags ^= MODE_DECBKM;
+ update_decbkm();
+}
+
+#if OPT_NUM_LOCK
+static void
+do_num_lock(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ term->misc.real_NumLock = !term->misc.real_NumLock;
+ update_num_lock();
+}
+
+static void
+do_alt_esc(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ term->screen.input_eight_bits = !term->screen.input_eight_bits;
+ update_alt_esc();
+}
+
+static void
+do_meta_esc(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ term->screen.meta_sends_esc = !term->screen.meta_sends_esc;
+ update_meta_esc();
+}
+#endif
+
+static void
+do_delete_del(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ if (xtermDeleteIsDEL())
+ term->screen.delete_is_del = False;
+ else
+ term->screen.delete_is_del = True;
+ update_delete_del();
+}
+
+static void
+do_old_fkeys(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ toggle_keyboard_type(keyboardIsLegacy);
+}
+
+#if OPT_HP_FUNC_KEYS
+static void
+do_hp_fkeys(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ toggle_keyboard_type(keyboardIsHP);
+}
+#endif
+
+#if OPT_SCO_FUNC_KEYS
+static void
+do_sco_fkeys(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ toggle_keyboard_type(keyboardIsSCO);
+}
+#endif
+
+static void
+do_sun_fkeys(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ toggle_keyboard_type(keyboardIsSun);
+}
+
+#if OPT_SUNPC_KBD
+/*
+ * This really means "Sun/PC keyboard emulating VT220".
+ */
+static void
+do_sun_kbd(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ toggle_keyboard_type(keyboardIsVT220);
+}
+#endif
+
+/*
+ * The following cases use the pid instead of the process group so that we
+ * don't get hosed by programs that change their process group
+ */
+
+/* ARGSUSED */
+static void
+do_suspend(Widget gw,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+#if defined(SIGTSTP)
+ handle_send_signal(gw, SIGTSTP);
+#endif
+}
+
+/* ARGSUSED */
+static void
+do_continue(Widget gw,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+#if defined(SIGCONT)
+ handle_send_signal(gw, SIGCONT);
+#endif
+}
+
+/* ARGSUSED */
+static void
+do_interrupt(Widget gw,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ handle_send_signal(gw, SIGINT);
+}
+
+/* ARGSUSED */
+void
+do_hangup(Widget gw,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ handle_send_signal(gw, SIGHUP);
+}
+
+/* ARGSUSED */
+static void
+do_terminate(Widget gw,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ handle_send_signal(gw, SIGTERM);
+}
+
+/* ARGSUSED */
+static void
+do_kill(Widget gw,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ handle_send_signal(gw, SIGKILL);
+}
+
+static void
+do_quit(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ Cleanup(0);
+}
+
+/*
+ * vt menu callbacks
+ */
+
+static void
+do_scrollbar(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ ToggleScrollBar(term);
+}
+
+static void
+do_jumpscroll(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TScreen *screen = &term->screen;
+
+ term->flags ^= SMOOTHSCROLL;
+ if (term->flags & SMOOTHSCROLL) {
+ screen->jumpscroll = False;
+ if (screen->scroll_amt)
+ FlushScroll(screen);
+ } else {
+ screen->jumpscroll = True;
+ }
+ update_jumpscroll();
+}
+
+static void
+do_reversevideo(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ ReverseVideo(term);
+}
+
+static void
+do_autowrap(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ term->flags ^= WRAPAROUND;
+ update_autowrap();
+}
+
+static void
+do_reversewrap(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ term->flags ^= REVERSEWRAP;
+ update_reversewrap();
+}
+
+static void
+do_autolinefeed(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ term->flags ^= LINEFEED;
+ update_autolinefeed();
+}
+
+static void
+do_appcursor(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ term->keyboard.flags ^= MODE_DECCKM;
+ update_appcursor();
+}
+
+static void
+do_appkeypad(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ term->keyboard.flags ^= MODE_DECKPAM;
+ update_appkeypad();
+}
+
+static void
+do_scrollkey(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TScreen *screen = &term->screen;
+
+ screen->scrollkey = !screen->scrollkey;
+ update_scrollkey();
+}
+
+static void
+do_scrollttyoutput(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TScreen *screen = &term->screen;
+
+ screen->scrollttyoutput = !screen->scrollttyoutput;
+ update_scrollttyoutput();
+}
+
+static void
+do_allow132(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TScreen *screen = &term->screen;
+
+ screen->c132 = !screen->c132;
+ update_allow132();
+}
+
+static void
+do_cursesemul(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TScreen *screen = &term->screen;
+
+ screen->curses = !screen->curses;
+ update_cursesemul();
+}
+
+static void
+do_marginbell(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TScreen *screen = &term->screen;
+
+ if (!(screen->marginbell = !screen->marginbell))
+ screen->bellarmed = -1;
+ update_marginbell();
+}
+
+#if OPT_TEK4014
+static void
+handle_tekshow(Widget gw GCC_UNUSED, Bool allowswitch)
+{
+ TScreen *screen = &term->screen;
+
+ if (!screen->Tshow) { /* not showing, turn on */
+ set_tek_visibility(True);
+ } else if (screen->Vshow || allowswitch) { /* is showing, turn off */
+ set_tek_visibility(False);
+ end_tek_mode(); /* WARNING: this does a longjmp */
+ } else
+ Bell(XkbBI_MinorError, 0);
+}
+
+/* ARGSUSED */
+static void
+do_tekshow(Widget gw,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ handle_tekshow(gw, True);
+}
+
+/* ARGSUSED */
+static void
+do_tekonoff(Widget gw,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ handle_tekshow(gw, False);
+}
+#endif /* OPT_TEK4014 */
+
+#if OPT_BLINK_CURS
+/* ARGSUSED */
+static void
+do_cursorblink(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TScreen *screen = &term->screen;
+ ToggleCursorBlink(screen);
+}
+#endif
+
+/* ARGSUSED */
+static void
+do_altscreen(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TScreen *screen = &term->screen;
+ ToggleAlternate(screen);
+}
+
+/* ARGSUSED */
+static void
+do_titeInhibit(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ term->misc.titeInhibit = !term->misc.titeInhibit;
+ update_titeInhibit();
+}
+
+#ifndef NO_ACTIVE_ICON
+/* ARGSUSED */
+static void
+do_activeicon(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TScreen *screen = &term->screen;
+
+ if (screen->iconVwin.window) {
+ Widget shell = XtParent(term);
+ term->misc.active_icon = !term->misc.active_icon;
+ XtVaSetValues(shell, XtNiconWindow,
+ term->misc.active_icon ? screen->iconVwin.window : None,
+ (XtPointer) 0);
+ update_activeicon();
+ }
+}
+#endif /* NO_ACTIVE_ICON */
+
+static void
+do_softreset(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ VTReset(False, False);
+}
+
+static void
+do_hardreset(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ VTReset(True, False);
+}
+
+static void
+do_clearsavedlines(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ VTReset(True, True);
+}
+
+#if OPT_TEK4014
+static void
+do_tekmode(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TScreen *screen = &term->screen;
+
+ switch_modes(screen->TekEmu); /* switch to tek mode */
+}
+
+/* ARGSUSED */
+static void
+do_vthide(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ hide_vt_window();
+}
+#endif /* OPT_TEK4014 */
+
+/*
+ * vtfont menu
+ */
+
+static void
+do_vtfont(Widget gw GCC_UNUSED,
+ XtPointer closure,
+ XtPointer data GCC_UNUSED)
+{
+ char *entryname = (char *) closure;
+ int i;
+
+ for (i = 0; i < NMENUFONTS; i++) {
+ if (strcmp(entryname, fontMenuEntries[i].name) == 0) {
+ SetVTFont(term, i, True, NULL);
+ return;
+ }
+ }
+ Bell(XkbBI_MinorError, 0);
+}
+
+#if OPT_DEC_CHRSET
+static void
+do_font_doublesize(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ if (term->screen.cache_doublesize != 0)
+ term->screen.font_doublesize = !term->screen.font_doublesize;
+ update_font_doublesize();
+ Redraw();
+}
+#endif
+
+#if OPT_BOX_CHARS
+static void
+do_font_boxchars(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ term->screen.force_box_chars = !term->screen.force_box_chars;
+ update_font_boxchars();
+ Redraw();
+}
+#endif
+
+#if OPT_DEC_SOFTFONT
+static void
+do_font_loadable(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ term->misc.font_loadable = !term->misc.font_loadable;
+ update_font_loadable();
+}
+#endif
+
+#if OPT_RENDERFONT
+static void
+do_font_renderfont(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TScreen *screen = &term->screen;
+ int fontnum = screen->menu_font_number;
+ String name = term->screen.MenuFontName(fontnum);
+
+ term->misc.render_font = !term->misc.render_font;
+ update_font_renderfont();
+ xtermLoadFont(term, xtermFontName(name), True, fontnum);
+ ScrnRefresh(screen, 0, 0,
+ MaxRows(screen),
+ MaxCols(screen), True);
+}
+#endif
+
+#if OPT_WIDE_CHARS
+static void
+do_font_utf8_mode(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TScreen *screen = &term->screen;
+
+ /*
+ * If xterm was started with -wc option, it might not have the wide fonts.
+ * If xterm was not started with -wc, it might not have wide cells.
+ */
+ if (!screen->utf8_mode) {
+ if (screen->wide_chars) {
+ if (xtermLoadWideFonts(term, True)) {
+ SetVTFont(term, screen->menu_font_number, TRUE, NULL);
+ }
+ } else {
+ ChangeToWide(screen);
+ }
+ }
+ switchPtyData(screen, !screen->utf8_mode);
+ /*
+ * We don't repaint the screen when switching UTF-8 on/off. When switching
+ * on - the Latin-1 codes should paint as-is. When switching off, that's
+ * hard to do properly.
+ */
+}
+#endif
+
+/*
+ * tek menu
+ */
+
+#if OPT_TEK4014
+static void
+do_tektextlarge(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TekSetFontSize(tekMenu_tektextlarge);
+}
+
+static void
+do_tektext2(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TekSetFontSize(tekMenu_tektext2);
+}
+
+static void
+do_tektext3(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TekSetFontSize(tekMenu_tektext3);
+}
+
+static void
+do_tektextsmall(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+
+ TekSetFontSize(tekMenu_tektextsmall);
+}
+
+static void
+do_tekpage(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TekSimulatePageButton(False);
+}
+
+static void
+do_tekreset(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TekSimulatePageButton(True);
+}
+
+static void
+do_tekcopy(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TekCopy();
+}
+
+static void
+handle_vtshow(Widget gw GCC_UNUSED, Bool allowswitch)
+{
+ TScreen *screen = &term->screen;
+
+ if (!screen->Vshow) { /* not showing, turn on */
+ set_vt_visibility(True);
+ } else if (screen->Tshow || allowswitch) { /* is showing, turn off */
+ set_vt_visibility(False);
+ if (!screen->TekEmu && TekRefresh)
+ dorefresh();
+ end_vt_mode(); /* WARNING: this does a longjmp... */
+ } else
+ Bell(XkbBI_MinorError, 0);
+}
+
+static void
+do_vtshow(Widget gw,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ handle_vtshow(gw, True);
+}
+
+static void
+do_vtonoff(Widget gw,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ handle_vtshow(gw, False);
+}
+
+static void
+do_vtmode(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ TScreen *screen = &term->screen;
+
+ switch_modes(screen->TekEmu); /* switch to vt, or from */
+}
+
+/* ARGSUSED */
+static void
+do_tekhide(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ hide_tek_window();
+}
+#endif /* OPT_TEK4014 */
+
+/*
+ * public handler routines
+ */
+
+static void
+handle_toggle(void (*proc) PROTO_XT_CALLBACK_ARGS,
+ int var,
+ String * params,
+ Cardinal nparams,
+ Widget w,
+ XtPointer closure,
+ XtPointer data)
+{
+ int dir = -2;
+
+ switch (nparams) {
+ case 0:
+ dir = -1;
+ break;
+ case 1:
+ if (XmuCompareISOLatin1(params[0], "on") == 0)
+ dir = 1;
+ else if (XmuCompareISOLatin1(params[0], "off") == 0)
+ dir = 0;
+ else if (XmuCompareISOLatin1(params[0], "toggle") == 0)
+ dir = -1;
+ break;
+ }
+
+ switch (dir) {
+ case -2:
+ Bell(XkbBI_MinorError, 0);
+ break;
+
+ case -1:
+ (*proc) (w, closure, data);
+ break;
+
+ case 0:
+ if (var)
+ (*proc) (w, closure, data);
+ else
+ Bell(XkbBI_MinorError, 0);
+ break;
+
+ case 1:
+ if (!var)
+ (*proc) (w, closure, data);
+ else
+ Bell(XkbBI_MinorError, 0);
+ break;
+ }
+ return;
+}
+
+#define handle_vt_toggle(proc, var, params, nparams, w) \
+ handle_toggle(proc, (int) (var), params, nparams, w, (XtPointer)0, (XtPointer)0)
+
+#define handle_tek_toggle(proc, var, params, nparams, w) \
+ handle_toggle(proc, (int) (var), params, nparams, w, (XtPointer)0, (XtPointer)0)
+
+void
+HandleAllowSends(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_allowsends, term->screen.allowSendEvents,
+ params, *param_count, w);
+}
+
+void
+HandleSetVisualBell(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_visualbell, term->screen.visualbell,
+ params, *param_count, w);
+}
+
+void
+HandleSetPopOnBell(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_poponbell, term->screen.poponbell,
+ params, *param_count, w);
+}
+
+#ifdef ALLOWLOGGING
+void
+HandleLogging(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_logging, term->screen.logging,
+ params, *param_count, w);
+}
+#endif
+
+/* ARGSUSED */
+void
+HandlePrintScreen(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params GCC_UNUSED,
+ Cardinal *param_count GCC_UNUSED)
+{
+ do_print(w, (XtPointer) 0, (XtPointer) 0);
+}
+
+/* ARGSUSED */
+void
+HandlePrintControlMode(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params GCC_UNUSED,
+ Cardinal *param_count GCC_UNUSED)
+{
+ do_print_redir(w, (XtPointer) 0, (XtPointer) 0);
+}
+
+/* ARGSUSED */
+void
+HandleRedraw(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params GCC_UNUSED,
+ Cardinal *param_count GCC_UNUSED)
+{
+ do_redraw(w, (XtPointer) 0, (XtPointer) 0);
+}
+
+/* ARGSUSED */
+void
+HandleSendSignal(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ /* *INDENT-OFF* */
+ static struct sigtab {
+ char *name;
+ int sig;
+ } signals[] = {
+#ifdef SIGTSTP
+ { "suspend", SIGTSTP },
+ { "tstp", SIGTSTP },
+#endif
+#ifdef SIGCONT
+ { "cont", SIGCONT },
+#endif
+ { "int", SIGINT },
+ { "hup", SIGHUP },
+ { "quit", SIGQUIT },
+ { "alrm", SIGALRM },
+ { "alarm", SIGALRM },
+ { "term", SIGTERM },
+ { "kill", SIGKILL },
+ { NULL, 0 },
+ };
+ /* *INDENT-ON* */
+
+ if (*param_count == 1) {
+ struct sigtab *st;
+
+ for (st = signals; st->name; st++) {
+ if (XmuCompareISOLatin1(st->name, params[0]) == 0) {
+ handle_send_signal(w, st->sig);
+ return;
+ }
+ }
+ /* one could allow numeric values, but that would be a security hole */
+ }
+
+ Bell(XkbBI_MinorError, 0);
+}
+
+/* ARGSUSED */
+void
+HandleQuit(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params GCC_UNUSED,
+ Cardinal *param_count GCC_UNUSED)
+{
+ do_quit(w, (XtPointer) 0, (XtPointer) 0);
+}
+
+void
+Handle8BitControl(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_8bit_control, term->screen.control_eight_bits,
+ params, *param_count, w);
+}
+
+void
+HandleBackarrow(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_backarrow, term->keyboard.flags & MODE_DECBKM,
+ params, *param_count, w);
+}
+
+void
+HandleSunFunctionKeys(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_sun_fkeys, term->keyboard.type == keyboardIsSun,
+ params, *param_count, w);
+}
+
+#if OPT_NUM_LOCK
+void
+HandleNumLock(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_num_lock, term->misc.real_NumLock,
+ params, *param_count, w);
+}
+
+void
+HandleAltEsc(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_alt_esc, !term->screen.input_eight_bits,
+ params, *param_count, w);
+}
+
+void
+HandleMetaEsc(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_meta_esc, term->screen.meta_sends_esc,
+ params, *param_count, w);
+}
+#endif
+
+void
+HandleDeleteIsDEL(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_delete_del, term->screen.delete_is_del,
+ params, *param_count, w);
+}
+
+void
+HandleOldFunctionKeys(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_old_fkeys, term->keyboard.type == keyboardIsLegacy,
+ params, *param_count, w);
+}
+
+#if OPT_SUNPC_KBD
+void
+HandleSunKeyboard(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_sun_kbd, term->keyboard.type == keyboardIsVT220,
+ params, *param_count, w);
+}
+#endif
+
+#if OPT_HP_FUNC_KEYS
+void
+HandleHpFunctionKeys(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_hp_fkeys, term->keyboard.type == keyboardIsHP,
+ params, *param_count, w);
+}
+#endif
+
+#if OPT_SCO_FUNC_KEYS
+void
+HandleScoFunctionKeys(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_sco_fkeys, term->keyboard.type == keyboardIsSCO,
+ params, *param_count, w);
+}
+#endif
+
+void
+HandleScrollbar(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ if (IsIcon(&(term->screen))) {
+ Bell(XkbBI_MinorError, 0);
+ } else {
+ handle_vt_toggle(do_scrollbar, term->screen.fullVwin.sb_info.width,
+ params, *param_count, w);
+ }
+}
+
+void
+HandleJumpscroll(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_jumpscroll, term->screen.jumpscroll,
+ params, *param_count, w);
+}
+
+void
+HandleReverseVideo(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_reversevideo, (term->misc.re_verse0),
+ params, *param_count, w);
+}
+
+void
+HandleAutoWrap(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_autowrap, (term->flags & WRAPAROUND),
+ params, *param_count, w);
+}
+
+void
+HandleReverseWrap(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_reversewrap, (term->flags & REVERSEWRAP),
+ params, *param_count, w);
+}
+
+void
+HandleAutoLineFeed(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_autolinefeed, (term->flags & LINEFEED),
+ params, *param_count, w);
+}
+
+void
+HandleAppCursor(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_appcursor, (term->keyboard.flags & MODE_DECCKM),
+ params, *param_count, w);
+}
+
+void
+HandleAppKeypad(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_appkeypad, (term->keyboard.flags & MODE_DECKPAM),
+ params, *param_count, w);
+}
+
+void
+HandleScrollKey(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_scrollkey, term->screen.scrollkey,
+ params, *param_count, w);
+}
+
+void
+HandleScrollTtyOutput(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_scrollttyoutput, term->screen.scrollttyoutput,
+ params, *param_count, w);
+}
+
+void
+HandleAllow132(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_allow132, term->screen.c132,
+ params, *param_count, w);
+}
+
+void
+HandleCursesEmul(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_cursesemul, term->screen.curses,
+ params, *param_count, w);
+}
+
+void
+HandleMarginBell(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_marginbell, term->screen.marginbell,
+ params, *param_count, w);
+}
+
+#if OPT_BLINK_CURS
+void
+HandleCursorBlink(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ /* eventually want to see if sensitive or not */
+ handle_vt_toggle(do_cursorblink, term->screen.cursor_blink,
+ params, *param_count, w);
+}
+#endif
+
+void
+HandleAltScreen(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ /* eventually want to see if sensitive or not */
+ handle_vt_toggle(do_altscreen, term->screen.alternate,
+ params, *param_count, w);
+}
+
+void
+HandleTiteInhibit(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ /* eventually want to see if sensitive or not */
+ handle_vt_toggle(do_titeInhibit, !(term->misc.titeInhibit),
+ params, *param_count, w);
+}
+
+/* ARGSUSED */
+void
+HandleSoftReset(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params GCC_UNUSED,
+ Cardinal *param_count GCC_UNUSED)
+{
+ do_softreset(w, (XtPointer) 0, (XtPointer) 0);
+}
+
+/* ARGSUSED */
+void
+HandleHardReset(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params GCC_UNUSED,
+ Cardinal *param_count GCC_UNUSED)
+{
+ do_hardreset(w, (XtPointer) 0, (XtPointer) 0);
+}
+
+/* ARGSUSED */
+void
+HandleClearSavedLines(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params GCC_UNUSED,
+ Cardinal *param_count GCC_UNUSED)
+{
+ do_clearsavedlines(w, (XtPointer) 0, (XtPointer) 0);
+}
+
+#if OPT_DEC_CHRSET
+void
+HandleFontDoublesize(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_font_doublesize, term->screen.font_doublesize,
+ params, *param_count, w);
+}
+#endif
+
+#if OPT_BOX_CHARS
+void
+HandleFontBoxChars(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_font_boxchars, term->screen.force_box_chars,
+ params, *param_count, w);
+}
+#endif
+
+#if OPT_DEC_SOFTFONT
+void
+HandleFontLoading(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_font_loadable, term->misc.font_loadable,
+ params, *param_count, w);
+}
+#endif
+
+#if OPT_RENDERFONT
+void
+HandleRenderFont(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_font_renderfont, term->misc.render_font,
+ params, *param_count, w);
+}
+#endif
+
+#if OPT_WIDE_CHARS
+void
+HandleUTF8Mode(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ handle_vt_toggle(do_font_utf8_mode, term->screen.utf8_mode,
+ params, *param_count, w);
+}
+#endif
+
+#if OPT_TEK4014
+void
+HandleSetTerminalType(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ if (*param_count == 1) {
+ switch (params[0][0]) {
+ case 'v':
+ case 'V':
+ if (term->screen.TekEmu)
+ do_vtmode(w, (XtPointer) 0, (XtPointer) 0);
+ break;
+ case 't':
+ case 'T':
+ if (!term->screen.TekEmu)
+ do_tekmode(w, (XtPointer) 0, (XtPointer) 0);
+ break;
+ default:
+ Bell(XkbBI_MinorError, 0);
+ }
+ } else {
+ Bell(XkbBI_MinorError, 0);
+ }
+}
+
+void
+HandleVisibility(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ if (*param_count == 2) {
+ switch (params[0][0]) {
+ case 'v':
+ case 'V':
+ handle_tek_toggle(do_vtonoff, (int) term->screen.Vshow,
+ params + 1, (*param_count) - 1, w);
+ break;
+ case 't':
+ case 'T':
+ handle_tek_toggle(do_tekonoff, (int) term->screen.Tshow,
+ params + 1, (*param_count) - 1, w);
+ break;
+ default:
+ Bell(XkbBI_MinorError, 0);
+ }
+ } else {
+ Bell(XkbBI_MinorError, 0);
+ }
+}
+
+/* ARGSUSED */
+void
+HandleSetTekText(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params,
+ Cardinal *param_count)
+{
+ void (*proc) PROTO_XT_CALLBACK_ARGS = 0;
+
+ switch (*param_count) {
+ case 0:
+ proc = do_tektextlarge;
+ break;
+ case 1:
+ switch (params[0][0]) {
+ case 'l':
+ case 'L':
+ proc = do_tektextlarge;
+ break;
+ case '2':
+ proc = do_tektext2;
+ break;
+ case '3':
+ proc = do_tektext3;
+ break;
+ case 's':
+ case 'S':
+ proc = do_tektextsmall;
+ break;
+ }
+ break;
+ }
+ if (proc)
+ (*proc) (w, (XtPointer) 0, (XtPointer) 0);
+ else
+ Bell(XkbBI_MinorError, 0);
+}
+
+/* ARGSUSED */
+void
+HandleTekPage(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params GCC_UNUSED,
+ Cardinal *param_count GCC_UNUSED)
+{
+ do_tekpage(w, (XtPointer) 0, (XtPointer) 0);
+}
+
+/* ARGSUSED */
+void
+HandleTekReset(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params GCC_UNUSED,
+ Cardinal *param_count GCC_UNUSED)
+{
+ do_tekreset(w, (XtPointer) 0, (XtPointer) 0);
+}
+
+/* ARGSUSED */
+void
+HandleTekCopy(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params GCC_UNUSED,
+ Cardinal *param_count GCC_UNUSED)
+{
+ do_tekcopy(w, (XtPointer) 0, (XtPointer) 0);
+}
+#endif /* OPT_TEK4014 */
+
+void
+UpdateMenuItem(Widget mi, XtArgVal val)
+{
+ static Arg menuArgs =
+ {XtNleftBitmap, (XtArgVal) 0};
+
+ if (mi) {
+ menuArgs.value = (XtArgVal) ((val)
+ ? term->screen.menu_item_bitmap
+ : None);
+ XtSetValues(mi, &menuArgs, (Cardinal) 1);
+ }
+}
+
+void
+SetItemSensitivity(Widget mi, XtArgVal val)
+{
+ static Arg menuArgs =
+ {XtNsensitive, (XtArgVal) 0};
+
+ if (mi) {
+ menuArgs.value = (XtArgVal) (val);
+ XtSetValues(mi, &menuArgs, (Cardinal) 1);
+ }
+}
+
+#if OPT_TOOLBAR
+/*
+ * The normal style of xterm popup menu delays initialization until the menu is
+ * first requested. When using a toolbar, we can use the same initialization,
+ * though on the first popup there will be a little geometry layout jitter,
+ * since the menu is already managed when this callback is invoked.
+ */
+static void
+InitPopup(Widget gw,
+ XtPointer closure,
+ XtPointer data GCC_UNUSED)
+{
+ String params[2];
+ Cardinal count = 1;
+
+ params[0] = (char *) closure;
+ params[1] = 0;
+ TRACE(("InitPopup(%s)\n", params[0]));
+
+ domenu(gw, (XEvent *) 0, params, &count);
+
+ if (gw)
+ XtRemoveCallback(gw, XtNpopupCallback, InitPopup, closure);
+}
+
+static void
+SetupShell(Widget *menus, MenuList * shell, int n, int m)
+{
+ char temp[80];
+ char *external_name = 0;
+
+ shell[n].w = XtVaCreatePopupShell(menu_names[n].internal_name,
+ simpleMenuWidgetClass,
+ *menus,
+ XtNgeometry, NULL,
+ (XtPointer) 0);
+
+ XtAddCallback(shell[n].w, XtNpopupCallback, InitPopup, menu_names[n].internal_name);
+ XtVaGetValues(shell[n].w,
+ XtNlabel, &external_name,
+ (XtPointer) 0);
+
+ TRACE(("...SetupShell(%s) -> %s -> %#lx\n",
+ menu_names[n].internal_name,
+ external_name,
+ (long) shell[n].w));
+
+ sprintf(temp, "%sButton", menu_names[n].internal_name);
+ shell[n].b = XtVaCreateManagedWidget(temp,
+ menuButtonWidgetClass,
+ *menus,
+ XtNfromHoriz, ((m >= 0)
+ ? shell[m].b
+ : 0),
+ XtNmenuName, menu_names[n].internal_name,
+ XtNlabel, external_name,
+ (XtPointer) 0);
+}
+
+#endif
+
+void
+SetupMenus(Widget shell, Widget *forms, Widget *menus)
+{
+#if OPT_TOOLBAR
+ Cardinal n;
+ Arg args[10];
+#endif
+
+ TRACE(("SetupMenus(%s)\n", shell == toplevel ? "vt100" : "tek4014"));
+
+ if (shell == toplevel) {
+ XawSimpleMenuAddGlobalActions(app_con);
+ XtRegisterGrabAction(HandlePopupMenu, True,
+ (ButtonPressMask | ButtonReleaseMask),
+ GrabModeAsync, GrabModeAsync);
+ }
+#if OPT_TOOLBAR
+ *forms = XtVaCreateManagedWidget("form",
+ formWidgetClass, shell,
+ (XtPointer) 0);
+ xtermAddInput(*forms);
+
+ /*
+ * Set a nominal value for the preferred pane size, which lets the
+ * buttons determine the actual height of the menu bar. We don't show
+ * the grip, because it's too easy to make the toolbar look bad that
+ * way.
+ */
+ XtSetArg(args[0], XtNorientation, XtorientHorizontal);
+ XtSetArg(args[1], XtNtop, XawChainTop);
+ XtSetArg(args[2], XtNbottom, XawChainTop);
+ XtSetArg(args[3], XtNleft, XawChainLeft);
+ XtSetArg(args[4], XtNright, XawChainLeft);
+
+ if (resource.toolBar)
+ *menus = XtCreateManagedWidget("menubar", boxWidgetClass, *forms,
+ args, 5);
+ else
+ *menus = XtCreateWidget("menubar", boxWidgetClass, *forms, args, 5);
+
+ if (shell == toplevel) { /* vt100 */
+ for (n = mainMenu; n <= fontMenu; n++) {
+ SetupShell(menus, vt_shell, n, n - 1);
+ }
+ }
+#if OPT_TEK4014
+ else { /* tek4014 */
+ SetupShell(menus, tek_shell, mainMenu, -1);
+ SetupShell(menus, tek_shell, tekMenu, mainMenu);
+ }
+#endif
+
+#else
+ *forms = shell;
+ *menus = shell;
+#endif
+
+ TRACE(("...shell=%#lx\n", (long) shell));
+ TRACE(("...forms=%#lx\n", (long) *forms));
+ TRACE(("...menus=%#lx\n", (long) *menus));
+}
+
+void
+repairSizeHints(void)
+{
+ TScreen *screen = &term->screen;
+
+ XSizeHints sizehints;
+
+ if (XtIsRealized((Widget) term)) {
+ bzero(&sizehints, sizeof(sizehints));
+ xtermSizeHints(term, &sizehints, ScrollbarWidth(screen));
+
+ XSetWMNormalHints(screen->display, XtWindow(SHELL_OF(term)), &sizehints);
+ }
+}
+
+#if OPT_TOOLBAR
+static int called_SetupToolbar[2] =
+{False, False};
+
+static void
+SetupToolbar(int which)
+{
+ int n;
+
+ TRACE(("SetupToolbar(%s)\n", which ? "vt100" : "tek4014"));
+
+ if (which) { /* vt100 */
+ for (n = mainMenu; n <= fontMenu; n++) {
+ InitPopup(vt_shell[n].w, menu_names[n].internal_name, 0);
+ }
+ }
+#if OPT_TEK4014
+ else { /* tek4014 */
+ InitPopup(tek_shell[mainMenu].w, menu_names[mainMenu].internal_name, 0);
+ InitPopup(tek_shell[tekMenu].w, menu_names[tekMenu].internal_name, 0);
+ }
+#endif
+ called_SetupToolbar[which] = True;
+ ShowToolbar(resource.toolBar);
+}
+
+static TbInfo *
+toolbar_info(Widget w)
+{
+ TRACE(("...getting toolbar_info\n"));
+#if OPT_TEK4014
+ if (w != (Widget) term)
+ return &(tekWidget->tek.tb_info);
+#endif
+ return &(WhichVWin(&(term->screen))->tb_info);
+}
+
+static void
+hide_toolbar(Widget w)
+{
+ if (w != 0) {
+ TbInfo *info = toolbar_info(w);
+
+ TRACE(("hiding toolbar\n"));
+ XtVaSetValues(w,
+ XtNfromVert, (Widget) 0,
+ (XtPointer) 0);
+
+ if (info->menu_bar != 0) {
+ repairSizeHints();
+ XtUnmanageChild(info->menu_bar);
+ if (XtIsRealized(info->menu_bar)) {
+ XtUnmapWidget(info->menu_bar);
+ }
+ }
+ TRACE(("...hiding toolbar (done)\n"));
+ }
+}
+
+static void
+show_toolbar(Widget w)
+{
+ if (w != 0) {
+ TbInfo *info = toolbar_info(w);
+
+ TRACE(("showing toolbar\n"));
+ if (info->menu_bar != 0) {
+ XtVaSetValues(w,
+ XtNfromVert, info->menu_bar,
+ (XtPointer) 0);
+ if (XtIsRealized(info->menu_bar))
+ repairSizeHints();
+ XtManageChild(info->menu_bar);
+ if (XtIsRealized(info->menu_bar)) {
+ XtMapWidget(info->menu_bar);
+ }
+ }
+ /*
+ * This is needed to make the terminal widget move down below the
+ * toolbar.
+ */
+ XawFormDoLayout(XtParent(w), True);
+ TRACE(("...showing toolbar (done)\n"));
+ }
+}
+
+/*
+ * Make the toolbar visible or invisible in the current window(s).
+ */
+void
+ShowToolbar(Bool enable)
+{
+ TRACE(("ShowToolbar(%d)\n", enable));
+
+ if (IsIcon(&(term->screen))) {
+ Bell(XkbBI_MinorError, 0);
+ } else {
+ if (enable) {
+ int which = !TEK4014_ACTIVE(&(term->screen));
+ if (!called_SetupToolbar[which])
+ SetupToolbar(which);
+ show_toolbar((Widget) term);
+#if OPT_TEK4014
+ show_toolbar((Widget) tekWidget);
+#endif
+ } else {
+ hide_toolbar((Widget) term);
+#if OPT_TEK4014
+ hide_toolbar((Widget) tekWidget);
+#endif
+ }
+ resource.toolBar = enable;
+ update_toolbar();
+ }
+}
+
+void
+HandleToolbar(Widget w,
+ XEvent * event GCC_UNUSED,
+ String * params GCC_UNUSED,
+ Cardinal *param_count GCC_UNUSED)
+{
+ if (IsIcon(&(term->screen))) {
+ Bell(XkbBI_MinorError, 0);
+ } else {
+ handle_vt_toggle(do_toolbar, resource.toolBar,
+ params, *param_count, w);
+ }
+}
+
+/* ARGSUSED */
+static void
+do_toolbar(Widget gw GCC_UNUSED,
+ XtPointer closure GCC_UNUSED,
+ XtPointer data GCC_UNUSED)
+{
+ /*
+ * Toggle toolbars for both vt100 and tek windows, since they share the
+ * menu which contains the checkbox indicating whether the toolbar is
+ * active.
+ */
+ if (IsIcon(&(term->screen))) {
+ Bell(XkbBI_MinorError, 0);
+ } else {
+ ShowToolbar(resource.toolBar = !resource.toolBar);
+ }
+}
+
+void
+update_toolbar(void)
+{
+ update_menu_item(term->screen.mainMenu,
+ mainMenuEntries[mainMenu_toolbar].widget,
+ resource.toolBar);
+}
+#endif /* OPT_TOOLBAR */
+
+void
+update_securekbd(void)
+{
+ update_menu_item(term->screen.mainMenu,
+ mainMenuEntries[mainMenu_securekbd].widget,
+ term->screen.grabbedKbd);
+}
+
+void
+update_allowsends(void)
+{
+ update_menu_item(term->screen.mainMenu,
+ mainMenuEntries[mainMenu_allowsends].widget,
+ term->screen.allowSendEvents);
+}
+
+#ifdef ALLOWLOGGING
+void
+update_logging(void)
+{
+ update_menu_item(term->screen.mainMenu,
+ mainMenuEntries[mainMenu_logging].widget,
+ term->screen.logging);
+}
+#endif
+
+void
+update_print_redir(void)
+{
+ update_menu_item(term->screen.mainMenu,
+ mainMenuEntries[mainMenu_print_redir].widget,
+ term->screen.printer_controlmode);
+}
+
+void
+update_8bit_control(void)
+{
+ update_menu_item(term->screen.mainMenu,
+ mainMenuEntries[mainMenu_8bit_ctrl].widget,
+ term->screen.control_eight_bits);
+}
+
+void
+update_decbkm(void)
+{
+ update_menu_item(term->screen.mainMenu,
+ mainMenuEntries[mainMenu_backarrow].widget,
+ (term->keyboard.flags & MODE_DECBKM) != 0);
+}
+
+#if OPT_NUM_LOCK
+void
+update_num_lock(void)
+{
+ update_menu_item(term->screen.mainMenu,
+ mainMenuEntries[mainMenu_num_lock].widget,
+ term->misc.real_NumLock);
+}
+
+void
+update_alt_esc(void)
+{
+ update_menu_item(term->screen.mainMenu,
+ mainMenuEntries[mainMenu_alt_esc].widget,
+ !term->screen.input_eight_bits);
+}
+
+void
+update_meta_esc(void)
+{
+ update_menu_item(term->screen.mainMenu,
+ mainMenuEntries[mainMenu_meta_esc].widget,
+ term->screen.meta_sends_esc);
+}
+#endif
+
+void
+update_sun_fkeys(void)
+{
+ update_menu_item(term->screen.mainMenu,
+ mainMenuEntries[mainMenu_sun_fkeys].widget,
+ term->keyboard.type == keyboardIsSun);
+}
+
+void
+update_old_fkeys(void)
+{
+ update_menu_item(term->screen.mainMenu,
+ mainMenuEntries[mainMenu_old_fkeys].widget,
+ term->keyboard.type == keyboardIsLegacy);
+}
+
+void
+update_delete_del(void)
+{
+ update_menu_item(term->screen.mainMenu,
+ mainMenuEntries[mainMenu_delete_del].widget,
+ xtermDeleteIsDEL());
+}
+
+#if OPT_SUNPC_KBD
+void
+update_sun_kbd(void)
+{
+ update_menu_item(term->screen.mainMenu,
+ mainMenuEntries[mainMenu_sun_kbd].widget,
+ term->keyboard.type == keyboardIsVT220);
+}
+#endif
+
+#if OPT_HP_FUNC_KEYS
+void
+update_hp_fkeys(void)
+{
+ update_menu_item(term->screen.mainMenu,
+ mainMenuEntries[mainMenu_hp_fkeys].widget,
+ term->keyboard.type == keyboardIsHP);
+}
+#endif
+
+#if OPT_SCO_FUNC_KEYS
+void
+update_sco_fkeys(void)
+{
+ update_menu_item(term->screen.mainMenu,
+ mainMenuEntries[mainMenu_sco_fkeys].widget,
+ term->keyboard.type == keyboardIsSCO);
+}
+#endif
+
+void
+update_scrollbar(void)
+{
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_scrollbar].widget,
+ ScrollbarWidth(&term->screen));
+}
+
+void
+update_jumpscroll(void)
+{
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_jumpscroll].widget,
+ term->screen.jumpscroll);
+}
+
+void
+update_reversevideo(void)
+{
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_reversevideo].widget,
+ (term->misc.re_verse));
+}
+
+void
+update_autowrap(void)
+{
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_autowrap].widget,
+ (term->flags & WRAPAROUND) != 0);
+}
+
+void
+update_reversewrap(void)
+{
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_reversewrap].widget,
+ (term->flags & REVERSEWRAP) != 0);
+}
+
+void
+update_autolinefeed(void)
+{
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_autolinefeed].widget,
+ (term->flags & LINEFEED) != 0);
+}
+
+void
+update_appcursor(void)
+{
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_appcursor].widget,
+ (term->keyboard.flags & MODE_DECCKM) != 0);
+}
+
+void
+update_appkeypad(void)
+{
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_appkeypad].widget,
+ (term->keyboard.flags & MODE_DECKPAM) != 0);
+}
+
+void
+update_scrollkey(void)
+{
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_scrollkey].widget,
+ term->screen.scrollkey);
+}
+
+void
+update_scrollttyoutput(void)
+{
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_scrollttyoutput].widget,
+ term->screen.scrollttyoutput);
+}
+
+void
+update_allow132(void)
+{
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_allow132].widget,
+ term->screen.c132);
+}
+
+void
+update_cursesemul(void)
+{
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_cursesemul].widget,
+ term->screen.curses);
+}
+
+void
+update_visualbell(void)
+{
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_visualbell].widget,
+ term->screen.visualbell);
+}
+
+void
+update_poponbell(void)
+{
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_poponbell].widget,
+ term->screen.poponbell);
+}
+
+void
+update_marginbell(void)
+{
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_marginbell].widget,
+ term->screen.marginbell);
+}
+
+#if OPT_BLINK_CURS
+void
+update_cursorblink(void)
+{
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_cursorblink].widget,
+ term->screen.cursor_blink);
+}
+#endif
+
+void
+update_altscreen(void)
+{
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_altscreen].widget,
+ term->screen.alternate);
+}
+
+void
+update_titeInhibit(void)
+{
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_titeInhibit].widget,
+ !(term->misc.titeInhibit));
+}
+
+#ifndef NO_ACTIVE_ICON
+void
+update_activeicon(void)
+{
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_activeicon].widget,
+ term->misc.active_icon);
+}
+#endif /* NO_ACTIVE_ICON */
+
+#if OPT_DEC_CHRSET
+void
+update_font_doublesize(void)
+{
+ update_menu_item(term->screen.fontMenu,
+ fontMenuEntries[fontMenu_font_doublesize].widget,
+ term->screen.font_doublesize);
+}
+#endif
+
+#if OPT_BOX_CHARS
+void
+update_font_boxchars(void)
+{
+ update_menu_item(term->screen.fontMenu,
+ fontMenuEntries[fontMenu_font_boxchars].widget,
+ term->screen.force_box_chars);
+}
+#endif
+
+#if OPT_DEC_SOFTFONT
+void
+update_font_loadable(void)
+{
+ update_menu_item(term->screen.fontMenu,
+ fontMenuEntries[fontMenu_font_loadable].widget,
+ term->misc.font_loadable);
+}
+#endif
+
+#if OPT_RENDERFONT
+void
+update_font_renderfont(void)
+{
+ update_menu_item(term->screen.fontMenu,
+ fontMenuEntries[fontMenu_render_font].widget,
+ term->misc.render_font);
+}
+#endif
+
+#if OPT_WIDE_CHARS
+void
+update_font_utf8_mode(void)
+{
+ Widget iw = fontMenuEntries[fontMenu_wide_chars].widget;
+ Bool active = (term->screen.utf8_mode != uAlways);
+ Bool enable = (term->screen.utf8_mode != uFalse);
+
+ TRACE(("update_font_utf8_mode active %d, enable %d\n", active, enable));
+ set_sensitivity(term->screen.fontMenu, iw, active);
+ update_menu_item(term->screen.fontMenu, iw, enable);
+}
+#endif
+
+#if OPT_TEK4014
+void
+update_tekshow(void)
+{
+ if (!(term->screen.inhibit & I_TEK)) {
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_tekshow].widget,
+ term->screen.Tshow);
+ }
+}
+
+void
+update_vttekmode(void)
+{
+ if (!(term->screen.inhibit & I_TEK)) {
+ update_menu_item(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_tekmode].widget,
+ term->screen.TekEmu);
+ update_menu_item(term->screen.tekMenu,
+ tekMenuEntries[tekMenu_vtmode].widget,
+ !term->screen.TekEmu);
+ }
+}
+
+void
+update_vtshow(void)
+{
+ if (!(term->screen.inhibit & I_TEK)) {
+ update_menu_item(term->screen.tekMenu,
+ tekMenuEntries[tekMenu_vtshow].widget,
+ term->screen.Vshow);
+ }
+}
+
+void
+set_vthide_sensitivity(void)
+{
+ if (!(term->screen.inhibit & I_TEK)) {
+ set_sensitivity(term->screen.vtMenu,
+ vtMenuEntries[vtMenu_vthide].widget,
+ term->screen.Tshow);
+ }
+}
+
+void
+set_tekhide_sensitivity(void)
+{
+ if (!(term->screen.inhibit & I_TEK)) {
+ set_sensitivity(term->screen.tekMenu,
+ tekMenuEntries[tekMenu_tekhide].widget,
+ term->screen.Vshow);
+ }
+}
+
+void
+set_tekfont_menu_item(int n, int val)
+{
+ if (!(term->screen.inhibit & I_TEK)) {
+ update_menu_item(term->screen.tekMenu,
+ tekMenuEntries[FS2MI(n)].widget,
+ (val));
+ }
+}
+#endif /* OPT_TEK4014 */
+
+void
+set_menu_font(int val)
+{
+ update_menu_item(term->screen.fontMenu,
+ fontMenuEntries[term->screen.menu_font_number].widget,
+ (val));
+}