so that things which care (such as the menubar code) can recompute
privately-cached data when the user has changed keybindings.
*/
-int keymap_tick;
+Fixnum keymap_tick;
/* Prefixing a key with this character is the same as sending a meta bit. */
Lisp_Object Vmeta_prefix_char;
Lisp_Object Qmenu_selection;
/* Emacs compatibility */
-Lisp_Object Qdown_mouse_1, Qdown_mouse_2, Qdown_mouse_3, Qdown_mouse_4,
- Qdown_mouse_5;
-Lisp_Object Qmouse_1, Qmouse_2, Qmouse_3, Qmouse_4, Qmouse_5;
+Lisp_Object Qdown_mouse_1, Qmouse_1;
+Lisp_Object Qdown_mouse_2, Qmouse_2;
+Lisp_Object Qdown_mouse_3, Qmouse_3;
+Lisp_Object Qdown_mouse_4, Qmouse_4;
+Lisp_Object Qdown_mouse_5, Qmouse_5;
+Lisp_Object Qdown_mouse_6, Qmouse_6;
+Lisp_Object Qdown_mouse_7, Qmouse_7;
/* Kludge kludge kludge */
Lisp_Object QLFD, QTAB, QRET, QESC, QDEL, QSPC, QBS;
if ((modifiers & ~(XEMACS_MOD_CONTROL | XEMACS_MOD_META | XEMACS_MOD_SUPER
| XEMACS_MOD_HYPER | XEMACS_MOD_ALT | XEMACS_MOD_SHIFT))
!= 0)
- abort ();
+ ABORT ();
k = XKEYMAP (keymap);
Lisp_Object *prev;
if (UNBOUNDP (keys))
- abort ();
+ ABORT ();
for (prev = &new_keys, tail = new_keys;
;
&& EQ (XCAR (tem), Qautoload)
&& EQ (Fcar (Fcdr (Fcdr (Fcdr (Fcdr (tem))))), Qkeymap))
{
- struct gcpro gcpro1, gcpro2;
- GCPRO2 (tem, object);
+ /* do_autoload GCPROs both arguments */
do_autoload (tem, object);
- UNGCPRO;
}
else if (errorp)
object = wrong_type_argument (Qkeymapp, object);
*keysym = Qbutton4;
else if (EQ(*keysym, Qdown_mouse_5))
*keysym = Qbutton5;
+ else if (EQ(*keysym, Qdown_mouse_6))
+ *keysym = Qbutton6;
+ else if (EQ(*keysym, Qdown_mouse_7))
+ *keysym = Qbutton7;
else if (EQ(*keysym, Qmouse_1))
*keysym = Qbutton1up;
else if (EQ(*keysym, Qmouse_2))
*keysym = Qbutton4up;
else if (EQ(*keysym, Qmouse_5))
*keysym = Qbutton5up;
+ else if (EQ(*keysym, Qmouse_6))
+ *keysym = Qbutton6up;
+ else if (EQ(*keysym, Qmouse_7))
+ *keysym = Qbutton7up;
}
}
int
event_matches_key_specifier_p (Lisp_Event *event, Lisp_Object key_specifier)
{
- Lisp_Object event2;
+ Lisp_Object event2 = Qnil;
int retval;
struct gcpro gcpro1;
returned_value->modifiers = 0;
if (modifiers_sans_meta == XEMACS_MOD_CONTROL)
{
- if EQ (keysym, QKspace)
+ if (EQ (keysym, QKspace))
MACROLET (make_char ('@'), modifiers);
else if (!CHARP (keysym))
return;
else
{
new_keys = Qnil;
- abort ();
+ ABORT ();
}
if (EQ (keys, new_keys))
(function, keymap, sort_first))
{
/* This function can GC */
- struct gcpro gcpro1, gcpro2;
+ struct gcpro gcpro1, gcpro2, gcpro3;
+ Lisp_Object table = Qnil;
/* tolerate obviously transposed args */
if (!NILP (Fkeymapp (function)))
function = keymap;
keymap = tmp;
}
- GCPRO2 (function, keymap);
+
+ GCPRO3 (function, keymap, table);
keymap = get_keymap (keymap, 1, 1);
- map_keymap (XKEYMAP (keymap)->table, !NILP (sort_first),
+
+ /* elisp_maphash does not allow mapping functions to modify the hash
+ table being mapped over. Since map-keymap explicitly allows a
+ mapping function to modify KEYMAP, we map over a copy of the hash
+ table instead. */
+ table = Fcopy_hash_table (XKEYMAP (keymap)->table);
+
+ map_keymap (table, !NILP (sort_first),
map_keymap_mapper, LISP_TO_VOID (function));
UNGCPRO;
return Qnil;
key.modifiers = modifiers;
if (NILP (cmd))
- abort ();
+ ABORT ();
cmd = get_keymap (cmd, 0, 1);
if (!KEYMAPP (cmd))
- abort ();
+ ABORT ();
vec = make_vector (XVECTOR_LENGTH (thisseq) + 1, Qnil);
len = XVECTOR_LENGTH (thisseq);
/* OK, the key is for real */
if (target_buffer)
{
- if (!firstonly) abort ();
+ if (!firstonly) ABORT ();
format_raw_keys (so_far, keys_count + 1, target_buffer);
return make_int (1);
}
struct key_data *new = xnew_array (struct key_data, size);
memcpy ((void *)new, (const void *)c->keys_so_far,
c->keys_so_far_total_size * sizeof (struct key_data));
+ xfree (c->keys_so_far);
+ c->keys_so_far = new;
}
else
XREALLOC_ARRAY (c->keys_so_far, struct key_data, size);
defsymbol (&Qmouse_3, "mouse-3");
defsymbol (&Qmouse_4, "mouse-4");
defsymbol (&Qmouse_5, "mouse-5");
+ defsymbol (&Qmouse_6, "mouse-6");
+ defsymbol (&Qmouse_7, "mouse-7");
defsymbol (&Qdown_mouse_1, "down-mouse-1");
defsymbol (&Qdown_mouse_2, "down-mouse-2");
defsymbol (&Qdown_mouse_3, "down-mouse-3");
defsymbol (&Qdown_mouse_4, "down-mouse-4");
defsymbol (&Qdown_mouse_5, "down-mouse-5");
+ defsymbol (&Qdown_mouse_6, "down-mouse-6");
+ defsymbol (&Qdown_mouse_7, "down-mouse-7");
defsymbol (&Qmenu_selection, "menu-selection");
defsymbol (&QLFD, "LFD");
defsymbol (&QTAB, "TAB");
DEFVAR_LISP ("key-translation-map", &Vkey_translation_map /*
Keymap of key translations that can override keymaps.
-This keymap works like `function-key-map', but comes after that,
+
+This keymap works like `function-key-map', but is searched before it,
and applies even for keys that have ordinary bindings.
+
+The `read-key-sequence' function replaces any subsequence bound by
+`key-translation-map' with its binding. More precisely, when the active
+keymaps have no binding for the current key sequence but
+`key-translation-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. See `key-binding' for details.
+
+The events that come from bindings in `key-translation-map' are not
+themselves looked up in `key-translation-map'.
+
+#### FIXME: stolen from `function-key-map'; need better example.
+#### I guess you could implement a Dvorak keyboard with this?
+For example, suppose `key-translation-map' binds `ESC O P' to [f1].
+Typing `ESC O P' to `read-key-sequence' would return
+\[#<keypress-event f1>]. Typing `C-x ESC O P' would return
+\[#<keypress-event control-X> #<keypress-event f1>]. If [f1]
+were a prefix key, typing `ESC O P x' would return
+\[#<keypress-event f1> #<keypress-event x>].
*/ );
Vkey_translation_map = Qnil;