#include "buffer.h"
#include "charset.h"
#include "keyboard.h"
+#include "frame.h"
#include "termhooks.h"
#include "blockinput.h"
#include "puresize.h"
/* List of emulation mode keymap alists. */
Lisp_Object Vemulation_mode_map_alists;
-/* Keymap mapping ASCII function key sequences onto their preferred forms.
- Initialized by the terminal-specific lisp files. See DEFVAR for more
- documentation. */
-Lisp_Object Vfunction_key_map;
-
-/* Keymap mapping ASCII function key sequences onto their preferred forms. */
-Lisp_Object Vkey_translation_map;
-
/* A list of all commands given new bindings since a certain time
when nil was stored here.
This is used to speed up recomputation of menu key equivalents
a cons (STRING . DEFN), meaning that DEFN is the definition
(DEFN should be a valid definition in its own right),
or a cons (MAP . CHAR), meaning use definition of CHAR in keymap MAP,
- or an extended menu item definition. (See info node `Extended Menu Items'.)
+ or an extended menu item definition.
+ (See info node `(elisp)Extended Menu Items'.)
If KEYMAP is a sparse keymap with a binding for KEY, the existing
binding is altered. If there is no binding for KEY, the new pair
if (SYMBOLP (def) && !EQ (Vdefine_key_rebound_commands, Qt))
Vdefine_key_rebound_commands = Fcons (def, Vdefine_key_rebound_commands);
- meta_bit = VECTORP (key) ? meta_modifier : 0x80;
+ meta_bit = (VECTORP (key) || STRINGP (key) && STRING_MULTIBYTE (key)
+ ? meta_modifier : 0x80);
if (VECTORP (def) && ASIZE (def) > 0 && CONSP (AREF (def, 0)))
{ /* DEF is apparently an XEmacs-style keyboard macro. */
/* This function may GC (it calls Fkey_binding). */
-DEFUN ("command-remapping", Fcommand_remapping, Scommand_remapping, 1, 2, 0,
- doc: /* Return the remapping for command COMMAND in current keymaps.
+DEFUN ("command-remapping", Fcommand_remapping, Scommand_remapping, 1, 3, 0,
+ doc: /* Return the remapping for command COMMAND.
Returns nil if COMMAND is not remapped (or not a symbol).
If the optional argument POSITION is non-nil, it specifies a mouse
position as returned by `event-start' and `event-end', and the
remapping occurs in the keymaps associated with it. It can also be a
number or marker, in which case the keymap properties at the specified
-buffer position instead of point are used. */)
- (command, position)
- Lisp_Object command, position;
+buffer position instead of point are used. The KEYMAPS argument is
+ignored if POSITION is non-nil.
+
+If the optional argument KEYMAPS is non-nil, it should be a list of
+keymaps to search for command remapping. Otherwise, search for the
+remapping in all currently active keymaps. */)
+ (command, position, keymaps)
+ Lisp_Object command, position, keymaps;
{
if (!SYMBOLP (command))
return Qnil;
ASET (command_remapping_vector, 1, command);
- return Fkey_binding (command_remapping_vector, Qnil, Qt, position);
+
+ if (NILP (keymaps))
+ return Fkey_binding (command_remapping_vector, Qnil, Qt, position);
+ else
+ {
+ Lisp_Object maps, binding;
+
+ for (maps = keymaps; !NILP (maps); maps = Fcdr (maps))
+ {
+ binding = Flookup_key (Fcar (maps), command_remapping_vector, Qnil);
+ if (!NILP (binding) && !INTEGERP (binding))
+ return binding;
+ }
+ return Qnil;
+ }
}
/* Value is number if KEY is too long; nil if valid but has no definition. */
c = Fevent_convert_list (c);
/* Turn the 8th bit of string chars into a meta modifier. */
- if (INTEGERP (c) && XINT (c) & 0x80 && STRINGP (key))
+ if (STRINGP (key) && XINT (c) & 0x80 && !STRING_MULTIBYTE (key))
XSETINT (c, (XINT (c) | meta_modifier) & ~0x80);
/* Allow string since binding for `menu-bar-select-buffer'
static Lisp_Object *cmm_modes = NULL, *cmm_maps = NULL;
static int cmm_size = 0;
-/* Store a pointer to an array of the keymaps of the currently active
- minor modes in *buf, and return the number of maps it contains.
+/* Store a pointer to an array of the currently active minor modes in
+ *modeptr, a pointer to an array of the keymaps of the currently
+ active minor modes in *mapptr, and return the number of maps
+ *mapptr contains.
This function always returns a pointer to the same buffer, and may
free or reallocate it, so if you want to keep it for a long time or
/* We are not interested in locations without event data */
- if (EVENT_HAS_PARAMETERS (event))
+ if (EVENT_HAS_PARAMETERS (event) && CONSP (XCDR (event)))
{
Lisp_Object kind = EVENT_HEAD_KIND (EVENT_HEAD (event));
- if (CONSP (XCDR (event)) && EQ (kind, Qmouse_click))
+ if (EQ (kind, Qmouse_click))
position = EVENT_START (event);
}
}
if (NILP (no_remap) && SYMBOLP (value))
{
Lisp_Object value1;
- if (value1 = Fcommand_remapping (value, position), !NILP (value1))
+ if (value1 = Fcommand_remapping (value, position, Qnil), !NILP (value1))
value = value1;
}
/* 1 means ignore all menu bindings entirely. */
int nomenus = !NILP (firstonly) && !EQ (firstonly, Qnon_ascii);
- /* If this command is remapped, then it has no key bindings
- of its own. */
- if (NILP (no_remap) && SYMBOLP (definition))
- {
- Lisp_Object tem;
- if (tem = Fcommand_remapping (definition, Qnil), !NILP (tem))
- return Qnil;
- }
-
found = keymaps;
while (CONSP (found))
{
found = Qnil;
sequences = Qnil;
+ /* If this command is remapped, then it has no key bindings
+ of its own. */
+ if (NILP (no_remap)
+ && SYMBOLP (definition)
+ && !NILP (Fcommand_remapping (definition, Qnil, keymaps)))
+ RETURN_UNGCPRO (Qnil);
+
for (; !NILP (maps); maps = Fcdr (maps))
{
/* Key sequence to reach map, and the map that it reaches */
You type Translation\n\
-------- -----------\n";
+ CHECK_BUFFER (buffer);
+
shadow = Qnil;
GCPRO1 (shadow);
outbuf = Fcurrent_buffer ();
/* Report on alternates for keys. */
- if (STRINGP (Vkeyboard_translate_table) && !NILP (prefix))
+ if (STRINGP (current_kboard->Vkeyboard_translate_table) && !NILP (prefix))
{
int c;
- const unsigned char *translate = SDATA (Vkeyboard_translate_table);
- int translate_len = SCHARS (Vkeyboard_translate_table);
+ const unsigned char *translate = SDATA (current_kboard->Vkeyboard_translate_table);
+ int translate_len = SCHARS (current_kboard->Vkeyboard_translate_table);
for (c = 0; c < translate_len; c++)
if (translate[c] != c)
insert ("\n", 1);
/* Insert calls signal_after_change which may GC. */
- translate = SDATA (Vkeyboard_translate_table);
+ translate = SDATA (current_kboard->Vkeyboard_translate_table);
}
insert ("\n", 1);
}
- if (!NILP (Vkey_translation_map))
- describe_map_tree (Vkey_translation_map, 0, Qnil, prefix,
+ if (!NILP (current_kboard->Vlocal_key_translation_map))
+ describe_map_tree (current_kboard->Vlocal_key_translation_map, 0, Qnil, prefix,
"Key translations", nomenu, 1, 0, 0);
"\f\nGlobal Bindings", nomenu, 0, 1, 0);
/* Print the function-key-map translations under this prefix. */
- if (!NILP (Vfunction_key_map))
- describe_map_tree (Vfunction_key_map, 0, Qnil, prefix,
+ if (!NILP (current_kboard->Vlocal_function_key_map))
+ describe_map_tree (current_kboard->Vlocal_function_key_map, 0, Qnil, prefix,
"\f\nFunction key map translations", nomenu, 1, 0, 0);
UNGCPRO;
tem = shadow_lookup (shadow, kludge, Qt);
if (!NILP (tem))
{
+ /* If both bindings are keymaps, this key is a prefix key,
+ so don't say it is shadowed. */
+ if (KEYMAPP (definition) && KEYMAPP (tem))
+ ;
/* Avoid generating duplicate entries if the
- shadowed binding has the same definition. */
- if (mention_shadow && !EQ (tem, definition))
+ shadowed binding has the same definition. */
+ else if (mention_shadow && !EQ (tem, definition))
this_shadowed = 1;
else
continue;
`minor-mode-map-alist' and `minor-mode-overriding-map-alist'. */);
Vemulation_mode_map_alists = Qnil;
-
- DEFVAR_LISP ("function-key-map", &Vfunction_key_map,
- doc: /* Keymap that translates key sequences to key sequences during input.
-This is used mainly for mapping ASCII function key sequences into
-real Emacs function key events (symbols).
-
-The `read-key-sequence' function replaces any subsequence bound by
-`function-key-map' with its binding. More precisely, when the active
-keymaps have no binding for the current key sequence but
-`function-key-map' binds a suffix of the sequence to a vector or string,
-`read-key-sequence' replaces the matching suffix with its binding, and
-continues with the new sequence.
-
-If the binding is a function, it is called with one argument (the prompt)
-and its return value (a key sequence) is used.
-
-The events that come from bindings in `function-key-map' are not
-themselves looked up in `function-key-map'.
-
-For example, suppose `function-key-map' binds `ESC O P' to [f1].
-Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing
-`C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix
-key, typing `ESC O P x' would return [f1 x]. */);
- Vfunction_key_map = Fmake_sparse_keymap (Qnil);
-
- DEFVAR_LISP ("key-translation-map", &Vkey_translation_map,
- doc: /* Keymap of key translations that can override keymaps.
-This keymap works like `function-key-map', but comes after that,
-and its non-prefix bindings override ordinary bindings. */);
- Vkey_translation_map = Qnil;
-
staticpro (&Vmouse_events);
Vmouse_events = Fcons (intern ("menu-bar"),
Fcons (intern ("tool-bar"),