#include "w32term.h"
#endif /* HAVE_NTGUI */
+#ifdef macintosh
+#include "macterm.h"
+#endif
+
/* Include systime.h after xterm.h to avoid double inclusion of time.h. */
#include "systime.h"
#ifdef HAVE_WINDOW_SYSTEM
/* Make all keyboard buffers much bigger when using X windows. */
#ifdef macintosh
-/* But not too big (local data > 32K error) if on macintosh */
+/* But not too big (local data > 32K error) if on macintosh. */
#define KBD_BUFFER_SIZE 512
#else
#define KBD_BUFFER_SIZE 4096
If the value is non-nil and not a number, we wait 2 seconds. */
Lisp_Object Vsuggest_key_bindings;
+/* How long to display an echo-area message when the minibuffer is active.
+ If the value is not a number, such messages don't time out. */
+Lisp_Object Vminibuffer_message_timeout;
+
/* Character that causes a quit. Normally C-g.
If we are running on an ordinary terminal, this must be an ordinary
int meta_key;
+/* Non-zero means force key bindings update in parse_menu_item. */
+
+int update_menu_bindings;
+
extern char *pending_malloc_warning;
/* Circular buffer for pre-read keyboard input. */
command_loop_level++;
update_mode_lines = 1;
+ /* This function may have been called from a debugger called from
+ within redisplay, for instance by Edebugging a function called
+ from fontification-functions. We want to allow redisplay in
+ the debugging session.
+
+ The recursive edit is left with a `(throw exit ...)'. The `exit'
+ tag is not caught anywhere in redisplay, i.e. when we leave the
+ recursive edit, the original redisplay leading to the recursive
+ edit will be unwound. The outcome should therefore be safe. */
+ specbind (Qinhibit_redisplay, Qnil);
+ redisplaying_p = 0;
+
record_unwind_protect (recursive_edit_unwind,
(command_loop_level
&& current_buffer != XBUFFER (XWINDOW (selected_window)->buffer))
Vdeactivate_mark = Qnil;
/* If minibuffer on and echo area in use,
- wait 2 sec and redraw minibuffer. */
+ wait a short time and redraw minibuffer. */
if (minibuf_level
&& !NILP (echo_area_buffer[0])
- && EQ (minibuf_window, echo_area_window))
+ && EQ (minibuf_window, echo_area_window)
+ && NUMBERP (Vminibuffer_message_timeout))
{
/* Bind inhibit-quit to t so that C-g gets read in
rather than quitting back to the minibuffer. */
int count = specpdl_ptr - specpdl;
specbind (Qinhibit_quit, Qt);
- Fsit_for (make_number (2), Qnil, Qnil);
+ Fsit_for (Vminibuffer_message_timeout, Qnil, Qnil);
/* Clear the echo area. */
message2 (0, 0, 0);
safe_run_hooks (Qecho_area_clear_hook);
args[1] = window;
args[2] = object;
args[3] = pos;
- help = call_function (4, args);
+ help = safe_call (4, args);
}
else
- help = eval_form (help);
+ help = safe_eval (help);
if (!STRINGP (help))
return;
{
int count = specpdl_ptr - specpdl;
specbind (Qmessage_truncate_lines, Qt);
- message3_nolog (help, XSTRING (help)->size,
+ message3_nolog (help, STRING_BYTES (XSTRING (help)),
STRING_MULTIBYTE (help));
unbind_to (count, Qnil);
}
else
- message (0);
+ message (0);
}
+
+ help_echo_showing_p = STRINGP (help);
}
}
/* Redisplay if no pending input. */
while (!input_pending)
{
- redisplay ();
+ if (help_echo_showing_p && !EQ (selected_window, minibuf_window))
+ redisplay_preserve_echo_area ();
+ else
+ redisplay ();
if (!input_pending)
/* Normal case: no input arrived during redisplay. */
/* Actually read a character, waiting if necessary. */
save_getcjmp (save_jump);
restore_getcjmp (local_getcjmp);
+ timer_start_idle ();
c = kbd_buffer_get_event (&kb, used_mouse_menu);
restore_getcjmp (save_jump);
non_reread:
timer_stop_idle ();
-
start_polling ();
if (NILP (c))
and loop around to read another event. */
save = Vquit_flag;
Vquit_flag = Qnil;
- tem = get_keyelt (access_keymap (get_keymap_1 (Vspecial_event_map, 0, 0),
- c, 0, 0), 1);
+ tem = access_keymap (get_keymap (Vspecial_event_map, 0, 1), c, 0, 0, 1);
Vquit_flag = save;
if (!NILP (tem))
record_char (c)
Lisp_Object c;
{
- total_keys++;
- XVECTOR (recent_keys)->contents[recent_keys_index] = c;
- if (++recent_keys_index >= NUM_RECENT_KEYS)
- recent_keys_index = 0;
+ Lisp_Object help;
+
+ /* Don't record `help-echo' in recent_keys unless it shows some help
+ message, and a different help than the previoiusly recorded
+ event. */
+ if (CONSP (c) && EQ (XCAR (c), Qhelp_echo))
+ {
+ Lisp_Object help;
+ help = Fnth (make_number (2), c);
+ if (STRINGP (help))
+ {
+ int last_idx;
+ Lisp_Object last_c, last_help;
+
+ last_idx = recent_keys_index - 1;
+ if (last_idx < 0)
+ last_idx = NUM_RECENT_KEYS - 1;
+ last_c = AREF (recent_keys, last_idx);
+
+ if (!CONSP (last_c)
+ || !EQ (XCAR (last_c), Qhelp_echo)
+ || (last_help = Fnth (make_number (2), last_c),
+ !EQ (last_help, help)))
+ {
+ total_keys++;
+ ASET (recent_keys, recent_keys_index, c);
+ if (++recent_keys_index >= NUM_RECENT_KEYS)
+ recent_keys_index = 0;
+ }
+ }
+ }
+ else
+ {
+ total_keys++;
+ ASET (recent_keys, recent_keys_index, c);
+ if (++recent_keys_index >= NUM_RECENT_KEYS)
+ recent_keys_index = 0;
+ }
+
/* Write c to the dribble file. If c is a lispy event, write
the event's symbol to the dribble file, in <brackets>. Bleaugh.
If you, dear reader, have a better idea, you've got the source. :-) */
fflush (dribble);
}
- store_kbd_macro_char (c);
+ if (!CONSP (c) || !EQ (Qhelp_echo, XCAR (c)))
+ store_kbd_macro_char (c);
num_nonmacro_input_events++;
}
abort ();
#endif
}
-#if defined (HAVE_X11) || defined (HAVE_NTGUI)
+#if defined (HAVE_X11) || defined (HAVE_NTGUI) || defined (macintosh)
else if (event->kind == delete_window_event)
{
/* Make an event (delete-frame (FRAME)). */
obj = Fcons (Qdelete_frame, Fcons (obj, Qnil));
kbd_fetch_ptr = event + 1;
}
+#endif
+#if defined (HAVE_X11) || defined (HAVE_NTGUI)
else if (event->kind == iconify_event)
{
/* Make an event (iconify-frame (FRAME)). */
XSETBUFFER (obj, current_buffer);
kbd_fetch_ptr = event + 1;
}
-#if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
+#if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (macintosh)
else if (event->kind == menu_bar_activate_event)
{
kbd_fetch_ptr = event + 1;
if (part == 1 || part == 3)
{
- /* Mode line or top line. Look for a string under
+ /* Mode line or header line. Look for a string under
the mouse that may have a `local-map' property. */
Lisp_Object string;
int charpos;
return Qnil;
pixel_to_glyph_coords (f, XINT (event->x), XINT (event->y),
&column, &row, NULL, 1);
- window = window_from_coordinates (f, column, row, &part, 0);
+ window = window_from_coordinates (f, XINT (event->x),
+ XINT (event->y), &part, 0);
if (!WINDOWP (window))
{
Lisp_Object window;
Lisp_Object posn;
Lisp_Object files;
- int row, column;
/* The frame_or_window field should be a cons of the frame in
which the event occurred and a list of the filenames
have been deleted. */
if (! FRAME_LIVE_P (f))
return Qnil;
- pixel_to_glyph_coords (f, XINT (event->x), XINT (event->y),
- &column, &row, NULL, 1);
- window = window_from_coordinates (f, column, row, &part, 0);
+
+ window = window_from_coordinates (f, XINT (event->x),
+ XINT (event->y), &part, 0);
if (!WINDOWP (window))
{
}
#endif /* HAVE_MOUSE */
-#if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
+#if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (macintosh)
case MENU_BAR_EVENT:
if (EQ (event->arg, event->frame_or_window))
/* This is the prefix key. We translate this to
if (! CONSP (object))
return 0;
+ if (EQ (XCAR (object), Qhelp_echo)
+ || EQ (XCAR (object), Qvertical_line)
+ || EQ (XCAR (object), Qmode_line)
+ || EQ (XCAR (object), Qheader_line))
+ return 0;
+
for (tail = object; CONSP (tail); tail = XCDR (tail))
{
Lisp_Object elt;
return Qnil;
}
-static void menu_bar_item ();
-static void menu_bar_one_keymap ();
+static void menu_bar_item P_ ((Lisp_Object, Lisp_Object));
+static void menu_bar_one_keymap P_ ((Lisp_Object));
/* These variables hold the vector under construction within
menu_bar_items and its subroutines, and the current index
result = Qnil;
for (mapno = nmaps - 1; mapno >= 0; mapno--)
- {
- if (! NILP (maps[mapno]))
- def = get_keyelt (access_keymap (maps[mapno], Qmenu_bar, 1, 0), 0);
- else
- def = Qnil;
-
- tem = Fkeymapp (def);
- if (!NILP (tem))
- menu_bar_one_keymap (def);
- }
+ if (!NILP (maps[mapno]))
+ {
+ def = get_keymap (access_keymap (maps[mapno], Qmenu_bar, 1, 0, 1),
+ 0, 1);
+ if (CONSP (def))
+ menu_bar_one_keymap (def);
+ }
/* Move to the end those items that should be at the end. */
/* Initialize optional entries. */
for (i = ITEM_PROPERTY_DEF; i < ITEM_PROPERTY_ENABLE; i++)
- XVECTOR (item_properties)->contents[i] = Qnil;
- XVECTOR (item_properties)->contents[ITEM_PROPERTY_ENABLE] = Qt;
+ AREF (item_properties, i) = Qnil;
+ AREF (item_properties, ITEM_PROPERTY_ENABLE) = Qt;
/* Save the item here to protect it from GC. */
- XVECTOR (item_properties)->contents[ITEM_PROPERTY_ITEM] = item;
+ AREF (item_properties, ITEM_PROPERTY_ITEM) = item;
item_string = XCAR (item);
if (STRINGP (item_string))
{
/* Old format menu item. */
- XVECTOR (item_properties)->contents[ITEM_PROPERTY_NAME] = item_string;
+ AREF (item_properties, ITEM_PROPERTY_NAME) = item_string;
/* Maybe help string. */
if (CONSP (item) && STRINGP (XCAR (item)))
{
- XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP]
- = XCAR (item);
+ AREF (item_properties, ITEM_PROPERTY_HELP) = XCAR (item);
start = item;
item = XCDR (item);
}
}
/* This is the real definition--the function to run. */
- XVECTOR (item_properties)->contents[ITEM_PROPERTY_DEF] = item;
+ AREF (item_properties, ITEM_PROPERTY_DEF) = item;
/* Get enable property, if any. */
if (SYMBOLP (item))
{
tem = Fget (item, Qmenu_enable);
if (!NILP (tem))
- XVECTOR (item_properties)->contents[ITEM_PROPERTY_ENABLE] = tem;
+ AREF (item_properties, ITEM_PROPERTY_ENABLE) = tem;
}
}
else if (EQ (item_string, Qmenu_item) && CONSP (item))
{
/* New format menu item. */
- XVECTOR (item_properties)->contents[ITEM_PROPERTY_NAME]
- = XCAR (item);
+ AREF (item_properties, ITEM_PROPERTY_NAME) = XCAR (item);
start = XCDR (item);
if (CONSP (start))
{
/* We have a real binding. */
- XVECTOR (item_properties)->contents[ITEM_PROPERTY_DEF]
- = XCAR (start);
+ AREF (item_properties, ITEM_PROPERTY_DEF) = XCAR (start);
item = XCDR (start);
/* Is there a cache list with key equivalences. */
item = XCDR (item);
if (EQ (tem, QCenable))
- XVECTOR (item_properties)->contents[ITEM_PROPERTY_ENABLE]
- = XCAR (item);
+ AREF (item_properties, ITEM_PROPERTY_ENABLE) = XCAR (item);
else if (EQ (tem, QCvisible) && !notreal)
{
/* If got a visible property and that evaluates to nil
return 0;
}
else if (EQ (tem, QChelp))
- XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP]
- = XCAR (item);
+ AREF (item_properties, ITEM_PROPERTY_HELP) = XCAR (item);
else if (EQ (tem, QCfilter))
filter = item;
else if (EQ (tem, QCkey_sequence))
{
tem = XCAR (item);
if (CONSP (tem) || (STRINGP (tem) && NILP (cachelist)))
- XVECTOR (item_properties)->contents[ITEM_PROPERTY_KEYEQ]
- = tem;
+ AREF (item_properties, ITEM_PROPERTY_KEYEQ) = tem;
}
else if (EQ (tem, QCbutton) && CONSP (XCAR (item)))
{
type = XCAR (tem);
if (EQ (type, QCtoggle) || EQ (type, QCradio))
{
- XVECTOR (item_properties)->contents[ITEM_PROPERTY_SELECTED]
+ AREF (item_properties, ITEM_PROPERTY_SELECTED)
= XCDR (tem);
- XVECTOR (item_properties)->contents[ITEM_PROPERTY_TYPE]
+ AREF (item_properties, ITEM_PROPERTY_TYPE)
= type;
}
}
/* If item string is not a string, evaluate it to get string.
If we don't get a string, skip this item. */
- item_string = XVECTOR (item_properties)->contents[ITEM_PROPERTY_NAME];
+ item_string = AREF (item_properties, ITEM_PROPERTY_NAME);
if (!(STRINGP (item_string) || notreal))
{
item_string = menu_item_eval_property (item_string);
if (!STRINGP (item_string))
return 0;
- XVECTOR (item_properties)->contents[ITEM_PROPERTY_NAME] = item_string;
+ AREF (item_properties, ITEM_PROPERTY_NAME) = item_string;
}
/* If got a filter apply it on definition. */
- def = XVECTOR (item_properties)->contents[ITEM_PROPERTY_DEF];
+ def = AREF (item_properties, ITEM_PROPERTY_DEF);
if (!NILP (filter))
{
def = menu_item_eval_property (list2 (XCAR (filter),
list2 (Qquote, def)));
- XVECTOR (item_properties)->contents[ITEM_PROPERTY_DEF] = def;
+ AREF (item_properties, ITEM_PROPERTY_DEF) = def;
}
/* If we got no definition, this item is just unselectable text which
return (inmenubar ? 0 : 1);
/* Enable or disable selection of item. */
- tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_ENABLE];
+ tem = AREF (item_properties, ITEM_PROPERTY_ENABLE);
if (!EQ (tem, Qt))
{
if (notreal)
tem = menu_item_eval_property (tem);
if (inmenubar && NILP (tem))
return 0; /* Ignore disabled items in menu bar. */
- XVECTOR (item_properties)->contents[ITEM_PROPERTY_ENABLE] = tem;
+ AREF (item_properties, ITEM_PROPERTY_ENABLE) = tem;
}
/* See if this is a separate pane or a submenu. */
- def = XVECTOR (item_properties)->contents[ITEM_PROPERTY_DEF];
- tem = get_keymap_1 (def, 0, 1);
+ def = AREF (item_properties, ITEM_PROPERTY_DEF);
+ tem = get_keymap (def, 0, 1);
/* For a subkeymap, just record its details and exit. */
- if (!NILP (tem))
+ if (CONSP (tem))
{
- XVECTOR (item_properties)->contents[ITEM_PROPERTY_MAP] = tem;
- XVECTOR (item_properties)->contents[ITEM_PROPERTY_DEF] = tem;
+ AREF (item_properties, ITEM_PROPERTY_MAP) = tem;
+ AREF (item_properties, ITEM_PROPERTY_DEF) = tem;
return 1;
}
+
/* At the top level in the menu bar, do likewise for commands also.
The menu bar does not display equivalent key bindings anyway.
ITEM_PROPERTY_DEF is already set up properly. */
XCDR (start) = Fcons (Fcons (Qnil, Qnil), XCDR (start));
cachelist = XCAR (XCDR (start));
newcache = 1;
- tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_KEYEQ];
+ tem = AREF (item_properties, ITEM_PROPERTY_KEYEQ);
if (!NILP (keyhint))
{
XCAR (cachelist) = XCAR (keyhint);
XCAR (cachelist) = Qt;
}
}
+
tem = XCAR (cachelist);
if (!EQ (tem, Qt))
{
if (!NILP (tem))
tem = Fkey_binding (tem, Qnil);
- prefix = XVECTOR (item_properties)->contents[ITEM_PROPERTY_KEYEQ];
+ prefix = AREF (item_properties, ITEM_PROPERTY_KEYEQ);
if (CONSP (prefix))
{
def = XCAR (prefix);
prefix = XCDR (prefix);
}
else
- def = XVECTOR (item_properties)->contents[ITEM_PROPERTY_DEF];
+ def = AREF (item_properties, ITEM_PROPERTY_DEF);
- if (NILP (XCAR (cachelist))) /* Have no saved key. */
+ if (!update_menu_bindings)
+ chkcache = 0;
+ else if (NILP (XCAR (cachelist))) /* Have no saved key. */
{
if (newcache /* Always check first time. */
/* Should we check everything when precomputing key
bindings? */
- /* || notreal */
/* If something had no key binding before, don't recheck it
because that is too slow--except if we have a list of
rebound commands in Vdefine_key_rebound_commands, do
command name has equivalent keys. Otherwise look up the
specified command itself. We don't try both, because that
makes lmenu menus slow. */
- if (SYMBOLP (def) && SYMBOLP (XSYMBOL (def)->function)
+ if (SYMBOLP (def)
+ && SYMBOLP (XSYMBOL (def)->function)
&& ! NILP (Fget (def, Qmenu_alias)))
def = XSYMBOL (def)->function;
tem = Fwhere_is_internal (def, Qnil, Qt, Qnil);
return 1;
/* If we have an equivalent key binding, use that. */
- XVECTOR (item_properties)->contents[ITEM_PROPERTY_KEYEQ] = tem;
+ AREF (item_properties, ITEM_PROPERTY_KEYEQ) = tem;
/* Include this when menu help is implemented.
tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP];
*/
/* Handle radio buttons or toggle boxes. */
- tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_SELECTED];
+ tem = AREF (item_properties, ITEM_PROPERTY_SELECTED);
if (!NILP (tem))
- XVECTOR (item_properties)->contents[ITEM_PROPERTY_SELECTED]
+ AREF (item_properties, ITEM_PROPERTY_SELECTED)
= menu_item_eval_property (tem);
return 1;
if (!NILP (maps[i]))
{
Lisp_Object keymap;
-
- keymap = get_keyelt (access_keymap (maps[i], Qtool_bar, 1, 1), 0);
- if (!NILP (Fkeymapp (keymap)))
+
+ keymap = get_keymap (access_keymap (maps[i], Qtool_bar, 1, 0, 1), 0, 1);
+ if (CONSP (keymap))
{
Lisp_Object tail;
PROP (TOOL_BAR_ITEM_BINDING))));
/* See if the binding is a keymap. Give up if it is. */
- if (!NILP (get_keymap_1 (PROP (TOOL_BAR_ITEM_BINDING), 0, 1)))
+ if (CONSP (get_keymap (PROP (TOOL_BAR_ITEM_BINDING), 0, 1)))
return 0;
/* Enable or disable selection of item. */
int i, first_binding;
int did_meta = 0;
- /* If KEY is a meta ASCII character, treat it like meta-prefix-char
- followed by the corresponding non-meta character.
- Put the results into DEFS, since we are going to alter that anyway.
- Do not alter CURRENT or NEXT. */
- if (INTEGERP (key) && (XUINT (key) & CHAR_META))
- {
- for (i = 0; i < nmaps; i++)
- if (! NILP (current[i]))
- {
- Lisp_Object def;
- def = get_keyelt (access_keymap (current[i],
- meta_prefix_char, 1, 0), 0);
-
- /* Note that since we pass the resulting bindings through
- get_keymap_1, non-prefix bindings for meta-prefix-char
- disappear. */
- defs[i] = get_keymap_1 (def, 0, 1);
- }
- else
- defs[i] = Qnil;
-
- did_meta = 1;
- XSETINT (key, XFASTINT (key) & ~CHAR_META);
- }
-
first_binding = nmaps;
for (i = nmaps - 1; i >= 0; i--)
{
else
map = current[i];
- defs[i] = get_keyelt (access_keymap (map, key, 1, 0), 1);
+ defs[i] = access_keymap (map, key, 1, 0, 1);
if (! NILP (defs[i]))
first_binding = i;
}
/* Given the set of bindings we've found, produce the next set of maps. */
if (first_binding < nmaps)
for (i = 0; i < nmaps; i++)
- next[i] = NILP (defs[i]) ? Qnil : get_keymap_1 (defs[i], 0, 1);
+ next[i] = NILP (defs[i]) ? Qnil : get_keymap (defs[i], 0, 1);
return first_binding;
}
keytran_map = Vkey_translation_map;
/* If there is no function-key-map, turn off function key scanning. */
- if (NILP (Fkeymapp (Vfunction_key_map)))
+ if (!KEYMAPP (Vfunction_key_map))
fkey_start = fkey_end = bufsize + 1;
/* If there is no key-translation-map, turn off scanning. */
- if (NILP (Fkeymapp (Vkey_translation_map)))
+ if (!KEYMAPP (Vkey_translation_map))
keytran_start = keytran_end = bufsize + 1;
if (INTERACTIVE)
Lisp_Object key;
key = keybuf[fkey_end++];
- /* Look up meta-characters by prefixing them
- with meta_prefix_char. I hate this. */
- if (INTEGERP (key) && XUINT (key) & meta_modifier)
- {
- fkey_next
- = get_keymap_1
- (get_keyelt
- (access_keymap (fkey_map, meta_prefix_char, 1, 0), 0),
- 0, 1);
- XSETFASTINT (key, XFASTINT (key) & ~meta_modifier);
- }
- else
- fkey_next = fkey_map;
-
fkey_next
- = get_keyelt (access_keymap (fkey_next, key, 1, 0), 1);
+ = access_keymap (fkey_map, key, 1, 0, 1);
/* Handle symbol with autoload definition. */
if (SYMBOLP (fkey_next) && ! NILP (Ffboundp (fkey_next))
or an array. */
if (SYMBOLP (fkey_next) && ! NILP (Ffboundp (fkey_next))
&& (!NILP (Farrayp (XSYMBOL (fkey_next)->function))
- || !NILP (Fkeymapp (XSYMBOL (fkey_next)->function))))
+ || KEYMAPP (XSYMBOL (fkey_next)->function)))
fkey_next = XSYMBOL (fkey_next)->function;
#if 0 /* I didn't turn this on, because it might cause trouble
goto replay_sequence;
}
- fkey_map = get_keymap_1 (fkey_next, 0, 1);
+ fkey_map = get_keymap (fkey_next, 0, 1);
/* If we no longer have a bound suffix, try a new positions for
fkey_start. */
- if (NILP (fkey_map))
+ if (!CONSP (fkey_map))
{
fkey_end = ++fkey_start;
fkey_map = Vfunction_key_map;
Lisp_Object key;
key = keybuf[keytran_end++];
- /* Look up meta-characters by prefixing them
- with meta_prefix_char. I hate this. */
- if (INTEGERP (key) && XUINT (key) & meta_modifier)
- {
- keytran_next
- = get_keymap_1
- (get_keyelt
- (access_keymap (keytran_map, meta_prefix_char, 1, 0), 0),
- 0, 1);
- XSETFASTINT (key, XFASTINT (key) & ~meta_modifier);
- }
- else
- keytran_next = keytran_map;
-
keytran_next
- = get_keyelt (access_keymap (keytran_next, key, 1, 0), 1);
+ = access_keymap (keytran_map, key, 1, 0, 1);
/* Handle symbol with autoload definition. */
if (SYMBOLP (keytran_next) && ! NILP (Ffboundp (keytran_next))
or an array. */
if (SYMBOLP (keytran_next) && ! NILP (Ffboundp (keytran_next))
&& (!NILP (Farrayp (XSYMBOL (keytran_next)->function))
- || !NILP (Fkeymapp (XSYMBOL (keytran_next)->function))))
+ || KEYMAPP (XSYMBOL (keytran_next)->function)))
keytran_next = XSYMBOL (keytran_next)->function;
/* If the key translation map gives a function, not an
goto replay_sequence;
}
- keytran_map = get_keymap_1 (keytran_next, 0, 1);
+ keytran_map = get_keymap (keytran_next, 0, 1);
/* If we no longer have a bound suffix, try a new positions for
keytran_start. */
- if (NILP (keytran_map))
+ if (!CONSP (keytran_map))
{
keytran_end = ++keytran_start;
keytran_map = Vkey_translation_map;
prompt, ! NILP (dont_downcase_last),
! NILP (can_return_switch_frame), 0);
+#if 0 /* The following is fine for code reading a key sequence and
+ then proceeding with a lenghty compuation, but it's not good
+ for code reading keys in a loop, like an input method. */
#ifdef HAVE_X_WINDOWS
if (display_busy_cursor_p)
start_busy_cursor ();
+#endif
#endif
if (i == -1)
suppressed only after special commands that set\n\
`disable-point-adjustment' (which see) to non-nil.");
Vglobal_disable_point_adjustment = Qnil;
+
+ DEFVAR_BOOL ("update-menu-bindings", &update_menu_bindings,
+ "Non-nil means updating menu bindings is allowed.\n\
+A value of nil means menu bindings should not be updated.\n\
+Used during Emacs' startup.");
+ update_menu_bindings = 1;
+
+ DEFVAR_LISP ("minibuffer-message-timeout", &Vminibuffer_message_timeout,
+ "*How long to display an echo-area message when the minibuffer is active.\n\
+If the value is not a number, such messages don't time out.");
+ Vminibuffer_message_timeout = make_number (2);
}
void