+ else
+ {
+ union REGS inregs, outregs;
+ inregs.h.ah = 2;
+ inregs.h.dl = 7;
+ intdos (&inregs, &outregs);
+ }
+}
+
+static void
+IT_set_face (int face)
+{
+ struct face *fp;
+ extern struct face *intern_face (/* FRAME_PTR, struct face * */);
+
+ if (face == 1 || (face == 0 && highlight))
+ fp = FRAME_MODE_LINE_FACE (foo);
+ else if (face <= 0 || face >= FRAME_N_COMPUTED_FACES (foo))
+ fp = FRAME_DEFAULT_FACE (foo);
+ else
+ fp = intern_face (selected_frame, FRAME_COMPUTED_FACES (foo)[face]);
+ if (termscript)
+ fprintf (termscript, "<FACE:%d:%d>", FACE_FOREGROUND (fp), FACE_BACKGROUND (fp));
+ screen_face = face;
+ ScreenAttrib = (FACE_BACKGROUND (fp) << 4) | FACE_FOREGROUND (fp);
+}
+
+static
+IT_write_glyphs (GLYPH *str, int len)
+{
+ int newface;
+ int ch, l = len;
+ unsigned char *buf, *bp;
+
+ if (len == 0) return;
+
+ buf = bp = alloca (len * 2);
+
+ while (--l >= 0)
+ {
+ newface = FAST_GLYPH_FACE (*str);
+ if (newface != screen_face)
+ IT_set_face (newface);
+ ch = FAST_GLYPH_CHAR (*str);
+ *bp++ = (unsigned char)ch;
+ *bp++ = ScreenAttrib;
+
+ if (termscript)
+ fputc (ch, termscript);
+ str++;
+ }
+
+ mouse_off_maybe ();
+ dosmemput (buf, 2 * len,
+ (int)ScreenPrimary + 2 * (new_pos_X + screen_size_X * new_pos_Y));
+ new_pos_X += len;
+}
+
+static
+IT_clear_end_of_line (first_unused)
+{
+ char *spaces, *sp;
+ int i, j;
+
+ IT_set_face (0);
+ if (termscript)
+ fprintf (termscript, "<CLR:EOL>");
+ i = (j = screen_size_X - new_pos_X) * 2;
+ spaces = sp = alloca (i);
+
+ while (--j >= 0)
+ {
+ *sp++ = ' ';
+ *sp++ = ScreenAttrib;
+ }
+
+ mouse_off_maybe ();
+ dosmemput (spaces, i,
+ (int)ScreenPrimary + 2 * (new_pos_X + screen_size_X * new_pos_Y));
+}
+
+static
+IT_clear_screen (void)
+{
+ if (termscript)
+ fprintf (termscript, "<CLR:SCR>");
+ IT_set_face (0);
+ mouse_off ();
+ ScreenClear ();
+ new_pos_X = new_pos_Y = 0;
+}
+
+static
+IT_clear_to_end (void)
+{
+ if (termscript)
+ fprintf (termscript, "<CLR:EOS>");
+
+ while (new_pos_Y < screen_size_Y) {
+ new_pos_X = 0;
+ IT_clear_end_of_line (0);
+ new_pos_Y++;
+ }
+}
+
+static
+IT_cursor_to (int y, int x)
+{
+ if (termscript)
+ fprintf (termscript, "\n<XY=%dx%d>", x, y);
+ new_pos_X = x;
+ new_pos_Y = y;
+}
+
+static int cursor_cleared;
+
+static
+IT_display_cursor (int on)
+{
+ if (on && cursor_cleared)
+ {
+ ScreenSetCursor (current_pos_Y, current_pos_X);
+ cursor_cleared = 0;
+ }
+ else if (!on && !cursor_cleared)
+ {
+ ScreenSetCursor (-1, -1);
+ cursor_cleared = 1;
+ }
+}
+
+/* Emacs calls cursor-movement functions a lot when it updates the
+ display (probably a legacy of old terminals where you cannot
+ update a screen line without first moving the cursor there).
+ However, cursor movement is expensive on MSDOS (it calls a slow
+ BIOS function and requires 2 mode switches), while actual screen
+ updates access the video memory directly and don't depend on
+ cursor position. To avoid slowing down the redisplay, we cheat:
+ all functions that move the cursor only set internal variables
+ which record the cursor position, whereas the cursor is only
+ moved to its final position whenever screen update is complete.
+
+ `IT_cmgoto' is called from the keyboard reading loop and when the
+ frame update is complete. This means that we are ready for user
+ input, so we update the cursor position to show where the point is,
+ and also make the mouse pointer visible.
+
+ Special treatment is required when the cursor is in the echo area,
+ to put the cursor at the end of the text displayed there. */
+
+static
+IT_cmgoto (f)
+ FRAME_PTR f;
+{
+ /* Only set the cursor to where it should be if the display is
+ already in sync with the window contents. */
+ int update_cursor_pos = MODIFF == unchanged_modified;
+
+ /* If we are in the echo area, put the cursor at the end of text. */
+ if (!update_cursor_pos
+ && XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f))->top) <= new_pos_Y)
+ {
+ new_pos_X = FRAME_DESIRED_GLYPHS (f)->used[new_pos_Y];
+ update_cursor_pos = 1;
+ }
+
+ if (update_cursor_pos
+ && (current_pos_X != new_pos_X || current_pos_Y != new_pos_Y))
+ {
+ ScreenSetCursor (current_pos_Y = new_pos_Y, current_pos_X = new_pos_X);
+ if (termscript)
+ fprintf (termscript, "\n<CURSOR:%dx%d>", current_pos_X, current_pos_Y);
+ }
+
+ /* Maybe cursor is invisible, so make it visible. */
+ IT_display_cursor (1);
+
+ /* Mouse pointer should be always visible if we are waiting for
+ keyboard input. */
+ if (!mouse_visible)
+ mouse_on ();
+}
+
+static
+IT_reassert_line_highlight (new, vpos)
+ int new, vpos;
+{
+ highlight = new;
+ IT_set_face (0); /* To possibly clear the highlighting. */
+}
+
+static
+IT_change_line_highlight (new_highlight, vpos, first_unused_hpos)
+{
+ highlight = new_highlight;
+ IT_set_face (0); /* To possibly clear the highlighting. */
+ IT_cursor_to (vpos, 0);
+ IT_clear_end_of_line (first_unused_hpos);
+}
+
+static
+IT_update_begin ()
+{
+ highlight = 0;
+ IT_set_face (0); /* To possibly clear the highlighting. */
+ screen_face = -1;
+}
+
+static
+IT_update_end ()
+{
+}
+
+/* This was more or less copied from xterm.c
+
+ Nowadays, the corresponding function under X is `x_set_menu_bar_lines_1'
+ on xfns.c */
+
+static void
+IT_set_menu_bar_lines (window, n)
+ Lisp_Object window;
+ int n;
+{
+ struct window *w = XWINDOW (window);
+
+ XSETFASTINT (w->last_modified, 0);
+ XSETFASTINT (w->last_overlay_modified, 0);
+ XSETFASTINT (w->top, XFASTINT (w->top) + n);
+ XSETFASTINT (w->height, XFASTINT (w->height) - n);
+
+ /* Handle just the top child in a vertical split. */
+ if (!NILP (w->vchild))
+ IT_set_menu_bar_lines (w->vchild, n);
+
+ /* Adjust all children in a horizontal split. */
+ for (window = w->hchild; !NILP (window); window = w->next)
+ {
+ w = XWINDOW (window);
+ IT_set_menu_bar_lines (window, n);
+ }
+}
+
+/* This was copied from xfns.c */
+
+void
+x_set_menu_bar_lines (f, value, oldval)
+ struct frame *f;
+ Lisp_Object value, oldval;
+{
+ int nlines;
+ int olines = FRAME_MENU_BAR_LINES (f);
+
+ /* Right now, menu bars don't work properly in minibuf-only frames;
+ most of the commands try to apply themselves to the minibuffer
+ frame itslef, and get an error because you can't switch buffers
+ in or split the minibuffer window. */
+ if (FRAME_MINIBUF_ONLY_P (f))
+ return;
+
+ if (INTEGERP (value))
+ nlines = XINT (value);
+ else
+ nlines = 0;
+
+ FRAME_MENU_BAR_LINES (f) = nlines;
+ IT_set_menu_bar_lines (f->root_window, nlines - olines);
+}
+
+/* IT_set_terminal_modes is called when emacs is started,
+ resumed, and whenever the screen is redrawn! */
+
+static
+IT_set_terminal_modes (void)
+{
+ if (termscript)
+ fprintf (termscript, "\n<SET_TERM>");
+ highlight = 0;
+
+ screen_size_X = ScreenCols ();
+ screen_size_Y = ScreenRows ();
+ screen_size = screen_size_X * screen_size_Y;
+
+ new_pos_X = new_pos_Y = 0;
+ current_pos_X = current_pos_Y = -1;
+
+ if (term_setup_done)
+ return;
+ term_setup_done = 1;
+
+ startup_screen_size_X = screen_size_X;
+ startup_screen_size_Y = screen_size_Y;
+ startup_screen_attrib = ScreenAttrib;
+
+ ScreenGetCursor (&startup_pos_Y, &startup_pos_X);
+ ScreenRetrieve (startup_screen_buffer = xmalloc (screen_size * 2));
+
+ if (termscript)
+ fprintf (termscript, "<SCREEN SAVED (dimensions=%dx%d)>\n",
+ screen_size_X, screen_size_Y);
+
+ bright_bg ();
+}
+
+/* IT_reset_terminal_modes is called when emacs is
+ suspended or killed. */
+
+static
+IT_reset_terminal_modes (void)
+{
+ int display_row_start = (int) ScreenPrimary;
+ int saved_row_len = startup_screen_size_X * 2;
+ int update_row_len = ScreenCols () * 2;
+ int current_rows = ScreenRows ();
+ int to_next_row = update_row_len;
+ unsigned char *saved_row = startup_screen_buffer;
+ int cursor_pos_X = ScreenCols () - 1;
+ int cursor_pos_Y = ScreenRows () - 1;
+
+ if (termscript)
+ fprintf (termscript, "\n<RESET_TERM>");
+
+ highlight = 0;
+
+ if (!term_setup_done)
+ return;
+
+ mouse_off ();
+
+ /* Leave the video system in the same state as we found it,
+ as far as the blink/bright-background bit is concerned. */
+ maybe_enable_blinking ();
+
+ /* We have a situation here.
+ We cannot just do ScreenUpdate(startup_screen_buffer) because
+ the luser could have changed screen dimensions inside Emacs
+ and failed (or didn't want) to restore them before killing
+ Emacs. ScreenUpdate() uses the *current* screen dimensions and
+ thus will happily use memory outside what was allocated for
+ `startup_screen_buffer'.
+ Thus we only restore as much as the current screen dimensions
+ can hold, and clear the rest (if the saved screen is smaller than
+ the current) with the color attribute saved at startup. The cursor
+ is also restored within the visible dimensions. */
+
+ ScreenAttrib = startup_screen_attrib;
+ ScreenClear ();
+
+ if (update_row_len > saved_row_len)
+ update_row_len = saved_row_len;
+ if (current_rows > startup_screen_size_Y)
+ current_rows = startup_screen_size_Y;
+
+ if (termscript)
+ fprintf (termscript, "<SCREEN RESTORED (dimensions=%dx%d)>\n",
+ update_row_len / 2, current_rows);
+
+ while (current_rows--)
+ {
+ dosmemput (saved_row, update_row_len, display_row_start);
+ saved_row += saved_row_len;
+ display_row_start += to_next_row;
+ }
+ if (startup_pos_X < cursor_pos_X)
+ cursor_pos_X = startup_pos_X;
+ if (startup_pos_Y < cursor_pos_Y)
+ cursor_pos_Y = startup_pos_Y;
+
+ ScreenSetCursor (cursor_pos_Y, cursor_pos_X);
+ xfree (startup_screen_buffer);
+
+ term_setup_done = 0;
+}
+
+static
+IT_set_terminal_window (void)
+{
+}
+
+void
+IT_set_frame_parameters (f, alist)
+ FRAME_PTR f;
+ Lisp_Object alist;
+{
+ Lisp_Object tail;
+ int redraw;
+ extern unsigned long load_color ();
+
+ redraw = 0;
+ for (tail = alist; CONSP (tail); tail = Fcdr (tail))
+ {
+ Lisp_Object elt, prop, val;
+
+ elt = Fcar (tail);
+ prop = Fcar (elt);
+ val = Fcdr (elt);
+ CHECK_SYMBOL (prop, 1);
+
+ if (EQ (prop, intern ("foreground-color")))
+ {
+ unsigned long new_color = load_color (f, val);
+ if (new_color != ~0)
+ {
+ FRAME_FOREGROUND_PIXEL (f) = new_color;
+ redraw = 1;
+ if (termscript)
+ fprintf (termscript, "<FGCOLOR %lu>\n", new_color);
+ }
+ }
+ else if (EQ (prop, intern ("background-color")))
+ {
+ unsigned long new_color = load_color (f, val);
+ if (new_color != ~0)
+ {
+ FRAME_BACKGROUND_PIXEL (f) = new_color;
+ redraw = 1;
+ if (termscript)
+ fprintf (termscript, "<BGCOLOR %lu>\n", new_color);
+ }
+ }
+ else if (EQ (prop, intern ("menu-bar-lines")))
+ x_set_menu_bar_lines (f, val, 0);
+ }
+
+ if (redraw)
+ {
+ extern void recompute_basic_faces (FRAME_PTR);
+ extern void redraw_frame (FRAME_PTR);
+
+ recompute_basic_faces (f);
+ if (f == selected_frame)
+ redraw_frame (f);
+ }
+}
+
+extern void init_frame_faces (FRAME_PTR);
+
+#endif /* !HAVE_X_WINDOWS */
+
+
+/* Do we need the internal terminal? */
+
+void
+internal_terminal_init ()
+{
+ char *term = getenv ("TERM");
+ char *colors;
+
+#ifdef HAVE_X_WINDOWS
+ if (!inhibit_window_system)
+ return;
+#endif
+
+ internal_terminal
+ = (!noninteractive) && term && !strcmp (term, "internal");
+
+ if (getenv ("EMACSTEST"))
+ termscript = fopen (getenv ("EMACSTEST"), "wt");
+
+#ifndef HAVE_X_WINDOWS
+ if (!internal_terminal || inhibit_window_system)
+ {
+ selected_frame->output_method = output_termcap;
+ return;
+ }
+
+ Vwindow_system = intern ("pc");
+ Vwindow_system_version = make_number (1);
+
+ bzero (&the_only_x_display, sizeof the_only_x_display);
+ the_only_x_display.background_pixel = 7; /* White */
+ the_only_x_display.foreground_pixel = 0; /* Black */
+ bright_bg ();
+ colors = getenv ("EMACSCOLORS");
+ if (colors && strlen (colors) >= 2)
+ {
+ /* The colors use 4 bits each (we enable bright background). */
+ if (isdigit (colors[0]))
+ colors[0] -= '0';
+ else if (isxdigit (colors[0]))
+ colors[0] -= (isupper (colors[0]) ? 'A' : 'a') - 10;
+ if (colors[0] >= 0 && colors[0] < 16)
+ the_only_x_display.foreground_pixel = colors[0];
+ if (isdigit (colors[1]))
+ colors[1] -= '0';
+ else if (isxdigit (colors[1]))
+ colors[1] -= (isupper (colors[1]) ? 'A' : 'a') - 10;
+ if (colors[1] >= 0 && colors[1] < 16)
+ the_only_x_display.background_pixel = colors[1];
+ }
+ the_only_x_display.line_height = 1;
+ the_only_x_display.font = (XFontStruct *)1; /* must *not* be zero */
+
+ init_frame_faces (selected_frame);
+
+ ring_bell_hook = IT_ring_bell;
+ write_glyphs_hook = IT_write_glyphs;
+ cursor_to_hook = raw_cursor_to_hook = IT_cursor_to;
+ clear_to_end_hook = IT_clear_to_end;
+ clear_end_of_line_hook = IT_clear_end_of_line;
+ clear_frame_hook = IT_clear_screen;
+ change_line_highlight_hook = IT_change_line_highlight;
+ update_begin_hook = IT_update_begin;
+ update_end_hook = IT_update_end;
+ reassert_line_highlight_hook = IT_reassert_line_highlight;
+ frame_up_to_date_hook = IT_cmgoto; /* position cursor when update is done */
+
+ /* These hooks are called by term.c without being checked. */
+ set_terminal_modes_hook = IT_set_terminal_modes;
+ reset_terminal_modes_hook = IT_reset_terminal_modes;
+ set_terminal_window_hook = IT_set_terminal_window;
+#endif
+}
+
+dos_get_saved_screen (screen, rows, cols)
+ char **screen;
+ int *rows;
+ int *cols;
+{
+#ifndef HAVE_X_WINDOWS
+ *screen = startup_screen_buffer;
+ *cols = startup_screen_size_X;
+ *rows = startup_screen_size_Y;
+ return 1;
+#else
+ return 0;
+#endif
+}
+
+#ifndef HAVE_X_WINDOWS
+
+/* We are not X, but we can emulate it well enough for our needs... */
+void
+check_x (void)
+{
+ if (! FRAME_MSDOS_P (selected_frame))
+ error ("Not running under a windows system");
+}
+
+#endif
+
+\f
+/* ----------------------- Keyboard control ----------------------
+ *
+ * Keymaps reflect the following keyboard layout:
+ *
+ * 0 1 2 3 4 5 6 7 8 9 10 11 12 BS
+ * TAB 15 16 17 18 19 20 21 22 23 24 25 26 (41)
+ * CLOK 30 31 32 33 34 35 36 37 38 39 40 (41) RET
+ * SH () 45 46 47 48 49 50 51 52 53 54 SHIFT
+ * SPACE
+ */
+
+static int extended_kbd; /* 101 (102) keyboard present. */
+
+struct dos_keyboard_map
+{
+ char *unshifted;
+ char *shifted;
+ char *alt_gr;
+};
+
+
+static struct dos_keyboard_map us_keyboard = {
+/* 0 1 2 3 4 5 */
+/* 01234567890123456789012345678901234567890 12345678901234 */
+ "`1234567890-= qwertyuiop[] asdfghjkl;'\\ zxcvbnm,./ ",
+/* 0123456789012345678901234567890123456789 012345678901234 */
+ "~!@#$%^&*()_+ QWERTYUIOP{} ASDFGHJKL:\"| ZXCVBNM<>? ",
+ 0 /* no Alt-Gr key */
+};
+
+static struct dos_keyboard_map fr_keyboard = {
+/* 0 1 2 3 4 5 */
+/* 012 3456789012345678901234567890123456789012345678901234 */
+ "ý&\82\",(-\8a_\80\85)= azertyuiop^$ qsdfghjklm\97* wxcvbnm;:! ",
+/* 0123456789012345678901234567890123456789012345678901234 */
+ " 1234567890ø+ AZERTYUIOPù\9c QSDFGHJKLM%æ WXCVBN?./õ ",
+/* 01234567 89012345678901234567890123456789012345678901234 */
+ " ~#{[|`\\^@]} Ï "
+};
+
+static struct dos_keyboard_map dk_keyboard = {
+/* 0 1 2 3 4 5 */
+/* 0123456789012345678901234567890123456789012345678901234 */
+ "«1234567890+| qwertyuiop\86~ asdfghjkl\91\9b' zxcvbnm,.- ",
+/* 01 23456789012345678901234567890123456789012345678901234 */
+ "õ!\"#$%&/()=?` QWERTYUIOP\8f^ ASDFGHJKL\92\9d* ZXCVBNM;:_ ",
+/* 0123456789012345678901234567890123456789012345678901234 */
+ " @\9c$ {[]} | "
+};
+
+static struct keyboard_layout_list
+{
+ int country_code;
+ struct dos_keyboard_map *keyboard_map;
+} keyboard_layout_list[] =
+{
+ 1, &us_keyboard,
+ 33, &fr_keyboard,
+ 45, &dk_keyboard
+};
+
+static struct dos_keyboard_map *keyboard;
+static int keyboard_map_all;
+static int international_keyboard;
+
+int
+dos_set_keyboard (code, always)
+ int code;
+ int always;
+{
+ int i;
+ union REGS regs;
+
+ /* See if Keyb.Com is installed (for international keyboard support). */
+ regs.x.ax = 0xad80;
+ int86 (0x2f, ®s, ®s);
+ if (regs.h.al == 0xff)
+ international_keyboard = 1;
+
+ /* Initialize to US settings, for countries that don't have their own. */
+ keyboard = keyboard_layout_list[0].keyboard_map;
+ keyboard_map_all = always;
+ dos_keyboard_layout = 1;
+
+ for (i = 0; i < (sizeof (keyboard_layout_list)/sizeof (struct keyboard_layout_list)); i++)
+ if (code == keyboard_layout_list[i].country_code)
+ {
+ keyboard = keyboard_layout_list[i].keyboard_map;
+ keyboard_map_all = always;
+ dos_keyboard_layout = code;
+ return 1;
+ }
+ return 0;
+}
+\f
+#define Ignore 0x0000
+#define Normal 0x0000 /* normal key - alt changes scan-code */
+#define FctKey 0x1000 /* func key if c == 0, else c */
+#define Special 0x2000 /* func key even if c != 0 */
+#define ModFct 0x3000 /* special if mod-keys, else 'c' */
+#define Map 0x4000 /* alt scan-code, map to unshift/shift key */
+#define KeyPad 0x5000 /* map to insert/kp-0 depending on c == 0xe0 */
+#define Grey 0x6000 /* Grey keypad key */
+
+#define Alt 0x0100 /* alt scan-code */
+#define Ctrl 0x0200 /* ctrl scan-code */
+#define Shift 0x0400 /* shift scan-code */
+
+static struct
+{
+ unsigned char char_code; /* normal code */
+ unsigned char meta_code; /* M- code */
+ unsigned char keypad_code; /* keypad code */
+ unsigned char editkey_code; /* edit key */
+} keypad_translate_map[] = {
+ '0', '0', 0xb0, /* kp-0 */ 0x63, /* insert */
+ '1', '1', 0xb1, /* kp-1 */ 0x57, /* end */
+ '2', '2', 0xb2, /* kp-2 */ 0x54, /* down */
+ '3', '3', 0xb3, /* kp-3 */ 0x56, /* next */
+ '4', '4', 0xb4, /* kp-4 */ 0x51, /* left */
+ '5', '5', 0xb5, /* kp-5 */ 0xb5, /* kp-5 */
+ '6', '6', 0xb6, /* kp-6 */ 0x53, /* right */
+ '7', '7', 0xb7, /* kp-7 */ 0x50, /* home */
+ '8', '8', 0xb8, /* kp-8 */ 0x52, /* up */
+ '9', '9', 0xb9, /* kp-9 */ 0x55, /* prior */
+ '.', '-', 0xae, /* kp-decimal */ 0xff /* delete */
+};
+
+static struct
+{
+ unsigned char char_code; /* normal code */
+ unsigned char keypad_code; /* keypad code */
+} grey_key_translate_map[] = {
+ '/', 0xaf, /* kp-decimal */
+ '*', 0xaa, /* kp-multiply */
+ '-', 0xad, /* kp-subtract */
+ '+', 0xab, /* kp-add */
+ '\r', 0x8d /* kp-enter */
+};
+
+static unsigned short
+ibmpc_translate_map[] =
+{
+ /* --------------- 00 to 0f --------------- */
+ Normal | 0xff, /* Ctrl Break + Alt-NNN */
+ Alt | ModFct | 0x1b, /* Escape */
+ Normal | 1, /* '1' */
+ Normal | 2, /* '2' */
+ Normal | 3, /* '3' */
+ Normal | 4, /* '4' */
+ Normal | 5, /* '5' */
+ Normal | 6, /* '6' */
+ Normal | 7, /* '7' */
+ Normal | 8, /* '8' */
+ Normal | 9, /* '9' */
+ Normal | 10, /* '0' */
+ Normal | 11, /* '-' */
+ Normal | 12, /* '=' */
+ Special | 0x08, /* Backspace */
+ ModFct | 0x74, /* Tab/Backtab */
+
+ /* --------------- 10 to 1f --------------- */
+ Map | 15, /* 'q' */
+ Map | 16, /* 'w' */
+ Map | 17, /* 'e' */
+ Map | 18, /* 'r' */
+ Map | 19, /* 't' */
+ Map | 20, /* 'y' */
+ Map | 21, /* 'u' */
+ Map | 22, /* 'i' */
+ Map | 23, /* 'o' */
+ Map | 24, /* 'p' */
+ Map | 25, /* '[' */
+ Map | 26, /* ']' */
+ ModFct | 0x0d, /* Return */
+ Ignore, /* Ctrl */
+ Map | 30, /* 'a' */
+ Map | 31, /* 's' */
+
+ /* --------------- 20 to 2f --------------- */
+ Map | 32, /* 'd' */
+ Map | 33, /* 'f' */
+ Map | 34, /* 'g' */
+ Map | 35, /* 'h' */
+ Map | 36, /* 'j' */
+ Map | 37, /* 'k' */
+ Map | 38, /* 'l' */
+ Map | 39, /* ';' */
+ Map | 40, /* '\'' */
+ Map | 0, /* '`' */
+ Ignore, /* Left shift */
+ Map | 41, /* '\\' */
+ Map | 45, /* 'z' */
+ Map | 46, /* 'x' */
+ Map | 47, /* 'c' */
+ Map | 48, /* 'v' */
+
+ /* --------------- 30 to 3f --------------- */
+ Map | 49, /* 'b' */
+ Map | 50, /* 'n' */
+ Map | 51, /* 'm' */
+ Map | 52, /* ',' */
+ Map | 53, /* '.' */
+ Map | 54, /* '/' */
+ Ignore, /* Right shift */
+ Grey | 1, /* Grey * */
+ Ignore, /* Alt */
+ Normal | ' ', /* ' ' */
+ Ignore, /* Caps Lock */
+ FctKey | 0xbe, /* F1 */
+ FctKey | 0xbf, /* F2 */
+ FctKey | 0xc0, /* F3 */
+ FctKey | 0xc1, /* F4 */
+ FctKey | 0xc2, /* F5 */
+
+ /* --------------- 40 to 4f --------------- */
+ FctKey | 0xc3, /* F6 */
+ FctKey | 0xc4, /* F7 */
+ FctKey | 0xc5, /* F8 */
+ FctKey | 0xc6, /* F9 */
+ FctKey | 0xc7, /* F10 */
+ Ignore, /* Num Lock */
+ Ignore, /* Scroll Lock */
+ KeyPad | 7, /* Home */
+ KeyPad | 8, /* Up */
+ KeyPad | 9, /* Page Up */
+ Grey | 2, /* Grey - */
+ KeyPad | 4, /* Left */
+ KeyPad | 5, /* Keypad 5 */
+ KeyPad | 6, /* Right */
+ Grey | 3, /* Grey + */
+ KeyPad | 1, /* End */
+
+ /* --------------- 50 to 5f --------------- */
+ KeyPad | 2, /* Down */
+ KeyPad | 3, /* Page Down */
+ KeyPad | 0, /* Insert */
+ KeyPad | 10, /* Delete */
+ Shift | FctKey | 0xbe, /* (Shift) F1 */
+ Shift | FctKey | 0xbf, /* (Shift) F2 */
+ Shift | FctKey | 0xc0, /* (Shift) F3 */
+ Shift | FctKey | 0xc1, /* (Shift) F4 */
+ Shift | FctKey | 0xc2, /* (Shift) F5 */
+ Shift | FctKey | 0xc3, /* (Shift) F6 */
+ Shift | FctKey | 0xc4, /* (Shift) F7 */
+ Shift | FctKey | 0xc5, /* (Shift) F8 */
+ Shift | FctKey | 0xc6, /* (Shift) F9 */
+ Shift | FctKey | 0xc7, /* (Shift) F10 */
+ Ctrl | FctKey | 0xbe, /* (Ctrl) F1 */
+ Ctrl | FctKey | 0xbf, /* (Ctrl) F2 */
+
+ /* --------------- 60 to 6f --------------- */
+ Ctrl | FctKey | 0xc0, /* (Ctrl) F3 */
+ Ctrl | FctKey | 0xc1, /* (Ctrl) F4 */
+ Ctrl | FctKey | 0xc2, /* (Ctrl) F5 */
+ Ctrl | FctKey | 0xc3, /* (Ctrl) F6 */
+ Ctrl | FctKey | 0xc4, /* (Ctrl) F7 */
+ Ctrl | FctKey | 0xc5, /* (Ctrl) F8 */
+ Ctrl | FctKey | 0xc6, /* (Ctrl) F9 */
+ Ctrl | FctKey | 0xc7, /* (Ctrl) F10 */
+ Alt | FctKey | 0xbe, /* (Alt) F1 */
+ Alt | FctKey | 0xbf, /* (Alt) F2 */
+ Alt | FctKey | 0xc0, /* (Alt) F3 */
+ Alt | FctKey | 0xc1, /* (Alt) F4 */
+ Alt | FctKey | 0xc2, /* (Alt) F5 */
+ Alt | FctKey | 0xc3, /* (Alt) F6 */
+ Alt | FctKey | 0xc4, /* (Alt) F7 */
+ Alt | FctKey | 0xc5, /* (Alt) F8 */
+
+ /* --------------- 70 to 7f --------------- */
+ Alt | FctKey | 0xc6, /* (Alt) F9 */
+ Alt | FctKey | 0xc7, /* (Alt) F10 */
+ Ctrl | FctKey | 0x6d, /* (Ctrl) Sys Rq */
+ Ctrl | KeyPad | 4, /* (Ctrl) Left */
+ Ctrl | KeyPad | 6, /* (Ctrl) Right */
+ Ctrl | KeyPad | 1, /* (Ctrl) End */
+ Ctrl | KeyPad | 3, /* (Ctrl) Page Down */
+ Ctrl | KeyPad | 7, /* (Ctrl) Home */
+ Alt | Map | 1, /* '1' */
+ Alt | Map | 2, /* '2' */
+ Alt | Map | 3, /* '3' */
+ Alt | Map | 4, /* '4' */
+ Alt | Map | 5, /* '5' */
+ Alt | Map | 6, /* '6' */
+ Alt | Map | 7, /* '7' */
+ Alt | Map | 8, /* '8' */
+
+ /* --------------- 80 to 8f --------------- */
+ Alt | Map | 9, /* '9' */
+ Alt | Map | 10, /* '0' */
+ Alt | Map | 11, /* '-' */
+ Alt | Map | 12, /* '=' */
+ Ctrl | KeyPad | 9, /* (Ctrl) Page Up */
+ FctKey | 0xc8, /* F11 */
+ FctKey | 0xc9, /* F12 */
+ Shift | FctKey | 0xc8, /* (Shift) F11 */
+ Shift | FctKey | 0xc9, /* (Shift) F12 */
+ Ctrl | FctKey | 0xc8, /* (Ctrl) F11 */
+ Ctrl | FctKey | 0xc9, /* (Ctrl) F12 */
+ Alt | FctKey | 0xc8, /* (Alt) F11 */
+ Alt | FctKey | 0xc9, /* (Alt) F12 */
+ Ctrl | KeyPad | 8, /* (Ctrl) Up */
+ Ctrl | Grey | 2, /* (Ctrl) Grey - */
+ Ctrl | KeyPad | 5, /* (Ctrl) Keypad 5 */
+
+ /* --------------- 90 to 9f --------------- */
+ Ctrl | Grey | 3, /* (Ctrl) Grey + */
+ Ctrl | KeyPad | 2, /* (Ctrl) Down */
+ Ctrl | KeyPad | 0, /* (Ctrl) Insert */
+ Ctrl | KeyPad | 10, /* (Ctrl) Delete */
+ Ctrl | FctKey | 0x09, /* (Ctrl) Tab */
+ Ctrl | Grey | 0, /* (Ctrl) Grey / */
+ Ctrl | Grey | 1, /* (Ctrl) Grey * */
+ Alt | FctKey | 0x50, /* (Alt) Home */
+ Alt | FctKey | 0x52, /* (Alt) Up */
+ Alt | FctKey | 0x55, /* (Alt) Page Up */
+ Ignore, /* NO KEY */
+ Alt | FctKey | 0x51, /* (Alt) Left */
+ Ignore, /* NO KEY */
+ Alt | FctKey | 0x53, /* (Alt) Right */
+ Ignore, /* NO KEY */
+ Alt | FctKey | 0x57, /* (Alt) End */
+
+ /* --------------- a0 to af --------------- */
+ Alt | KeyPad | 2, /* (Alt) Down */
+ Alt | KeyPad | 3, /* (Alt) Page Down */
+ Alt | KeyPad | 0, /* (Alt) Insert */
+ Alt | KeyPad | 10, /* (Alt) Delete */
+ Alt | Grey | 0, /* (Alt) Grey / */
+ Alt | FctKey | 0x09, /* (Alt) Tab */
+ Alt | Grey | 4 /* (Alt) Keypad Enter */
+};
+\f
+/* These bit-positions corresponds to values returned by BIOS */
+#define SHIFT_P 0x0003 /* two bits! */
+#define CTRL_P 0x0004
+#define ALT_P 0x0008
+#define SCRLOCK_P 0x0010
+#define NUMLOCK_P 0x0020
+#define CAPSLOCK_P 0x0040
+#define ALT_GR_P 0x0800
+#define SUPER_P 0x4000 /* pseudo */
+#define HYPER_P 0x8000 /* pseudo */
+
+static int
+dos_get_modifiers (keymask)
+ int *keymask;
+{
+ union REGS regs;
+ int mask;
+ int modifiers = 0;
+
+ /* Calculate modifier bits */
+ regs.h.ah = extended_kbd ? 0x12 : 0x02;
+ int86 (0x16, ®s, ®s);
+
+ if (!extended_kbd)
+ {
+ mask = regs.h.al & (SHIFT_P | CTRL_P | ALT_P |
+ SCRLOCK_P | NUMLOCK_P | CAPSLOCK_P);
+ }
+ else
+ {
+ mask = regs.h.al & (SHIFT_P |
+ SCRLOCK_P | NUMLOCK_P | CAPSLOCK_P);
+
+ /* Do not break international keyboard support. */
+ /* When Keyb.Com is loaded, the right Alt key is */
+ /* used for accessing characters like { and } */
+ if (regs.h.ah & 2) /* Left ALT pressed ? */
+ mask |= ALT_P;
+
+ if ((regs.h.ah & 8) != 0) /* Right ALT pressed ? */
+ {
+ mask |= ALT_GR_P;
+ if (dos_hyper_key == 1)
+ {
+ mask |= HYPER_P;
+ modifiers |= hyper_modifier;
+ }
+ else if (dos_super_key == 1)
+ {
+ mask |= SUPER_P;
+ modifiers |= super_modifier;
+ }
+ else if (!international_keyboard)
+ {
+ /* If Keyb.Com is NOT installed, let Right Alt behave
+ like the Left Alt. */
+ mask &= ~ALT_GR_P;
+ mask |= ALT_P;
+ }
+ }
+
+ if (regs.h.ah & 1) /* Left CTRL pressed ? */
+ mask |= CTRL_P;
+
+ if (regs.h.ah & 4) /* Right CTRL pressed ? */
+ {
+ if (dos_hyper_key == 2)
+ {
+ mask |= HYPER_P;
+ modifiers |= hyper_modifier;
+ }
+ else if (dos_super_key == 2)
+ {
+ mask |= SUPER_P;
+ modifiers |= super_modifier;
+ }
+ else
+ mask |= CTRL_P;
+ }
+ }
+
+ if (mask & SHIFT_P)
+ modifiers |= shift_modifier;
+ if (mask & CTRL_P)
+ modifiers |= ctrl_modifier;
+ if (mask & ALT_P)
+ modifiers |= meta_modifier;
+
+ if (keymask)
+ *keymask = mask;
+ return modifiers;
+}
+
+#define NUM_RECENT_DOSKEYS (100)
+int recent_doskeys_index; /* Index for storing next element into recent_doskeys */
+int total_doskeys; /* Total number of elements stored into recent_doskeys */
+Lisp_Object recent_doskeys; /* A vector, holding the last 100 keystrokes */
+
+DEFUN ("recent-doskeys", Frecent_doskeys, Srecent_doskeys, 0, 0, 0,
+ "Return vector of last 100 keyboard input values seen in dos_rawgetc.\n\
+Each input key receives two values in this vector: first the ASCII code,\n\
+and then the scan code.")
+ ()
+{
+ Lisp_Object *keys = XVECTOR (recent_doskeys)->contents;
+ Lisp_Object val;
+
+ if (total_doskeys < NUM_RECENT_DOSKEYS)
+ return Fvector (total_doskeys, keys);
+ else
+ {
+ val = Fvector (NUM_RECENT_DOSKEYS, keys);
+ bcopy (keys + recent_doskeys_index,
+ XVECTOR (val)->contents,
+ (NUM_RECENT_DOSKEYS - recent_doskeys_index) * sizeof (Lisp_Object));
+ bcopy (keys,
+ XVECTOR (val)->contents + NUM_RECENT_DOSKEYS - recent_doskeys_index,
+ recent_doskeys_index * sizeof (Lisp_Object));
+ return val;
+ }
+}
+
+/* Get a char from keyboard. Function keys are put into the event queue. */
+
+extern void kbd_buffer_store_event (struct input_event *);
+
+static int
+dos_rawgetc ()
+{
+ struct input_event event;
+ union REGS regs;
+
+#ifndef HAVE_X_WINDOWS
+ /* Maybe put the cursor where it should be. */
+ IT_cmgoto (selected_frame);
+#endif
+
+ /* The following condition is equivalent to `kbhit ()', except that
+ it uses the bios to do its job. This pleases DESQview/X. */
+ while ((regs.h.ah = extended_kbd ? 0x11 : 0x01),
+ int86 (0x16, ®s, ®s),
+ (regs.x.flags & 0x40) == 0)
+ {
+ union REGS regs;
+ register unsigned char c;
+ int sc, code, mask, kp_mode;
+ int modifiers;
+
+ regs.h.ah = extended_kbd ? 0x10 : 0x00;
+ int86 (0x16, ®s, ®s);
+ c = regs.h.al;
+ sc = regs.h.ah;
+
+ total_doskeys += 2;
+ XVECTOR (recent_doskeys)->contents[recent_doskeys_index++]
+ = make_number (c);
+ if (recent_doskeys_index == NUM_RECENT_DOSKEYS)
+ recent_doskeys_index = 0;
+ XVECTOR (recent_doskeys)->contents[recent_doskeys_index++]
+ = make_number (sc);
+ if (recent_doskeys_index == NUM_RECENT_DOSKEYS)
+ recent_doskeys_index = 0;
+
+ modifiers = dos_get_modifiers (&mask);
+
+#ifndef HAVE_X_WINDOWS
+ if (!NILP (Vdos_display_scancodes))
+ {
+ char buf[11];
+ sprintf (buf, "%02x:%02x*%04x",
+ (unsigned) (sc&0xff), (unsigned) c, mask);
+ dos_direct_output (screen_size_Y - 2, screen_size_X - 12, buf, 10);
+ }
+#endif
+
+ if (sc == 0xe0)
+ {
+ switch (c)
+ {
+ case 10: /* Ctrl Grey Enter */
+ code = Ctrl | Grey | 4;
+ break;
+ case 13: /* Grey Enter */
+ code = Grey | 4;
+ break;
+ case '/': /* Grey / */
+ code = Grey | 0;
+ break;
+ default:
+ continue;
+ };
+ c = 0;
+ }
+ else
+ {
+ if (sc >= (sizeof (ibmpc_translate_map) / sizeof (short)))
+ continue;
+ if ((code = ibmpc_translate_map[sc]) == Ignore)
+ continue;
+ }
+
+ if (c == 0)
+ {
+ /* We only look at the keyboard Ctrl/Shift/Alt keys when
+ Emacs is ready to read a key. Therefore, if they press
+ `Alt-x' when Emacs is busy, by the time we get to
+ `dos_get_modifiers', they might have already released the
+ Alt key, and Emacs gets just `x', which is BAD.
+ However, for keys with the `Map' property set, the ASCII
+ code returns zero iff Alt is pressed. So, when we DON'T
+ have to support international_keyboard, we don't have to
+ distinguish between the left and right Alt keys, and we
+ can set the META modifier for any keys with the `Map'
+ property if they return zero ASCII code (c = 0). */
+ if ( (code & Alt)
+ || ( (code & 0xf000) == Map && !international_keyboard))
+ modifiers |= meta_modifier;
+ if (code & Ctrl)
+ modifiers |= ctrl_modifier;
+ if (code & Shift)
+ modifiers |= shift_modifier;
+ }
+
+ switch (code & 0xf000)
+ {
+ case ModFct:
+ if (c && !(mask & (SHIFT_P | ALT_P | CTRL_P | HYPER_P | SUPER_P)))
+ return c;
+ c = 0; /* Special */
+
+ case FctKey:
+ if (c != 0)
+ return c;
+
+ case Special:
+ code |= 0xff00;
+ break;
+
+ case Normal:
+ if (sc == 0)
+ {
+ if (c == 0) /* ctrl-break */
+ continue;
+ return c; /* ALT-nnn */
+ }
+ if (!keyboard_map_all)
+ {
+ if (c != ' ')
+ return c;
+ code = c;
+ break;
+ }
+
+ case Map:
+ if (c && !(mask & ALT_P) && !((mask & SHIFT_P) && (mask & CTRL_P)))
+ if (!keyboard_map_all)
+ return c;
+
+ code &= 0xff;
+ if (mask & ALT_P && code <= 10 && code > 0 && dos_keypad_mode & 0x200)
+ mask |= SHIFT_P; /* ALT-1 => M-! etc. */
+
+ if (mask & SHIFT_P)
+ {
+ code = keyboard->shifted[code];
+ mask -= SHIFT_P;
+ modifiers &= ~shift_modifier;
+ }
+ else
+ if ((mask & ALT_GR_P) && keyboard->alt_gr && keyboard->alt_gr[code] != ' ')
+ code = keyboard->alt_gr[code];
+ else
+ code = keyboard->unshifted[code];
+ break;
+
+ case KeyPad:
+ code &= 0xff;
+ if (c == 0xe0) /* edit key */
+ kp_mode = 3;
+ else
+ if ((mask & (NUMLOCK_P|CTRL_P|SHIFT_P|ALT_P)) == NUMLOCK_P) /* numlock on */
+ kp_mode = dos_keypad_mode & 0x03;
+ else
+ kp_mode = (dos_keypad_mode >> 4) & 0x03;
+
+ switch (kp_mode)
+ {
+ case 0:
+ if (code == 10 && dos_decimal_point)
+ return dos_decimal_point;
+ return keypad_translate_map[code].char_code;
+
+ case 1:
+ code = 0xff00 | keypad_translate_map[code].keypad_code;
+ break;
+
+ case 2:
+ code = keypad_translate_map[code].meta_code;
+ modifiers = meta_modifier;
+ break;
+
+ case 3:
+ code = 0xff00 | keypad_translate_map[code].editkey_code;
+ break;
+ }
+ break;
+
+ case Grey:
+ code &= 0xff;
+ kp_mode = ((mask & (NUMLOCK_P|CTRL_P|SHIFT_P|ALT_P)) == NUMLOCK_P) ? 0x04 : 0x40;
+ if (dos_keypad_mode & kp_mode)
+ code = 0xff00 | grey_key_translate_map[code].keypad_code;
+ else
+ code = grey_key_translate_map[code].char_code;
+ break;
+ }
+
+ make_event:
+ if (code == 0)
+ continue;
+
+ if (code >= 0x100)
+ event.kind = non_ascii_keystroke;
+ else
+ event.kind = ascii_keystroke;
+ event.code = code;
+ event.modifiers = modifiers;
+ XSETFRAME (event.frame_or_window, selected_frame);
+ event.timestamp = event_timestamp ();
+ kbd_buffer_store_event (&event);
+ }
+
+ if (have_mouse > 0)
+ {
+ int but, press, x, y, ok;
+
+ /* Check for mouse movement *before* buttons. */
+ mouse_check_moved ();
+
+ for (but = 0; but < NUM_MOUSE_BUTTONS; but++)
+ for (press = 0; press < 2; press++)
+ {
+ int button_num = but;
+
+ if (press)
+ ok = mouse_pressed (but, &x, &y);
+ else
+ ok = mouse_released (but, &x, &y);
+ if (ok)
+ {
+ /* Allow a simultaneous press/release of Mouse-1 and
+ Mouse-2 to simulate Mouse-3 on two-button mice. */
+ if (mouse_button_count == 2 && but < 2)
+ {
+ int x2, y2; /* don't clobber original coordinates */
+
+ /* If only one button is pressed, wait 100 msec and
+ check again. This way, Speedy Gonzales isn't
+ punished, while the slow get their chance. */
+ if (press && mouse_pressed (1-but, &x2, &y2)
+ || !press && mouse_released (1-but, &x2, &y2))
+ button_num = 2;
+ else
+ {
+ delay (100);
+ if (press && mouse_pressed (1-but, &x2, &y2)
+ || !press && mouse_released (1-but, &x2, &y2))
+ button_num = 2;
+ }
+ }
+
+ event.kind = mouse_click;
+ event.code = button_num;
+ event.modifiers = dos_get_modifiers (0)
+ | (press ? down_modifier : up_modifier);
+ event.x = x;
+ event.y = y;
+ XSETFRAME (event.frame_or_window, selected_frame);
+ event.timestamp = event_timestamp ();
+ kbd_buffer_store_event (&event);
+ }
+ }
+ }
+
+ return -1;
+}
+
+static int prev_get_char = -1;
+
+/* Return 1 if a key is ready to be read without suspending execution. */
+
+dos_keysns ()
+{
+ if (prev_get_char != -1)
+ return 1;
+ else
+ return ((prev_get_char = dos_rawgetc ()) != -1);
+}
+
+/* Read a key. Return -1 if no key is ready. */
+
+dos_keyread ()
+{
+ if (prev_get_char != -1)
+ {
+ int c = prev_get_char;
+ prev_get_char = -1;
+ return c;
+ }
+ else
+ return dos_rawgetc ();
+}
+\f
+#ifndef HAVE_X_WINDOWS
+/* See xterm.c for more info. */
+void
+pixel_to_glyph_coords (f, pix_x, pix_y, x, y, bounds, noclip)
+ FRAME_PTR f;
+ register int pix_x, pix_y;
+ register int *x, *y;
+ void /* XRectangle */ *bounds;
+ int noclip;
+{
+ if (bounds) abort ();
+
+ /* Ignore clipping. */
+
+ *x = pix_x;
+ *y = pix_y;
+}
+
+void
+glyph_to_pixel_coords (f, x, y, pix_x, pix_y)
+ FRAME_PTR f;
+ register int x, y;
+ register int *pix_x, *pix_y;
+{
+ *pix_x = x;
+ *pix_y = y;
+}
+\f
+/* Simulation of X's menus. Nothing too fancy here -- just make it work
+ for now.
+
+ Actually, I don't know the meaning of all the parameters of the functions
+ here -- I only know how they are called by xmenu.c. I could of course
+ grab the nearest Xlib manual (down the hall, second-to-last door on the
+ left), but I don't think it's worth the effort. */
+
+static XMenu *
+IT_menu_create ()
+{
+ XMenu *menu;
+
+ menu = (XMenu *) xmalloc (sizeof (XMenu));
+ menu->allocated = menu->count = menu->panecount = menu->width = 0;
+ return menu;
+}
+
+/* Allocate some (more) memory for MENU ensuring that there is room for one
+ for item. */
+
+static void
+IT_menu_make_room (XMenu *menu)
+{
+ if (menu->allocated == 0)
+ {
+ int count = menu->allocated = 10;
+ menu->text = (char **) xmalloc (count * sizeof (char *));
+ menu->submenu = (XMenu **) xmalloc (count * sizeof (XMenu *));
+ menu->panenumber = (int *) xmalloc (count * sizeof (int));
+ }
+ else if (menu->allocated == menu->count)
+ {
+ int count = menu->allocated = menu->allocated + 10;
+ menu->text
+ = (char **) xrealloc (menu->text, count * sizeof (char *));
+ menu->submenu
+ = (XMenu **) xrealloc (menu->submenu, count * sizeof (XMenu *));
+ menu->panenumber
+ = (int *) xrealloc (menu->panenumber, count * sizeof (int));
+ }
+}
+
+/* Search the given menu structure for a given pane number. */
+
+static XMenu *
+IT_menu_search_pane (XMenu *menu, int pane)
+{
+ int i;
+ XMenu *try;
+
+ for (i = 0; i < menu->count; i++)
+ if (menu->submenu[i])
+ {
+ if (pane == menu->panenumber[i])
+ return menu->submenu[i];
+ if ((try = IT_menu_search_pane (menu->submenu[i], pane)))
+ return try;
+ }
+ return (XMenu *) 0;
+}
+
+/* Determine how much screen space a given menu needs. */
+
+static void
+IT_menu_calc_size (XMenu *menu, int *width, int *height)
+{
+ int i, h2, w2, maxsubwidth, maxheight;
+
+ maxsubwidth = 0;
+ maxheight = menu->count;
+ for (i = 0; i < menu->count; i++)
+ {
+ if (menu->submenu[i])
+ {
+ IT_menu_calc_size (menu->submenu[i], &w2, &h2);
+ if (w2 > maxsubwidth) maxsubwidth = w2;
+ if (i + h2 > maxheight) maxheight = i + h2;
+ }
+ }
+ *width = menu->width + maxsubwidth;
+ *height = maxheight;
+}
+
+/* Display MENU at (X,Y) using FACES. */
+
+static void
+IT_menu_display (XMenu *menu, int y, int x, int *faces)
+{
+ int i, j, face, width;
+ GLYPH *text, *p;
+ char *q;
+ int mx, my;
+ int enabled, mousehere;
+ int row, col;
+
+ width = menu->width;
+ text = (GLYPH *) xmalloc ((width + 2) * sizeof (GLYPH));
+ ScreenGetCursor (&row, &col);
+ mouse_get_xy (&mx, &my);
+ IT_update_begin ();
+ for (i = 0; i < menu->count; i++)
+ {
+ IT_cursor_to (y + i, x);
+ enabled
+ = (!menu->submenu[i] && menu->panenumber[i]) || (menu->submenu[i]);
+ mousehere = (y + i == my && x <= mx && mx < x + width + 2);
+ face = faces[enabled + mousehere * 2];
+ p = text;
+ *p++ = FAST_MAKE_GLYPH (' ', face);
+ for (j = 0, q = menu->text[i]; *q; j++)
+ {
+ if (*q > 26)
+ *p++ = FAST_MAKE_GLYPH (*q++, face);
+ else /* make '^x' */
+ {
+ *p++ = FAST_MAKE_GLYPH ('^', face);
+ j++;
+ *p++ = FAST_MAKE_GLYPH (*q++ + 64, face);
+ }
+ }
+
+ for (; j < width; j++)
+ *p++ = FAST_MAKE_GLYPH (' ', face);
+ *p++ = FAST_MAKE_GLYPH (menu->submenu[i] ? 16 : ' ', face);
+ IT_write_glyphs (text, width + 2);
+ }
+ IT_update_end ();
+ IT_cursor_to (row, col);
+ xfree (text);
+}
+\f
+/* --------------------------- X Menu emulation ---------------------- */
+
+/* Report availability of menus. */
+
+int
+have_menus_p ()
+{
+ return 1;
+}
+
+/* Create a brand new menu structure. */
+
+XMenu *
+XMenuCreate (Display *foo1, Window foo2, char *foo3)
+{
+ return IT_menu_create ();
+}
+
+/* Create a new pane and place it on the outer-most level. It is not
+ clear that it should be placed out there, but I don't know what else
+ to do. */
+
+int
+XMenuAddPane (Display *foo, XMenu *menu, char *txt, int enable)
+{
+ int len;
+ char *p;
+
+ if (!enable)
+ abort ();
+
+ IT_menu_make_room (menu);
+ menu->submenu[menu->count] = IT_menu_create ();
+ menu->text[menu->count] = txt;
+ menu->panenumber[menu->count] = ++menu->panecount;
+ menu->count++;
+
+ /* Adjust length for possible control characters (which will
+ be written as ^x). */
+ for (len = strlen (txt), p = txt; *p; p++)
+ if (*p < 27)
+ len++;
+
+ if (len > menu->width)
+ menu->width = len;
+
+ return menu->panecount;
+}
+
+/* Create a new item in a menu pane. */
+
+int
+XMenuAddSelection (Display *bar, XMenu *menu, int pane,
+ int foo, char *txt, int enable)
+{
+ int len;
+ char *p;
+
+ if (pane)
+ if (!(menu = IT_menu_search_pane (menu, pane)))
+ return XM_FAILURE;
+ IT_menu_make_room (menu);
+ menu->submenu[menu->count] = (XMenu *) 0;
+ menu->text[menu->count] = txt;
+ menu->panenumber[menu->count] = enable;
+ menu->count++;
+
+ /* Adjust length for possible control characters (which will
+ be written as ^x). */
+ for (len = strlen (txt), p = txt; *p; p++)
+ if (*p < 27)
+ len++;
+
+ if (len > menu->width)
+ menu->width = len;
+
+ return XM_SUCCESS;
+}
+
+/* Decide where the menu would be placed if requested at (X,Y). */
+
+void
+XMenuLocate (Display *foo0, XMenu *menu, int foo1, int foo2, int x, int y,
+ int *ulx, int *uly, int *width, int *height)
+{
+ IT_menu_calc_size (menu, width, height);
+ *ulx = x + 1;
+ *uly = y;
+ *width += 2;
+}
+
+struct IT_menu_state
+{
+ void *screen_behind;
+ XMenu *menu;
+ int pane;
+ int x, y;
+};
+
+
+/* Display menu, wait for user's response, and return that response. */
+
+int
+XMenuActivate (Display *foo, XMenu *menu, int *pane, int *selidx,
+ int x0, int y0, unsigned ButtonMask, char **txt)
+{
+ struct IT_menu_state *state;
+ int statecount;
+ int x, y, i, b;
+ int screensize;
+ int faces[4], selectface;
+ int leave, result, onepane;
+ int title_faces[4]; /* face to display the menu title */
+ int buffers_num_deleted = 0;
+
+ /* Just in case we got here without a mouse present... */
+ if (have_mouse <= 0)
+ return XM_IA_SELECT;
+ /* Don't allow non-positive x0 and y0, lest the menu will wrap
+ around the display. */
+ if (x0 <= 0)
+ x0 = 1;
+ if (y0 <= 0)
+ y0 = 1;
+
+ state = alloca (menu->panecount * sizeof (struct IT_menu_state));
+ screensize = screen_size * 2;
+ faces[0]
+ = compute_glyph_face (selected_frame,
+ face_name_id_number
+ (selected_frame,
+ intern ("msdos-menu-passive-face")),
+ 0);
+ faces[1]
+ = compute_glyph_face (selected_frame,
+ face_name_id_number
+ (selected_frame,
+ intern ("msdos-menu-active-face")),
+ 0);
+ selectface
+ = face_name_id_number (selected_frame, intern ("msdos-menu-select-face"));
+ faces[2] = compute_glyph_face (selected_frame, selectface, faces[0]);
+ faces[3] = compute_glyph_face (selected_frame, selectface, faces[1]);
+
+ /* Make sure the menu title is always displayed with
+ `msdos-menu-active-face', no matter where the mouse pointer is. */
+ for (i = 0; i < 4; i++)
+ title_faces[i] = faces[3];
+
+ statecount = 1;
+
+ /* Don't let the title for the "Buffers" popup menu include a
+ digit (which is ugly).
+
+ This is a terrible kludge, but I think the "Buffers" case is
+ the only one where the title includes a number, so it doesn't
+ seem to be necessary to make this more general. */
+ if (strncmp (menu->text[0], "Buffers 1", 9) == 0)
+ {
+ menu->text[0][7] = '\0';
+ buffers_num_deleted = 1;
+ }
+ state[0].menu = menu;
+ mouse_off ();
+ ScreenRetrieve (state[0].screen_behind = xmalloc (screensize));
+
+ /* Turn off the cursor. Otherwise it shows through the menu
+ panes, which is ugly. */
+ IT_display_cursor (0);
+
+ IT_menu_display (menu, y0 - 1, x0 - 1, title_faces); /* display menu title */
+ if (buffers_num_deleted)
+ menu->text[0][7] = ' ';
+ if ((onepane = menu->count == 1 && menu->submenu[0]))
+ {
+ menu->width = menu->submenu[0]->width;
+ state[0].menu = menu->submenu[0];
+ }
+ else
+ {
+ state[0].menu = menu;
+ }
+ state[0].x = x0 - 1;
+ state[0].y = y0;
+ state[0].pane = onepane;
+
+ mouse_last_x = -1; /* A hack that forces display. */
+ leave = 0;
+ while (!leave)
+ {
+ if (!mouse_visible) mouse_on ();
+ mouse_check_moved ();
+ if (selected_frame->mouse_moved)
+ {
+ selected_frame->mouse_moved = 0;
+ result = XM_IA_SELECT;
+ mouse_get_xy (&x, &y);
+ for (i = 0; i < statecount; i++)
+ if (state[i].x <= x && x < state[i].x + state[i].menu->width + 2)
+ {
+ int dy = y - state[i].y;
+ if (0 <= dy && dy < state[i].menu->count)
+ {
+ if (!state[i].menu->submenu[dy])
+ if (state[i].menu->panenumber[dy])
+ result = XM_SUCCESS;
+ else
+ result = XM_IA_SELECT;
+ *pane = state[i].pane - 1;
+ *selidx = dy;
+ /* We hit some part of a menu, so drop extra menus that
+ have been opened. That does not include an open and
+ active submenu. */
+ if (i != statecount - 2
+ || state[i].menu->submenu[dy] != state[i+1].menu)
+ while (i != statecount - 1)
+ {
+ statecount--;
+ mouse_off ();
+ ScreenUpdate (state[statecount].screen_behind);
+ xfree (state[statecount].screen_behind);
+ }
+ if (i == statecount - 1 && state[i].menu->submenu[dy])
+ {
+ IT_menu_display (state[i].menu,
+ state[i].y,
+ state[i].x,
+ faces);
+ state[statecount].menu = state[i].menu->submenu[dy];
+ state[statecount].pane = state[i].menu->panenumber[dy];
+ mouse_off ();
+ ScreenRetrieve (state[statecount].screen_behind
+ = xmalloc (screensize));
+ state[statecount].x
+ = state[i].x + state[i].menu->width + 2;
+ state[statecount].y = y;
+ statecount++;
+ }
+ }
+ }
+ IT_menu_display (state[statecount - 1].menu,
+ state[statecount - 1].y,
+ state[statecount - 1].x,
+ faces);
+ }
+ for (b = 0; b < mouse_button_count; b++)
+ {
+ (void) mouse_pressed (b, &x, &y);
+ if (mouse_released (b, &x, &y))
+ leave = 1;
+ }
+ }
+
+ mouse_off ();
+ ScreenUpdate (state[0].screen_behind);
+ while (statecount--)
+ xfree (state[statecount].screen_behind);
+ IT_display_cursor (1); /* turn cursor back on */