2 * Copyright © 2013 Ran Benita
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
27 * References for the lonesome traveler:
28 * Xkb protocol specification:
29 * http://www.x.org/releases/current/doc/kbproto/xkbproto.html
30 * The XCB xkb XML protocol file:
31 * /user/share/xcb/xkb.xml
32 * The XCB xkb header file:
33 * /usr/include/xcb/xkb.h
34 * The old kbproto header files:
35 * /usr/include/X11/extensions/XKB{,proto,str}.h
36 * Xlib XKB source code:
37 * <libX11>/src/xkb/XKBGetMap.c (and friends)
38 * X server XKB protocol handling:
41 * XkbGetMap(3), XkbGetCompatMap(3), etc.
44 /* Constants from /usr/include/X11/extensions/XKB.h */
45 /* XkbNumModifiers. */
46 #define NUM_REAL_MODS 8
47 /* XkbNumVirtualMods. */
50 #define NO_MODIFIER 0xff
51 /* XkbNumIndicators. */
52 #define NUM_INDICATORS 32
53 /* XkbAllIndicatorsMask. */
54 #define ALL_INDICATORS_MASK 0xffffffff
56 /* Some macros. Not very nice but it'd be worse without them. */
59 * We try not to trust the server too much and be paranoid. If we get
60 * something which we definitely shouldn't, we fail.
62 #define STRINGIFY(expr) #expr
63 #define FAIL_UNLESS(expr) do { \
65 log_err(keymap->ctx, \
66 "x11: failed to get keymap from X server: unmet condition in %s(): %s\n", \
67 __func__, STRINGIFY(expr)); \
72 #define FAIL_IF_BAD_REPLY(reply, request_name) do { \
74 log_err(keymap->ctx, \
75 "x11: failed to get keymap from X server: %s request failed\n", \
81 #define ALLOC_OR_FAIL(arr, nmemb) do { \
83 (arr) = calloc((nmemb), sizeof(*(arr))); \
91 translate_mods(uint8_t rmods, uint16_t vmods_low, uint16_t vmods_high)
93 /* We represent mod masks in a single uint32_t value, with real mods
94 * first and vmods after (though we don't make these distinctions). */
96 ((xkb_mod_mask_t) rmods) |
97 ((xkb_mod_mask_t) vmods_low << 8) |
98 ((xkb_mod_mask_t) vmods_high << 16);
101 static enum xkb_action_controls
102 translate_controls_mask(uint16_t wire)
104 enum xkb_action_controls ret = 0;
105 if (wire & XCB_XKB_BOOL_CTRL_REPEAT_KEYS)
106 ret |= CONTROL_REPEAT;
107 if (wire & XCB_XKB_BOOL_CTRL_SLOW_KEYS)
109 if (wire & XCB_XKB_BOOL_CTRL_BOUNCE_KEYS)
110 ret |= CONTROL_DEBOUNCE;
111 if (wire & XCB_XKB_BOOL_CTRL_STICKY_KEYS)
112 ret |= CONTROL_STICKY;
113 if (wire & XCB_XKB_BOOL_CTRL_MOUSE_KEYS)
114 ret |= CONTROL_MOUSEKEYS;
115 if (wire & XCB_XKB_BOOL_CTRL_MOUSE_KEYS_ACCEL)
116 ret |= CONTROL_MOUSEKEYS_ACCEL;
117 if (wire & XCB_XKB_BOOL_CTRL_ACCESS_X_KEYS)
119 if (wire & XCB_XKB_BOOL_CTRL_ACCESS_X_TIMEOUT_MASK)
120 ret |= CONTROL_AX_TIMEOUT;
121 if (wire & XCB_XKB_BOOL_CTRL_ACCESS_X_FEEDBACK_MASK)
122 ret |= CONTROL_AX_FEEDBACK;
123 if (wire & XCB_XKB_BOOL_CTRL_AUDIBLE_BELL_MASK)
125 if (wire & XCB_XKB_BOOL_CTRL_IGNORE_GROUP_LOCK_MASK)
126 ret |= CONTROL_IGNORE_GROUP_LOCK;
127 /* Some controls are not supported and don't appear here. */
132 translate_action(union xkb_action *action, const xcb_xkb_action_t *wire)
134 switch (wire->type) {
135 case XCB_XKB_SA_TYPE_SET_MODS:
136 action->type = ACTION_TYPE_MOD_SET;
138 action->mods.mods.mods = translate_mods(wire->setmods.realMods,
139 wire->setmods.vmodsLow,
140 wire->setmods.vmodsHigh);
141 action->mods.mods.mask = translate_mods(wire->setmods.mask, 0, 0);
143 if (wire->setmods.flags & XCB_XKB_SA_CLEAR_LOCKS)
144 action->mods.flags |= ACTION_LOCK_CLEAR;
145 if (wire->setmods.flags & XCB_XKB_SA_LATCH_TO_LOCK)
146 action->mods.flags |= ACTION_LATCH_TO_LOCK;
147 if (wire->setmods.flags & XCB_XKB_SA_USE_MOD_MAP_MODS)
148 action->mods.flags |= ACTION_MODS_LOOKUP_MODMAP;
151 case XCB_XKB_SA_TYPE_LATCH_MODS:
152 action->type = ACTION_TYPE_MOD_LATCH;
154 action->mods.mods.mods = translate_mods(wire->latchmods.realMods,
155 wire->latchmods.vmodsLow,
156 wire->latchmods.vmodsHigh);
157 action->mods.mods.mask = translate_mods(wire->latchmods.mask, 0, 0);
159 if (wire->latchmods.flags & XCB_XKB_SA_CLEAR_LOCKS)
160 action->mods.flags |= ACTION_LOCK_CLEAR;
161 if (wire->latchmods.flags & XCB_XKB_SA_LATCH_TO_LOCK)
162 action->mods.flags |= ACTION_LATCH_TO_LOCK;
163 if (wire->latchmods.flags & XCB_XKB_SA_USE_MOD_MAP_MODS)
164 action->mods.flags |= ACTION_MODS_LOOKUP_MODMAP;
167 case XCB_XKB_SA_TYPE_LOCK_MODS:
168 action->type = ACTION_TYPE_MOD_LOCK;
170 action->mods.mods.mods = translate_mods(wire->lockmods.realMods,
171 wire->lockmods.vmodsLow,
172 wire->lockmods.vmodsHigh);
173 action->mods.mods.mask = translate_mods(wire->lockmods.mask, 0, 0);
175 if (wire->lockmods.flags & XCB_XKB_SA_ISO_LOCK_FLAG_NO_LOCK)
176 action->mods.flags |= ACTION_LOCK_NO_LOCK;
177 if (wire->lockmods.flags & XCB_XKB_SA_ISO_LOCK_FLAG_NO_UNLOCK)
178 action->mods.flags |= ACTION_LOCK_NO_UNLOCK;
179 if (wire->lockmods.flags & XCB_XKB_SA_USE_MOD_MAP_MODS)
180 action->mods.flags |= ACTION_MODS_LOOKUP_MODMAP;
183 case XCB_XKB_SA_TYPE_SET_GROUP:
184 action->type = ACTION_TYPE_GROUP_SET;
186 action->group.group = wire->setgroup.group;
188 if (wire->setmods.flags & XCB_XKB_SA_CLEAR_LOCKS)
189 action->group.flags |= ACTION_LOCK_CLEAR;
190 if (wire->setmods.flags & XCB_XKB_SA_LATCH_TO_LOCK)
191 action->group.flags |= ACTION_LATCH_TO_LOCK;
192 if (wire->setmods.flags & XCB_XKB_SA_ISO_LOCK_FLAG_GROUP_ABSOLUTE)
193 action->group.flags |= ACTION_ABSOLUTE_SWITCH;
196 case XCB_XKB_SA_TYPE_LATCH_GROUP:
197 action->type = ACTION_TYPE_GROUP_LATCH;
199 action->group.group = wire->latchgroup.group;
201 if (wire->latchmods.flags & XCB_XKB_SA_CLEAR_LOCKS)
202 action->group.flags |= ACTION_LOCK_CLEAR;
203 if (wire->latchmods.flags & XCB_XKB_SA_LATCH_TO_LOCK)
204 action->group.flags |= ACTION_LATCH_TO_LOCK;
205 if (wire->latchmods.flags & XCB_XKB_SA_ISO_LOCK_FLAG_GROUP_ABSOLUTE)
206 action->group.flags |= ACTION_ABSOLUTE_SWITCH;
209 case XCB_XKB_SA_TYPE_LOCK_GROUP:
210 action->type = ACTION_TYPE_GROUP_LOCK;
212 action->group.group = wire->lockgroup.group;
214 if (wire->lockgroup.flags & XCB_XKB_SA_ISO_LOCK_FLAG_GROUP_ABSOLUTE)
215 action->group.flags |= ACTION_ABSOLUTE_SWITCH;
218 case XCB_XKB_SA_TYPE_MOVE_PTR:
219 action->type = ACTION_TYPE_PTR_MOVE;
221 action->ptr.x = (wire->moveptr.xLow | (wire->moveptr.xHigh << 8));
222 action->ptr.y = (wire->moveptr.yLow | (wire->moveptr.yHigh << 8));
224 if (wire->moveptr.flags & XCB_XKB_SA_MOVE_PTR_FLAG_NO_ACCELERATION)
225 action->ptr.flags |= ACTION_NO_ACCEL;
226 if (wire->moveptr.flags & XCB_XKB_SA_MOVE_PTR_FLAG_MOVE_ABSOLUTE_X)
227 action->ptr.flags |= ACTION_ABSOLUTE_X;
228 if (wire->moveptr.flags & XCB_XKB_SA_MOVE_PTR_FLAG_MOVE_ABSOLUTE_Y)
229 action->ptr.flags |= ACTION_ABSOLUTE_Y;
232 case XCB_XKB_SA_TYPE_PTR_BTN:
233 action->type = ACTION_TYPE_PTR_BUTTON;
235 action->btn.count = wire->ptrbtn.count;
236 action->btn.button = wire->ptrbtn.button;
237 action->btn.flags = 0;
240 case XCB_XKB_SA_TYPE_LOCK_PTR_BTN:
241 action->type = ACTION_TYPE_PTR_LOCK;
243 action->btn.button = wire->lockptrbtn.button;
245 if (wire->lockptrbtn.flags & XCB_XKB_SA_ISO_LOCK_FLAG_NO_LOCK)
246 action->btn.flags |= ACTION_LOCK_NO_LOCK;
247 if (wire->lockptrbtn.flags & XCB_XKB_SA_ISO_LOCK_FLAG_NO_UNLOCK)
248 action->btn.flags |= ACTION_LOCK_NO_UNLOCK;
251 case XCB_XKB_SA_TYPE_SET_PTR_DFLT:
252 action->type = ACTION_TYPE_PTR_DEFAULT;
254 action->dflt.value = wire->setptrdflt.value;
256 if (wire->setptrdflt.flags & XCB_XKB_SA_SET_PTR_DFLT_FLAG_DFLT_BTN_ABSOLUTE)
257 action->dflt.flags |= ACTION_ABSOLUTE_SWITCH;
260 case XCB_XKB_SA_TYPE_TERMINATE:
261 action->type = ACTION_TYPE_TERMINATE;
264 case XCB_XKB_SA_TYPE_SWITCH_SCREEN:
265 action->type = ACTION_TYPE_SWITCH_VT;
267 action->screen.screen = wire->switchscreen.newScreen;
269 if (wire->switchscreen.flags & XCB_XKB_SWITCH_SCREEN_FLAG_APPLICATION)
270 action->screen.flags |= ACTION_SAME_SCREEN;
271 if (wire->switchscreen.flags & XCB_XKB_SWITCH_SCREEN_FLAG_ABSOLUTE)
272 action->screen.flags |= ACTION_ABSOLUTE_SWITCH;
275 case XCB_XKB_SA_TYPE_SET_CONTROLS:
276 action->type = ACTION_TYPE_CTRL_SET;
278 const uint16_t mask = (wire->setcontrols.boolCtrlsLow |
279 (wire->setcontrols.boolCtrlsHigh << 8));
280 action->ctrls.ctrls = translate_controls_mask(mask);
283 case XCB_XKB_SA_TYPE_LOCK_CONTROLS:
284 action->type = ACTION_TYPE_CTRL_LOCK;
286 const uint16_t mask = (wire->lockcontrols.boolCtrlsLow |
287 (wire->lockcontrols.boolCtrlsHigh << 8));
288 action->ctrls.ctrls = translate_controls_mask(mask);
292 case XCB_XKB_SA_TYPE_NO_ACTION:
293 /* We don't support these. */
294 case XCB_XKB_SA_TYPE_ISO_LOCK:
295 case XCB_XKB_SA_TYPE_REDIRECT_KEY:
296 case XCB_XKB_SA_TYPE_ACTION_MESSAGE:
297 case XCB_XKB_SA_TYPE_DEVICE_BTN:
298 case XCB_XKB_SA_TYPE_LOCK_DEVICE_BTN:
299 case XCB_XKB_SA_TYPE_DEVICE_VALUATOR:
300 action->type = ACTION_TYPE_NONE;
306 get_types(struct xkb_keymap *keymap, xcb_connection_t *conn,
307 xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
309 int types_length = xcb_xkb_get_map_map_types_rtrn_length(reply, map);
310 xcb_xkb_key_type_iterator_t types_iter =
311 xcb_xkb_get_map_map_types_rtrn_iterator(reply, map);
313 FAIL_UNLESS(reply->firstType == 0);
315 keymap->num_types = reply->nTypes;
316 ALLOC_OR_FAIL(keymap->types, keymap->num_types);
318 for (int i = 0; i < types_length; i++) {
319 xcb_xkb_key_type_t *wire_type = types_iter.data;
320 struct xkb_key_type *type = &keymap->types[i];
322 FAIL_UNLESS(wire_type->numLevels > 0);
324 type->mods.mods = translate_mods(wire_type->mods_mods,
325 wire_type->mods_vmods, 0);
326 type->mods.mask = translate_mods(wire_type->mods_mask, 0, 0);
327 type->num_levels = wire_type->numLevels;
330 int entries_length = xcb_xkb_key_type_map_length(wire_type);
331 xcb_xkb_kt_map_entry_iterator_t entries_iter =
332 xcb_xkb_key_type_map_iterator(wire_type);
334 type->num_entries = wire_type->nMapEntries;
335 ALLOC_OR_FAIL(type->entries, type->num_entries);
337 for (int j = 0; j < entries_length; j++) {
338 xcb_xkb_kt_map_entry_t *wire_entry = entries_iter.data;
339 struct xkb_key_type_entry *entry = &type->entries[j];
341 FAIL_UNLESS(wire_entry->level < type->num_levels);
343 entry->level = wire_entry->level;
344 entry->mods.mods = translate_mods(wire_entry->mods_mods,
345 wire_entry->mods_vmods, 0);
346 entry->mods.mask = translate_mods(wire_entry->mods_mask, 0, 0);
348 xcb_xkb_kt_map_entry_next(&entries_iter);
353 int preserves_length = xcb_xkb_key_type_preserve_length(wire_type);
354 xcb_xkb_mod_def_iterator_t preserves_iter =
355 xcb_xkb_key_type_preserve_iterator(wire_type);
357 FAIL_UNLESS(preserves_length <= type->num_entries);
359 for (int j = 0; j < preserves_length; j++) {
360 xcb_xkb_mod_def_t *wire_preserve = preserves_iter.data;
361 struct xkb_key_type_entry *entry = &type->entries[j];
363 entry->preserve.mods = translate_mods(wire_preserve->realMods,
364 wire_preserve->vmods, 0);
365 entry->preserve.mask = translate_mods(wire_preserve->mask, 0, 0);
367 xcb_xkb_mod_def_next(&preserves_iter);
371 xcb_xkb_key_type_next(&types_iter);
381 get_sym_maps(struct xkb_keymap *keymap, xcb_connection_t *conn,
382 xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
384 int sym_maps_length = xcb_xkb_get_map_map_syms_rtrn_length(reply, map);
385 xcb_xkb_key_sym_map_iterator_t sym_maps_iter =
386 xcb_xkb_get_map_map_syms_rtrn_iterator(reply, map);
388 FAIL_UNLESS(reply->minKeyCode <= reply->maxKeyCode);
389 FAIL_UNLESS(reply->firstKeySym >= reply->minKeyCode);
390 FAIL_UNLESS(reply->firstKeySym + reply->nKeySyms <= reply->maxKeyCode + 1);
392 keymap->min_key_code = reply->minKeyCode;
393 keymap->max_key_code = reply->maxKeyCode;
395 ALLOC_OR_FAIL(keymap->keys, keymap->max_key_code + 1);
397 for (xkb_keycode_t kc = keymap->min_key_code; kc <= keymap->max_key_code; kc++)
398 keymap->keys[kc].keycode = kc;
400 for (int i = 0; i < sym_maps_length; i++) {
401 xcb_xkb_key_sym_map_t *wire_sym_map = sym_maps_iter.data;
402 struct xkb_key *key = &keymap->keys[reply->firstKeySym + i];
404 key->num_groups = wire_sym_map->groupInfo & 0x0f;
405 FAIL_UNLESS(key->num_groups <= ARRAY_SIZE(wire_sym_map->kt_index));
406 ALLOC_OR_FAIL(key->groups, key->num_groups);
408 for (int j = 0; j < key->num_groups; j++) {
409 FAIL_UNLESS(wire_sym_map->kt_index[j] < keymap->num_types);
410 key->groups[j].type = &keymap->types[wire_sym_map->kt_index[j]];
412 ALLOC_OR_FAIL(key->groups[j].levels, key->groups[j].type->num_levels);
415 key->out_of_range_group_number = (wire_sym_map->groupInfo & 0x30) >> 4;
417 FAIL_UNLESS(key->out_of_range_group_number <= key->num_groups);
419 if (wire_sym_map->groupInfo & XCB_XKB_GROUPS_WRAP_CLAMP_INTO_RANGE)
420 key->out_of_range_group_action = RANGE_SATURATE;
421 else if (wire_sym_map->groupInfo & XCB_XKB_GROUPS_WRAP_REDIRECT_INTO_RANGE)
422 key->out_of_range_group_action = RANGE_REDIRECT;
424 key->out_of_range_group_action = RANGE_WRAP;
427 int syms_length = xcb_xkb_key_sym_map_syms_length(wire_sym_map);
428 xcb_keysym_t *syms_iter = xcb_xkb_key_sym_map_syms(wire_sym_map);
430 FAIL_UNLESS(syms_length == wire_sym_map->width * key->num_groups);
432 for (int j = 0; j < syms_length; j++) {
433 xcb_keysym_t wire_keysym = *syms_iter;
434 const xkb_layout_index_t group = j / wire_sym_map->width;
435 const xkb_level_index_t level = j % wire_sym_map->width;
437 if (level < key->groups[group].type->num_levels &&
438 wire_keysym != XKB_KEY_NoSymbol) {
439 key->groups[group].levels[level].num_syms = 1;
440 key->groups[group].levels[level].u.sym = wire_keysym;
447 xcb_xkb_key_sym_map_next(&sym_maps_iter);
457 get_actions(struct xkb_keymap *keymap, xcb_connection_t *conn,
458 xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
460 int acts_count_length =
461 xcb_xkb_get_map_map_acts_rtrn_count_length(reply, map);
462 uint8_t *acts_count_iter = xcb_xkb_get_map_map_acts_rtrn_count(map);
463 xcb_xkb_action_iterator_t acts_iter =
464 xcb_xkb_get_map_map_acts_rtrn_acts_iterator(reply, map);
465 xcb_xkb_key_sym_map_iterator_t sym_maps_iter =
466 xcb_xkb_get_map_map_syms_rtrn_iterator(reply, map);
468 FAIL_UNLESS(reply->firstKeyAction == keymap->min_key_code);
469 FAIL_UNLESS(reply->firstKeyAction + reply->nKeyActions ==
470 keymap->max_key_code + 1);
472 for (int i = 0; i < acts_count_length; i++) {
473 xcb_xkb_key_sym_map_t *wire_sym_map = sym_maps_iter.data;
474 int syms_length = xcb_xkb_key_sym_map_syms_length(wire_sym_map);
475 uint8_t wire_count = *acts_count_iter;
476 struct xkb_key *key = &keymap->keys[reply->firstKeyAction + i];
478 FAIL_UNLESS(wire_count == 0 || wire_count == syms_length);
480 for (int j = 0; j < wire_count; j++) {
481 xcb_xkb_action_t *wire_action = acts_iter.data;
482 const xkb_layout_index_t group = j / wire_sym_map->width;
483 const xkb_level_index_t level = j % wire_sym_map->width;
485 if (level < key->groups[group].type->num_levels) {
486 union xkb_action *action =
487 &key->groups[group].levels[level].action;
489 translate_action(action, wire_action);
492 xcb_xkb_action_next(&acts_iter);
496 xcb_xkb_key_sym_map_next(&sym_maps_iter);
506 get_vmods(struct xkb_keymap *keymap, xcb_connection_t *conn,
507 xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
509 uint8_t *iter = xcb_xkb_get_map_map_vmods_rtrn(map);
511 darray_resize0(keymap->mods,
512 NUM_REAL_MODS + msb_pos(reply->virtualMods));
514 for (int i = 0; i < NUM_VMODS; i++) {
515 if (reply->virtualMods & (1 << i)) {
516 uint8_t wire = *iter;
517 struct xkb_mod *mod = &darray_item(keymap->mods, NUM_REAL_MODS + i);
519 mod->type = MOD_VIRT;
520 mod->mapping = translate_mods(wire, 0, 0);
530 get_explicits(struct xkb_keymap *keymap, xcb_connection_t *conn,
531 xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
533 int length = xcb_xkb_get_map_map_explicit_rtrn_length(reply, map);
534 xcb_xkb_set_explicit_iterator_t iter =
535 xcb_xkb_get_map_map_explicit_rtrn_iterator(reply, map);
537 for (int i = 0; i < length; i++) {
538 xcb_xkb_set_explicit_t *wire = iter.data;
539 struct xkb_key *key = &keymap->keys[wire->keycode];
541 FAIL_UNLESS(wire->keycode >= keymap->min_key_code &&
542 wire->keycode <= keymap->max_key_code);
544 if ((wire->explicit & XCB_XKB_EXPLICIT_KEY_TYPE_1) &&
546 key->groups[0].explicit_type = true;
547 if ((wire->explicit & XCB_XKB_EXPLICIT_KEY_TYPE_2) &&
549 key->groups[1].explicit_type = true;
550 if ((wire->explicit & XCB_XKB_EXPLICIT_KEY_TYPE_3) &&
552 key->groups[2].explicit_type = true;
553 if ((wire->explicit & XCB_XKB_EXPLICIT_KEY_TYPE_4) &&
555 key->groups[3].explicit_type = true;
556 if (wire->explicit & XCB_XKB_EXPLICIT_INTERPRET)
557 key->explicit |= EXPLICIT_INTERP;
558 if (wire->explicit & XCB_XKB_EXPLICIT_AUTO_REPEAT)
559 key->explicit |= EXPLICIT_REPEAT;
560 if (wire->explicit & XCB_XKB_EXPLICIT_V_MOD_MAP)
561 key->explicit |= EXPLICIT_VMODMAP;
563 xcb_xkb_set_explicit_next(&iter);
573 get_modmaps(struct xkb_keymap *keymap, xcb_connection_t *conn,
574 xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
576 int length = xcb_xkb_get_map_map_modmap_rtrn_length(reply, map);
577 xcb_xkb_key_mod_map_iterator_t iter =
578 xcb_xkb_get_map_map_modmap_rtrn_iterator(reply, map);
580 for (int i = 0; i < length; i++) {
581 xcb_xkb_key_mod_map_t *wire = iter.data;
582 struct xkb_key *key = &keymap->keys[wire->keycode];
584 FAIL_UNLESS(wire->keycode >= keymap->min_key_code &&
585 wire->keycode <= keymap->max_key_code);
587 key->modmap = wire->mods;
589 xcb_xkb_key_mod_map_next(&iter);
599 get_vmodmaps(struct xkb_keymap *keymap, xcb_connection_t *conn,
600 xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
602 int length = xcb_xkb_get_map_map_vmodmap_rtrn_length(reply, map);
603 xcb_xkb_key_v_mod_map_iterator_t iter =
604 xcb_xkb_get_map_map_vmodmap_rtrn_iterator(reply, map);
606 for (int i = 0; i < length; i++) {
607 xcb_xkb_key_v_mod_map_t *wire = iter.data;
608 struct xkb_key *key = &keymap->keys[wire->keycode];
610 FAIL_UNLESS(wire->keycode >= keymap->min_key_code &&
611 wire->keycode <= keymap->max_key_code);
613 key->vmodmap = translate_mods(0, wire->vmods, 0);
615 xcb_xkb_key_v_mod_map_next(&iter);
625 get_map(struct xkb_keymap *keymap, xcb_connection_t *conn, uint16_t device_id)
627 static const xcb_xkb_map_part_t required_components =
628 (XCB_XKB_MAP_PART_KEY_TYPES |
629 XCB_XKB_MAP_PART_KEY_SYMS |
630 XCB_XKB_MAP_PART_MODIFIER_MAP |
631 XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS |
632 XCB_XKB_MAP_PART_KEY_ACTIONS |
633 XCB_XKB_MAP_PART_VIRTUAL_MODS |
634 XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP);
636 xcb_xkb_get_map_cookie_t cookie =
637 xcb_xkb_get_map(conn, device_id, required_components,
638 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
639 xcb_xkb_get_map_reply_t *reply = xcb_xkb_get_map_reply(conn, cookie, NULL);
640 xcb_xkb_get_map_map_t map;
642 FAIL_IF_BAD_REPLY(reply, "XkbGetMap");
644 if ((reply->present & required_components) != required_components)
647 xcb_xkb_get_map_map_unpack(xcb_xkb_get_map_map(reply),
652 reply->totalKeyBehaviors,
654 reply->totalKeyExplicit,
655 reply->totalModMapKeys,
656 reply->totalVModMapKeys,
660 if (!get_types(keymap, conn, reply, &map) ||
661 !get_sym_maps(keymap, conn, reply, &map) ||
662 !get_actions(keymap, conn, reply, &map) ||
663 !get_vmods(keymap, conn, reply, &map) ||
664 !get_explicits(keymap, conn, reply, &map) ||
665 !get_modmaps(keymap, conn, reply, &map) ||
666 !get_vmodmaps(keymap, conn, reply, &map))
678 get_indicators(struct xkb_keymap *keymap, xcb_connection_t *conn,
679 xcb_xkb_get_indicator_map_reply_t *reply)
681 xcb_xkb_indicator_map_iterator_t iter =
682 xcb_xkb_get_indicator_map_maps_iterator(reply);
684 darray_resize0(keymap->leds, msb_pos(reply->which));
686 for (int i = 0; i < NUM_INDICATORS; i++) {
687 if (reply->which & (1 << i)) {
688 xcb_xkb_indicator_map_t *wire = iter.data;
689 struct xkb_led *led = &darray_item(keymap->leds, i);
691 if (wire->whichGroups & XCB_XKB_IM_GROUPS_WHICH_USE_BASE)
692 led->which_groups |= XKB_STATE_LAYOUT_DEPRESSED;
693 if (wire->whichGroups & XCB_XKB_IM_GROUPS_WHICH_USE_LATCHED)
694 led->which_groups |= XKB_STATE_LAYOUT_LATCHED;
695 if (wire->whichGroups & XCB_XKB_IM_GROUPS_WHICH_USE_LOCKED)
696 led->which_groups |= XKB_STATE_LAYOUT_LOCKED;
697 if (wire->whichGroups & XCB_XKB_IM_GROUPS_WHICH_USE_EFFECTIVE)
698 led->which_groups |= XKB_STATE_LAYOUT_EFFECTIVE;
699 if (wire->whichGroups & XCB_XKB_IM_GROUPS_WHICH_USE_COMPAT)
700 led->which_groups |= XKB_STATE_LAYOUT_EFFECTIVE;
702 led->groups = wire->groups;
704 if (wire->whichMods & XCB_XKB_IM_MODS_WHICH_USE_BASE)
705 led->which_mods |= XKB_STATE_MODS_DEPRESSED;
706 if (wire->whichMods & XCB_XKB_IM_MODS_WHICH_USE_LATCHED)
707 led->which_mods |= XKB_STATE_MODS_LATCHED;
708 if (wire->whichMods & XCB_XKB_IM_MODS_WHICH_USE_LOCKED)
709 led->which_mods |= XKB_STATE_MODS_LOCKED;
710 if (wire->whichMods & XCB_XKB_IM_MODS_WHICH_USE_EFFECTIVE)
711 led->which_mods |= XKB_STATE_MODS_EFFECTIVE;
712 if (wire->whichMods & XCB_XKB_IM_MODS_WHICH_USE_COMPAT)
713 led->which_mods |= XKB_STATE_MODS_EFFECTIVE;
715 led->mods.mods = translate_mods(wire->realMods, wire->vmods, 0);
716 led->mods.mask = translate_mods(wire->mods, 0, 0);
718 led->ctrls = translate_controls_mask(wire->ctrls);
720 xcb_xkb_indicator_map_next(&iter);
728 get_indicator_map(struct xkb_keymap *keymap, xcb_connection_t *conn,
731 xcb_xkb_get_indicator_map_cookie_t cookie =
732 xcb_xkb_get_indicator_map(conn, device_id, ALL_INDICATORS_MASK);
733 xcb_xkb_get_indicator_map_reply_t *reply =
734 xcb_xkb_get_indicator_map_reply(conn, cookie, NULL);
736 FAIL_IF_BAD_REPLY(reply, "XkbGetIndicatorMap");
738 if (!get_indicators(keymap, conn, reply))
750 get_sym_interprets(struct xkb_keymap *keymap, xcb_connection_t *conn,
751 xcb_xkb_get_compat_map_reply_t *reply)
753 int length = xcb_xkb_get_compat_map_si_rtrn_length(reply);
754 xcb_xkb_sym_interpret_iterator_t iter =
755 xcb_xkb_get_compat_map_si_rtrn_iterator(reply);
757 FAIL_UNLESS(reply->firstSIRtrn == 0);
758 FAIL_UNLESS(reply->nSIRtrn == reply->nTotalSI);
760 keymap->num_sym_interprets = reply->nSIRtrn;
761 ALLOC_OR_FAIL(keymap->sym_interprets, keymap->num_sym_interprets);
763 for (int i = 0; i < length; i++) {
764 xcb_xkb_sym_interpret_t *wire = iter.data;
765 struct xkb_sym_interpret *sym_interpret = &keymap->sym_interprets[i];
767 sym_interpret->sym = wire->sym;
769 switch (wire->match & XCB_XKB_SYM_INTERP_MATCH_OP_MASK) {
770 case XCB_XKB_SYM_INTERPRET_MATCH_NONE_OF:
771 sym_interpret->match = MATCH_NONE;
773 case XCB_XKB_SYM_INTERPRET_MATCH_ANY_OF_OR_NONE:
774 sym_interpret->match = MATCH_ANY_OR_NONE;
776 case XCB_XKB_SYM_INTERPRET_MATCH_ANY_OF:
777 sym_interpret->match = MATCH_ANY;
779 case XCB_XKB_SYM_INTERPRET_MATCH_ALL_OF:
780 sym_interpret->match = MATCH_ALL;
782 case XCB_XKB_SYM_INTERPRET_MATCH_EXACTLY:
783 sym_interpret->match = MATCH_EXACTLY;
787 sym_interpret->level_one_only =
788 !!(wire->match & XCB_XKB_SYM_INTERP_MATCH_LEVEL_ONE_ONLY);
789 sym_interpret->mods = wire->mods;
791 if (wire->virtualMod == NO_MODIFIER)
792 sym_interpret->virtual_mod = XKB_MOD_INVALID;
794 sym_interpret->virtual_mod = NUM_REAL_MODS + wire->virtualMod;
796 sym_interpret->repeat = !!(wire->flags & 0x01);
797 translate_action(&sym_interpret->action,
798 (xcb_xkb_action_t *) &wire->action);
800 xcb_xkb_sym_interpret_next(&iter);
810 get_compat_map(struct xkb_keymap *keymap, xcb_connection_t *conn,
813 xcb_xkb_get_compat_map_cookie_t cookie =
814 xcb_xkb_get_compat_map(conn, device_id, 0, true, 0, 0);
815 xcb_xkb_get_compat_map_reply_t *reply =
816 xcb_xkb_get_compat_map_reply(conn, cookie, NULL);
818 FAIL_IF_BAD_REPLY(reply, "XkbGetCompatMap");
820 if (!get_sym_interprets(keymap, conn, reply))
832 get_type_names(struct xkb_keymap *keymap, xcb_connection_t *conn,
833 xcb_xkb_get_names_reply_t *reply,
834 xcb_xkb_get_names_value_list_t *list)
836 int key_type_names_length =
837 xcb_xkb_get_names_value_list_type_names_length(reply, list);
838 xcb_atom_t *key_type_names_iter =
839 xcb_xkb_get_names_value_list_type_names(list);
840 int n_levels_per_type_length =
841 xcb_xkb_get_names_value_list_n_levels_per_type_length(reply, list);
842 uint8_t *n_levels_per_type_iter =
843 xcb_xkb_get_names_value_list_n_levels_per_type(list);
844 xcb_atom_t *kt_level_names_iter =
845 xcb_xkb_get_names_value_list_kt_level_names(list);
847 FAIL_UNLESS(reply->nTypes == keymap->num_types);
848 FAIL_UNLESS(key_type_names_length == n_levels_per_type_length);
850 for (int i = 0; i < key_type_names_length; i++) {
851 xcb_atom_t wire_type_name = *key_type_names_iter;
852 uint8_t wire_num_levels = *n_levels_per_type_iter;
853 struct xkb_key_type *type = &keymap->types[i];
855 /* Levels must have names. */
856 FAIL_UNLESS(type->num_levels == wire_num_levels);
858 ALLOC_OR_FAIL(type->level_names, type->num_levels);
860 if (!adopt_atom(keymap->ctx, conn, wire_type_name, &type->name))
863 if (!adopt_atoms(keymap->ctx, conn,
864 kt_level_names_iter, type->level_names,
868 kt_level_names_iter += wire_num_levels;
869 key_type_names_iter++;
870 n_levels_per_type_iter++;
880 get_indicator_names(struct xkb_keymap *keymap, xcb_connection_t *conn,
881 xcb_xkb_get_names_reply_t *reply,
882 xcb_xkb_get_names_value_list_t *list)
884 xcb_atom_t *iter = xcb_xkb_get_names_value_list_indicator_names(list);
886 FAIL_UNLESS(msb_pos(reply->indicators) <= darray_size(keymap->leds));
888 for (int i = 0; i < NUM_INDICATORS; i++) {
889 if (reply->indicators & (1 << i)) {
890 xcb_atom_t wire = *iter;
891 struct xkb_led *led = &darray_item(keymap->leds, i);
893 if (!adopt_atom(keymap->ctx, conn, wire, &led->name))
907 get_vmod_names(struct xkb_keymap *keymap, xcb_connection_t *conn,
908 xcb_xkb_get_names_reply_t *reply,
909 xcb_xkb_get_names_value_list_t *list)
911 xcb_atom_t *iter = xcb_xkb_get_names_value_list_virtual_mod_names(list);
914 * GetMap's reply->virtualMods is always 0xffff. This one really
915 * tells us which vmods exist (a vmod must have a name), so we fix
918 darray_resize0(keymap->mods, NUM_REAL_MODS + msb_pos(reply->virtualMods));
920 for (int i = 0; i < NUM_VMODS; i++) {
921 if (reply->virtualMods & (1 << i)) {
922 xcb_atom_t wire = *iter;
923 struct xkb_mod *mod = &darray_item(keymap->mods, NUM_REAL_MODS + i);
925 if (!adopt_atom(keymap->ctx, conn, wire, &mod->name))
936 get_group_names(struct xkb_keymap *keymap, xcb_connection_t *conn,
937 xcb_xkb_get_names_reply_t *reply,
938 xcb_xkb_get_names_value_list_t *list)
940 int length = xcb_xkb_get_names_value_list_groups_length(reply, list);
941 xcb_atom_t *iter = xcb_xkb_get_names_value_list_groups(list);
943 keymap->num_group_names = msb_pos(reply->groupNames);
944 ALLOC_OR_FAIL(keymap->group_names, keymap->num_group_names);
946 if (!adopt_atoms(keymap->ctx, conn,
947 iter, keymap->group_names, length))
957 get_key_names(struct xkb_keymap *keymap, xcb_connection_t *conn,
958 xcb_xkb_get_names_reply_t *reply,
959 xcb_xkb_get_names_value_list_t *list)
961 int length = xcb_xkb_get_names_value_list_key_names_length(reply, list);
962 xcb_xkb_key_name_iterator_t iter =
963 xcb_xkb_get_names_value_list_key_names_iterator(reply, list);
965 FAIL_UNLESS(reply->minKeyCode == keymap->min_key_code);
966 FAIL_UNLESS(reply->maxKeyCode == keymap->max_key_code);
967 FAIL_UNLESS(reply->firstKey == keymap->min_key_code);
968 FAIL_UNLESS(reply->firstKey + reply->nKeys - 1 == keymap->max_key_code);
970 for (int i = 0; i < length; i++) {
971 xcb_xkb_key_name_t *wire = iter.data;
972 xkb_atom_t *key_name = &keymap->keys[reply->firstKey + i].name;
974 if (wire->name[0] == '\0') {
975 *key_name = XKB_ATOM_NONE;
978 *key_name = xkb_atom_intern(keymap->ctx, wire->name,
980 XCB_XKB_CONST_KEY_NAME_LENGTH));
985 xcb_xkb_key_name_next(&iter);
995 get_aliases(struct xkb_keymap *keymap, xcb_connection_t *conn,
996 xcb_xkb_get_names_reply_t *reply,
997 xcb_xkb_get_names_value_list_t *list)
999 int length = xcb_xkb_get_names_value_list_key_aliases_length(reply, list);
1000 xcb_xkb_key_alias_iterator_t iter =
1001 xcb_xkb_get_names_value_list_key_aliases_iterator(reply, list);
1003 keymap->num_key_aliases = reply->nKeyAliases;
1004 ALLOC_OR_FAIL(keymap->key_aliases, keymap->num_key_aliases);
1006 for (int i = 0; i < length; i++) {
1007 xcb_xkb_key_alias_t *wire = iter.data;
1008 struct xkb_key_alias *alias = &keymap->key_aliases[i];
1011 xkb_atom_intern(keymap->ctx, wire->real,
1012 strnlen(wire->real, XCB_XKB_CONST_KEY_NAME_LENGTH));
1014 xkb_atom_intern(keymap->ctx, wire->alias,
1015 strnlen(wire->alias, XCB_XKB_CONST_KEY_NAME_LENGTH));
1016 if (!alias->real || !alias->alias)
1019 xcb_xkb_key_alias_next(&iter);
1029 get_names(struct xkb_keymap *keymap, xcb_connection_t *conn,
1032 static const xcb_xkb_name_detail_t required_names =
1033 (XCB_XKB_NAME_DETAIL_KEYCODES |
1034 XCB_XKB_NAME_DETAIL_SYMBOLS |
1035 XCB_XKB_NAME_DETAIL_TYPES |
1036 XCB_XKB_NAME_DETAIL_COMPAT |
1037 XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES |
1038 XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES |
1039 XCB_XKB_NAME_DETAIL_INDICATOR_NAMES |
1040 XCB_XKB_NAME_DETAIL_KEY_NAMES |
1041 XCB_XKB_NAME_DETAIL_KEY_ALIASES |
1042 XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES |
1043 XCB_XKB_NAME_DETAIL_GROUP_NAMES);
1045 xcb_xkb_get_names_cookie_t cookie =
1046 xcb_xkb_get_names(conn, device_id, required_names);
1047 xcb_xkb_get_names_reply_t *reply =
1048 xcb_xkb_get_names_reply(conn, cookie, NULL);
1049 xcb_xkb_get_names_value_list_t list;
1051 FAIL_IF_BAD_REPLY(reply, "XkbGetNames");
1053 if ((reply->which & required_names) != required_names)
1056 xcb_xkb_get_names_value_list_unpack(xcb_xkb_get_names_value_list(reply),
1063 reply->nRadioGroups,
1067 if (!get_atom_name(conn, list.keycodesName, &keymap->keycodes_section_name) ||
1068 !get_atom_name(conn, list.symbolsName, &keymap->symbols_section_name) ||
1069 !get_atom_name(conn, list.typesName, &keymap->types_section_name) ||
1070 !get_atom_name(conn, list.compatName, &keymap->compat_section_name) ||
1071 !get_type_names(keymap, conn, reply, &list) ||
1072 !get_indicator_names(keymap, conn, reply, &list) ||
1073 !get_vmod_names(keymap, conn, reply, &list) ||
1074 !get_group_names(keymap, conn, reply, &list) ||
1075 !get_key_names(keymap, conn, reply, &list) ||
1076 !get_aliases(keymap, conn, reply, &list))
1079 XkbEscapeMapName(keymap->keycodes_section_name);
1080 XkbEscapeMapName(keymap->symbols_section_name);
1081 XkbEscapeMapName(keymap->types_section_name);
1082 XkbEscapeMapName(keymap->compat_section_name);
1093 get_controls(struct xkb_keymap *keymap, xcb_connection_t *conn,
1096 xcb_xkb_get_controls_cookie_t cookie =
1097 xcb_xkb_get_controls(conn, device_id);
1098 xcb_xkb_get_controls_reply_t *reply =
1099 xcb_xkb_get_controls_reply(conn, cookie, NULL);
1101 FAIL_IF_BAD_REPLY(reply, "XkbGetControls");
1103 keymap->enabled_ctrls = translate_controls_mask(reply->enabledControls);
1104 keymap->num_groups = reply->numGroups;
1106 FAIL_UNLESS(keymap->max_key_code < XCB_XKB_CONST_PER_KEY_BIT_ARRAY_SIZE * 8);
1108 for (int i = keymap->min_key_code; i <= keymap->max_key_code; i++)
1109 keymap->keys[i].repeats = !!(reply->perKeyRepeat[i / 8] & (1 << (i % 8)));
1119 XKB_EXPORT struct xkb_keymap *
1120 xkb_x11_keymap_new_from_device(struct xkb_context *ctx,
1121 xcb_connection_t *conn,
1123 enum xkb_keymap_compile_flags flags)
1125 struct xkb_keymap *keymap;
1126 const enum xkb_keymap_format format = XKB_KEYMAP_FORMAT_TEXT_V1;
1128 if (flags & ~(XKB_MAP_COMPILE_PLACEHOLDER)) {
1129 log_err_func(ctx, "unrecognized flags: %#x\n", flags);
1133 if (device_id < 0 || device_id > 255) {
1134 log_err_func(ctx, "illegal device ID: %d\n", device_id);
1138 keymap = xkb_keymap_new(ctx, format, flags);
1142 if (!get_map(keymap, conn, device_id) ||
1143 !get_indicator_map(keymap, conn, device_id) ||
1144 !get_compat_map(keymap, conn, device_id) ||
1145 !get_names(keymap, conn, device_id) ||
1146 !get_controls(keymap, conn, device_id)) {
1147 xkb_keymap_unref(keymap);