Commit 2a2a8d7da117803667f1eaee0519db5d5e99271c
2013-08-13T18:57:43
state: apply capitalization transformation on keysyms The xkbproto spec says: http://www.x.org/releases/current/doc/kbproto/xkbproto.html#Interpreting_the_Lock_Modifier If the Lock modifier is not consumed by the symbol lookup process, routines that determine the symbol and string that correspond to an event should capitalize the result. This was not an issue until now, because most xkeyboard-config keymaps do not utilize this "feature", and specify the keysyms for the Lock modifier explicitly instead. However, some keymaps do depend on it, e.g. ch(fr) for eacute and others. The spec goes on to describe two options for doing this transformation: locale-sensitive and locale-insensitive. We opt for the latter; it is less desirable but we don't want *that* headache. Also, only xkb_state_key_get_one_sym() is changed; xkb_state_key_get_syms() is left as-is, and always reports the untransformed keysyms. This is for the following reasons: - The API doesn't allow it, since we return a const pointer directly to the keymap keysyms table and we can't transform that. - The transformation doesn't make sense for multiple-keysyms. - It can be useful for an application to get the "raw" keysyms if it wants to (e.g. maybe it wants to do the transformation itself). Finally, note that xkb_state_mod_index_is_consumed() does *not* report Lock as consumed even if it was used in the transformation. This is what Xlib does. This definitely doesn't fall under the "hard to misuse" API rule but it's the best we can do. https://bugs.freedesktop.org/show_bug.cgi?id=67167 Reported-By: Gatis Paeglis <gatis.paeglis@digia.com> Signed-off-by: Ran Benita <ran234@gmail.com>
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
diff --git a/src/state.c b/src/state.c
index bfcf1d4..e13d1fd 100644
--- a/src/state.c
+++ b/src/state.c
@@ -60,6 +60,7 @@
*/
#include "keymap.h"
+#include "keysym.h"
struct xkb_filter {
union xkb_action action;
@@ -832,13 +833,26 @@ XKB_EXPORT xkb_keysym_t
xkb_state_key_get_one_sym(struct xkb_state *state, xkb_keycode_t kc)
{
const xkb_keysym_t *syms;
+ xkb_keysym_t sym;
int num_syms;
+ xkb_mod_index_t caps;
num_syms = xkb_state_key_get_syms(state, kc, &syms);
if (num_syms != 1)
return XKB_KEY_NoSymbol;
- return syms[0];
+ sym = syms[0];
+
+ /*
+ * Perform capitalization transformation, see:
+ * http://www.x.org/releases/current/doc/kbproto/xkbproto.html#Interpreting_the_Lock_Modifier
+ */
+ caps = xkb_keymap_mod_get_index(state->keymap, XKB_MOD_NAME_CAPS);
+ if (xkb_state_mod_index_is_active(state, caps, XKB_STATE_MODS_EFFECTIVE) > 0 &&
+ xkb_state_mod_index_is_consumed(state, kc, caps) == 0)
+ sym = xkb_keysym_to_upper(sym);
+
+ return sym;
}
/**
diff --git a/test/state.c b/test/state.c
index 3521d66..d4e5aba 100644
--- a/test/state.c
+++ b/test/state.c
@@ -353,6 +353,71 @@ test_range(struct xkb_keymap *keymap)
assert(counter == xkb_keymap_max_keycode(keymap) + 1);
}
+static void
+test_caps_keysym_transformation(struct xkb_keymap *keymap)
+{
+ struct xkb_state *state = xkb_state_new(keymap);
+ xkb_mod_index_t caps, shift;
+ int nsyms;
+ xkb_keysym_t sym;
+ const xkb_keysym_t *syms;
+
+ assert(state);
+
+ /* See xkb_state_key_get_one_sym() for what's this all about. */
+
+ caps = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CAPS);
+ shift = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
+ assert(caps >= 0 && shift >= 0);
+
+ assert(xkb_state_key_get_layout(state, KEY_A + 8) == 0);
+ assert(xkb_state_key_get_layout(state, KEY_SEMICOLON + 8) == 0);
+
+ /* Without caps, no transformation. */
+ assert(xkb_state_mod_index_is_active(state, caps, XKB_STATE_MODS_EFFECTIVE) == 0);
+ assert(xkb_state_mod_index_is_active(state, shift, XKB_STATE_MODS_EFFECTIVE) == 0);
+ assert(xkb_state_key_get_level(state, KEY_A + 8, 0) == 0);
+ sym = xkb_state_key_get_one_sym(state, KEY_A + 8);
+ assert(sym == XKB_KEY_a);
+ assert(xkb_state_key_get_level(state, KEY_SEMICOLON + 8, 0) == 0);
+ sym = xkb_state_key_get_one_sym(state, KEY_SEMICOLON + 8);
+ assert(sym == XKB_KEY_eacute);
+ nsyms = xkb_state_key_get_syms(state, KEY_SEMICOLON + 8, &syms);
+ assert(nsyms == 1 && syms[0] == XKB_KEY_eacute);
+
+ /* With shift, no transformation (only different level). */
+ xkb_state_update_key(state, KEY_LEFTSHIFT + 8, XKB_KEY_DOWN);
+ assert(xkb_state_mod_index_is_active(state, caps, XKB_STATE_MODS_EFFECTIVE) == 0);
+ assert(xkb_state_mod_index_is_active(state, shift, XKB_STATE_MODS_EFFECTIVE) > 0);
+ assert(xkb_state_key_get_level(state, KEY_A + 8, 0) == 1);
+ sym = xkb_state_key_get_one_sym(state, KEY_A + 8);
+ assert(sym == XKB_KEY_A);
+ sym = xkb_state_key_get_one_sym(state, KEY_SEMICOLON + 8);
+ assert(sym == XKB_KEY_odiaeresis);
+ nsyms = xkb_state_key_get_syms(state, KEY_SEMICOLON + 8, &syms);
+ assert(nsyms == 1 && syms[0] == XKB_KEY_odiaeresis);
+ xkb_state_update_key(state, KEY_LEFTSHIFT + 8, XKB_KEY_UP);
+ assert(xkb_state_mod_index_is_active(state, shift, XKB_STATE_MODS_EFFECTIVE) == 0);
+
+ /* With caps, transform in same level, only with _get_one_sym(). */
+ xkb_state_update_key(state, KEY_CAPSLOCK + 8, XKB_KEY_DOWN);
+ xkb_state_update_key(state, KEY_CAPSLOCK + 8, XKB_KEY_UP);
+ assert(xkb_state_mod_index_is_active(state, caps, XKB_STATE_MODS_EFFECTIVE) > 0);
+ assert(xkb_state_mod_index_is_active(state, shift, XKB_STATE_MODS_EFFECTIVE) == 0);
+ assert(xkb_state_key_get_level(state, KEY_A + 8, 0) == 1);
+ sym = xkb_state_key_get_one_sym(state, KEY_A + 8);
+ assert(sym == XKB_KEY_A);
+ assert(xkb_state_key_get_level(state, KEY_SEMICOLON + 8, 0) == 0);
+ sym = xkb_state_key_get_one_sym(state, KEY_SEMICOLON + 8);
+ assert(sym == XKB_KEY_Eacute);
+ nsyms = xkb_state_key_get_syms(state, KEY_SEMICOLON + 8, &syms);
+ assert(nsyms == 1 && syms[0] == XKB_KEY_eacute);
+ xkb_state_update_key(state, KEY_LEFTSHIFT + 8, XKB_KEY_UP);
+ assert(xkb_state_mod_index_is_active(state, shift, XKB_STATE_MODS_EFFECTIVE) == 0);
+ xkb_state_update_key(state, KEY_CAPSLOCK + 8, XKB_KEY_DOWN);
+ xkb_state_update_key(state, KEY_CAPSLOCK + 8, XKB_KEY_UP);
+}
+
int
main(void)
{
@@ -376,5 +441,11 @@ main(void)
test_range(keymap);
xkb_keymap_unref(keymap);
+ keymap = test_compile_rules(context, "evdev", NULL, "ch", "fr", NULL);
+ assert(keymap);
+
+ test_caps_keysym_transformation(keymap);
+
+ xkb_keymap_unref(keymap);
xkb_context_unref(context);
}
diff --git a/xkbcommon/xkbcommon.h b/xkbcommon/xkbcommon.h
index de64dbe..e5c8f05 100644
--- a/xkbcommon/xkbcommon.h
+++ b/xkbcommon/xkbcommon.h
@@ -1205,8 +1205,9 @@ xkb_state_update_mask(struct xkb_state *state,
* key in the given keyboard state.
*
* As an extension to XKB, this function can return more than one keysym.
- * If you do not want to handle this case, you can use
- * xkb_state_key_get_one_sym().
+ * If you do not want to handle this case, you should use
+ * xkb_state_key_get_one_sym(), which additionally performs transformations
+ * which are specific to the one-keysym case.
*
* @returns The number of keysyms in the syms_out array. If no keysyms
* are produced by the key in the given keyboard state, returns 0 and sets
@@ -1222,9 +1223,10 @@ xkb_state_key_get_syms(struct xkb_state *state, xkb_keycode_t key,
* Get the single keysym obtained from pressing a particular key in a
* given keyboard state.
*
- * This function is similar to xkb_state_key_get_syms(), but with a
- * simplified interface for users which cannot or do not want to handle
- * the case where multiple keysyms are returned.
+ * This function is similar to xkb_state_key_get_syms(), but intended
+ * for users which cannot or do not want to handle the case where
+ * multiple keysyms are returned (in which case this function is
+ * preferred).
*
* @returns The keysym. If the key does not have exactly one keysym,
* returns XKB_KEY_NoSymbol