1 /************************************************************
2 * Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
4 * Permission to use, copy, modify, and distribute this
5 * software and its documentation for any purpose and without
6 * fee is hereby granted, provided that the above copyright
7 * notice appear in all copies and that both that copyright
8 * notice and this permission notice appear in supporting
9 * documentation, and that the name of Silicon Graphics not be
10 * used in advertising or publicity pertaining to distribution
11 * of the software without specific prior written permission.
12 * Silicon Graphics makes no representation about the suitability
13 * of this software for any purpose. It is provided "as is"
14 * without any express or implied warranty.
16 * SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
17 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
18 * AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
19 * GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
20 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
21 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
22 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
23 * THE USE OR PERFORMANCE OF THIS SOFTWARE.
25 ********************************************************/
28 * Copyright © 2012 Intel Corporation
30 * Permission is hereby granted, free of charge, to any person obtaining a
31 * copy of this software and associated documentation files (the "Software"),
32 * to deal in the Software without restriction, including without limitation
33 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
34 * and/or sell copies of the Software, and to permit persons to whom the
35 * Software is furnished to do so, subject to the following conditions:
37 * The above copyright notice and this permission notice (including the next
38 * paragraph) shall be included in all copies or substantial portions of the
41 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
42 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
43 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
44 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
45 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
46 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
47 * DEALINGS IN THE SOFTWARE.
49 * Author: Daniel Stone <daniel@fooishbar.org>
53 * This is a bastardised version of xkbActions.c from the X server which
54 * does not support, for the moment:
55 * - AccessX sticky/debounce/etc (will come later)
56 * - pointer keys (may come later)
57 * - key redirects (unlikely)
58 * - messages (very unlikely)
67 struct xkb_state *state;
68 union xkb_action action;
71 int (*func)(struct xkb_filter *filter, xkb_keycode_t kc,
72 enum xkb_key_direction direction);
74 struct xkb_filter *next;
78 xkb_group_index_t base_group; /**< depressed */
79 xkb_group_index_t latched_group;
80 xkb_group_index_t locked_group;
81 xkb_group_index_t group; /**< effective */
83 xkb_mod_mask_t base_mods; /**< depressed */
84 xkb_mod_mask_t latched_mods;
85 xkb_mod_mask_t locked_mods;
86 xkb_mod_mask_t mods; /**< effective */
89 * At each event, we accumulate all the needed modifications to the base
90 * modifiers, and apply them at the end. These keep track of this state.
92 xkb_mod_mask_t set_mods;
93 xkb_mod_mask_t clear_mods;
95 * We mustn't clear a base modifier if there's another depressed key
96 * which affects it, e.g. given this sequence
97 * < Left Shift down, Right Shift down, Left Shift Up >
98 * the modifier should still be set. This keeps the count.
100 int16_t mod_key_count[sizeof(xkb_mod_mask_t) * 8];
105 darray(struct xkb_filter) filters;
106 struct xkb_keymap *keymap;
109 static const union xkb_action fake = { .type = XkbSA_NoAction };
111 static const union xkb_action *
112 xkb_key_get_action(struct xkb_state *state, xkb_keycode_t kc)
114 xkb_group_index_t group;
115 xkb_level_index_t level;
116 struct xkb_key *key = NULL;
118 if (XkbKeycodeInRange(state->keymap, kc))
119 key = XkbKey(state->keymap, kc);
121 if (!key || !key->actions)
124 group = xkb_key_get_group(state, kc);
125 if (group == XKB_GROUP_INVALID)
128 level = xkb_key_get_level(state, kc, group);
129 if (level == XKB_LEVEL_INVALID)
132 return XkbKeyActionEntry(key, group, level);
135 static struct xkb_filter *
136 xkb_filter_new(struct xkb_state *state)
138 int old_size = darray_size(state->filters);
139 struct xkb_filter *filter = NULL, *iter;
141 darray_foreach(iter, state->filters) {
149 darray_resize0(state->filters, darray_size(state->filters) + 1);
150 filter = &darray_item(state->filters, old_size);
153 filter->state = state;
158 /***====================================================================***/
161 xkb_filter_group_set_func(struct xkb_filter *filter, xkb_keycode_t kc,
162 enum xkb_key_direction direction)
164 if (kc != filter->kc) {
165 filter->action.group.flags &= ~XkbSA_ClearLocks;
169 if (direction == XKB_KEY_DOWN) {
173 else if (--filter->refcnt > 0) {
177 if (filter->action.group.flags & XkbSA_GroupAbsolute)
178 filter->state->base_group = filter->action.group.group;
180 filter->state->base_group = -filter->action.group.group;
181 if (filter->action.group.flags & XkbSA_ClearLocks)
182 filter->state->locked_group = 0;
190 xkb_filter_group_set_new(struct xkb_state *state, xkb_keycode_t kc,
191 const union xkb_action *action)
193 struct xkb_filter *filter = xkb_filter_new(state);
195 if (!filter) /* WSGO */
198 filter->func = xkb_filter_group_set_func;
199 filter->action = *action;
201 if (action->group.flags & XkbSA_GroupAbsolute) {
202 filter->action.group.group = filter->state->base_group;
203 filter->state->base_group = action->group.group;
206 filter->state->base_group += action->group.group;
213 xkb_filter_group_lock_func(struct xkb_filter *filter, xkb_keycode_t kc,
214 enum xkb_key_direction direction)
216 if (kc != filter->kc)
219 if (direction == XKB_KEY_DOWN) {
223 if (--filter->refcnt > 0)
231 xkb_filter_group_lock_new(struct xkb_state *state, xkb_keycode_t kc,
232 const union xkb_action *action)
234 struct xkb_filter *filter = xkb_filter_new(state);
240 filter->func = xkb_filter_group_lock_func;
241 filter->action = *action;
243 if (action->group.flags & XkbSA_GroupAbsolute)
244 filter->state->locked_group = action->group.group;
246 filter->state->locked_group += action->group.group;
252 xkb_filter_mod_set_func(struct xkb_filter *filter, xkb_keycode_t kc,
253 enum xkb_key_direction direction)
255 if (kc != filter->kc) {
256 filter->action.mods.flags &= ~XkbSA_ClearLocks;
260 if (direction == XKB_KEY_DOWN) {
264 else if (--filter->refcnt > 0) {
268 filter->state->clear_mods = filter->action.mods.mods.mask;
269 if (filter->action.mods.flags & XkbSA_ClearLocks)
270 filter->state->locked_mods &= ~filter->action.mods.mods.mask;
278 xkb_filter_mod_set_new(struct xkb_state *state, xkb_keycode_t kc,
279 const union xkb_action *action)
281 struct xkb_filter *filter = xkb_filter_new(state);
283 if (!filter) /* WSGO */
286 filter->func = xkb_filter_mod_set_func;
287 filter->action = *action;
289 filter->state->set_mods = action->mods.mods.mask;
295 xkb_filter_mod_lock_func(struct xkb_filter *filter, xkb_keycode_t kc,
296 enum xkb_key_direction direction)
298 if (kc != filter->kc)
301 if (direction == XKB_KEY_DOWN) {
305 if (--filter->refcnt > 0)
308 filter->state->locked_mods &= ~filter->priv;
314 xkb_filter_mod_lock_new(struct xkb_state *state, xkb_keycode_t kc,
315 const union xkb_action *action)
317 struct xkb_filter *filter = xkb_filter_new(state);
319 if (!filter) /* WSGO */
323 filter->func = xkb_filter_mod_lock_func;
324 filter->action = *action;
325 filter->priv = state->locked_mods & action->mods.mods.mask;
326 state->locked_mods |= action->mods.mods.mask;
331 enum xkb_key_latch_state {
338 xkb_filter_mod_latch_func(struct xkb_filter *filter, xkb_keycode_t kc,
339 enum xkb_key_direction direction)
341 enum xkb_key_latch_state latch = filter->priv;
343 if (direction == XKB_KEY_DOWN && latch == LATCH_PENDING) {
344 /* If this is a new keypress and we're awaiting our single latched
345 * keypress, then either break the latch if any random key is pressed,
346 * or promote it to a lock or plain base set if it's the same
348 const union xkb_action *action = xkb_key_get_action(filter->state, kc);
349 if (action->type == XkbSA_LatchMods &&
350 action->mods.flags == filter->action.mods.flags &&
351 action->mods.mods.mask == filter->action.mods.mods.mask) {
352 filter->action = *action;
353 if (filter->action.mods.flags & XkbSA_LatchToLock) {
354 filter->action.type = XkbSA_LockMods;
355 filter->func = xkb_filter_mod_lock_func;
356 filter->state->locked_mods |= filter->action.mods.mods.mask;
359 filter->action.type = XkbSA_SetMods;
360 filter->func = xkb_filter_mod_set_func;
361 filter->state->set_mods = filter->action.mods.mods.mask;
364 filter->state->latched_mods &= ~filter->action.mods.mods.mask;
368 else if (((1 << action->type) & XkbSA_BreakLatch)) {
369 /* XXX: This may be totally broken, we might need to break the
370 * latch in the next run after this press? */
371 filter->state->latched_mods &= ~filter->action.mods.mods.mask;
376 else if (direction == XKB_KEY_UP && kc == filter->kc) {
377 /* Our key got released. If we've set it to clear locks, and we
378 * currently have the same modifiers locked, then release them and
379 * don't actually latch. Else we've actually hit the latching
380 * stage, so set PENDING and move our modifier from base to
382 if (latch == NO_LATCH ||
383 ((filter->action.mods.flags & XkbSA_ClearLocks) &&
384 (filter->state->locked_mods & filter->action.mods.mods.mask) ==
385 filter->action.mods.mods.mask)) {
386 /* XXX: We might be a bit overenthusiastic about clearing
387 * mods other filters have set here? */
388 if (latch == LATCH_PENDING)
389 filter->state->latched_mods &= ~filter->action.mods.mods.mask;
391 filter->state->clear_mods = filter->action.mods.mods.mask;
392 filter->state->locked_mods &= ~filter->action.mods.mods.mask;
396 latch = LATCH_PENDING;
397 filter->state->clear_mods = filter->action.mods.mods.mask;
398 filter->state->latched_mods |= filter->action.mods.mods.mask;
402 else if (direction == XKB_KEY_DOWN && latch == LATCH_KEY_DOWN) {
403 /* Someone's pressed another key while we've still got the latching
404 * key held down, so keep the base modifier state active (from
405 * xkb_filter_mod_latch_new), but don't trip the latch, just clear
406 * it as soon as the modifier gets released. */
410 filter->priv = latch;
416 xkb_filter_mod_latch_new(struct xkb_state *state, xkb_keycode_t kc,
417 const union xkb_action *action)
419 struct xkb_filter *filter = xkb_filter_new(state);
420 enum xkb_key_latch_state latch = LATCH_KEY_DOWN;
422 if (!filter) /* WSGO */
425 filter->priv = latch;
426 filter->func = xkb_filter_mod_latch_func;
427 filter->action = *action;
429 filter->state->set_mods = action->mods.mods.mask;
435 * Applies any relevant filters to the key, first from the list of filters
436 * that are currently active, then if no filter has claimed the key, possibly
437 * apply a new filter from the key action.
440 xkb_filter_apply_all(struct xkb_state *state, xkb_keycode_t kc,
441 enum xkb_key_direction direction)
443 struct xkb_filter *filter;
444 const union xkb_action *act = NULL;
447 /* First run through all the currently active filters and see if any of
448 * them have claimed this event. */
449 darray_foreach(filter, state->filters) {
452 send &= filter->func(filter, kc, direction);
455 if (!send || direction == XKB_KEY_UP)
458 act = xkb_key_get_action(state, kc);
461 send = xkb_filter_mod_set_new(state, kc, act);
463 case XkbSA_LatchMods:
464 send = xkb_filter_mod_latch_new(state, kc, act);
467 send = xkb_filter_mod_lock_new(state, kc, act);
470 send = xkb_filter_group_set_new(state, kc, act);
473 case XkbSA_LatchGroup:
474 send = xkb_filter_mod_latch_new(state, key, act);
477 case XkbSA_LockGroup:
478 send = xkb_filter_group_lock_new(state, kc, act);
485 XKB_EXPORT struct xkb_state *
486 xkb_state_new(struct xkb_keymap *keymap)
488 struct xkb_state *ret;
493 ret = calloc(sizeof(*ret), 1);
498 ret->keymap = xkb_map_ref(keymap);
503 XKB_EXPORT struct xkb_state *
504 xkb_state_ref(struct xkb_state *state)
511 xkb_state_unref(struct xkb_state *state)
514 assert(state->refcnt >= 0);
515 if (state->refcnt > 0)
518 xkb_map_unref(state->keymap);
519 darray_free(state->filters);
523 XKB_EXPORT struct xkb_keymap *
524 xkb_state_get_map(struct xkb_state *state)
526 return state->keymap;
530 * Update the LED state to match the rest of the xkb_state.
533 xkb_state_led_update_all(struct xkb_state *state)
539 for (led = 0; led < XkbNumIndicators; led++) {
540 struct xkb_indicator_map *map = &state->keymap->indicators[led];
541 xkb_mod_mask_t mod_mask = 0;
542 uint32_t group_mask = 0;
544 if (map->which_mods & XkbIM_UseAnyMods) {
545 if (map->which_mods & XkbIM_UseBase)
546 mod_mask |= state->base_mods;
547 if (map->which_mods & XkbIM_UseLatched)
548 mod_mask |= state->latched_mods;
549 if (map->which_mods & XkbIM_UseLocked)
550 mod_mask |= state->locked_mods;
551 if (map->which_mods & XkbIM_UseEffective)
552 mod_mask |= state->mods;
553 if ((map->mods.mask & mod_mask))
554 state->leds |= (1 << led);
556 if (map->which_groups & XkbIM_UseAnyGroup) {
557 if (map->which_groups & XkbIM_UseBase)
558 group_mask |= (1 << state->base_group);
559 if (map->which_groups & XkbIM_UseLatched)
560 group_mask |= (1 << state->latched_group);
561 if (map->which_groups & XkbIM_UseLocked)
562 group_mask |= (1 << state->locked_group);
563 if (map->which_groups & XkbIM_UseEffective)
564 group_mask |= (1 << state->group);
565 if ((map->groups & group_mask))
566 state->leds |= (1 << led);
569 if ((map->ctrls & state->keymap->enabled_ctrls))
570 state->leds |= (1 << led);
576 * Calculates the derived state (effective mods/group and LEDs) from an
577 * up-to-date xkb_state.
580 xkb_state_update_derived(struct xkb_state *state)
583 (state->base_mods | state->latched_mods | state->locked_mods);
584 /* FIXME: Clamp/wrap locked_group */
585 state->group = state->locked_group + state->base_group +
586 state->latched_group;
587 /* FIXME: Clamp/wrap effective group */
589 xkb_state_led_update_all(state);
593 * Given a particular key event, updates the state structure to reflect the
597 xkb_state_update_key(struct xkb_state *state, xkb_keycode_t kc,
598 enum xkb_key_direction direction)
604 state->clear_mods = 0;
606 xkb_filter_apply_all(state, kc, direction);
608 for (i = 0, bit = 1; state->set_mods; i++, bit <<= 1) {
609 if (state->set_mods & bit) {
610 state->mod_key_count[i]++;
611 state->base_mods |= bit;
612 state->set_mods &= ~bit;
616 for (i = 0, bit = 1; state->clear_mods; i++, bit <<= 1) {
617 if (state->clear_mods & bit) {
618 state->mod_key_count[i]--;
619 if (state->mod_key_count[i] <= 0) {
620 state->base_mods &= ~bit;
621 state->mod_key_count[i] = 0;
623 state->clear_mods &= ~bit;
627 xkb_state_update_derived(state);
631 * Updates the state from a set of explicit masks as gained from
632 * xkb_state_serialize_mods and xkb_state_serialize_groups. As noted in the
633 * documentation for these functions in xkbcommon.h, this round-trip is
634 * lossy, and should only be used to update a slave state mirroring the
635 * master, e.g. in a client/server window system.
638 xkb_state_update_mask(struct xkb_state *state,
639 xkb_mod_mask_t base_mods,
640 xkb_mod_mask_t latched_mods,
641 xkb_mod_mask_t locked_mods,
642 xkb_group_index_t base_group,
643 xkb_group_index_t latched_group,
644 xkb_group_index_t locked_group)
646 xkb_mod_index_t num_mods;
649 state->base_mods = 0;
650 state->latched_mods = 0;
651 state->locked_mods = 0;
652 num_mods = xkb_map_num_mods(state->keymap);
654 for (idx = 0; idx < num_mods; idx++) {
655 xkb_mod_mask_t mod = (1 << idx);
657 state->base_mods |= mod;
658 if (latched_mods & mod)
659 state->latched_mods |= mod;
660 if (locked_mods & mod)
661 state->locked_mods |= mod;
664 state->base_group = base_group;
665 state->latched_group = latched_group;
666 state->locked_group = locked_group;
668 xkb_state_update_derived(state);
672 * Serialises the requested modifier state into an xkb_mod_mask_t, with all
673 * the same disclaimers as in xkb_state_update_mask.
675 XKB_EXPORT xkb_mod_mask_t
676 xkb_state_serialize_mods(struct xkb_state *state,
677 enum xkb_state_component type)
679 xkb_mod_mask_t ret = 0;
681 if (type == XKB_STATE_EFFECTIVE)
684 if (type & XKB_STATE_DEPRESSED)
685 ret |= state->base_mods;
686 if (type & XKB_STATE_LATCHED)
687 ret |= state->latched_mods;
688 if (type & XKB_STATE_LOCKED)
689 ret |= state->locked_mods;
695 * Serialises the requested group state, with all the same disclaimers as
696 * in xkb_state_update_mask.
698 XKB_EXPORT xkb_group_index_t
699 xkb_state_serialize_group(struct xkb_state *state,
700 enum xkb_state_component type)
702 xkb_group_index_t ret = 0;
704 if (type == XKB_STATE_EFFECTIVE)
707 if (type & XKB_STATE_DEPRESSED)
708 ret += state->base_group;
709 if (type & XKB_STATE_LATCHED)
710 ret += state->latched_group;
711 if (type & XKB_STATE_LOCKED)
712 ret += state->locked_group;
718 * Returns 1 if the given modifier is active with the specified type(s), 0 if
719 * not, or -1 if the modifier is invalid.
722 xkb_state_mod_index_is_active(struct xkb_state *state,
724 enum xkb_state_component type)
728 if (idx >= xkb_map_num_mods(state->keymap))
731 if (type & XKB_STATE_DEPRESSED)
732 ret |= (state->base_mods & (1 << idx));
733 if (type & XKB_STATE_LATCHED)
734 ret |= (state->latched_mods & (1 << idx));
735 if (type & XKB_STATE_LOCKED)
736 ret |= (state->locked_mods & (1 << idx));
742 * Helper function for xkb_state_mod_indices_are_active and
743 * xkb_state_mod_names_are_active.
746 match_mod_masks(struct xkb_state *state, enum xkb_state_match match,
749 uint32_t active = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
751 if (!(match & XKB_STATE_MATCH_NON_EXCLUSIVE) && (active & ~wanted))
754 if (match & XKB_STATE_MATCH_ANY)
755 return !!(active & wanted);
757 return (active & wanted) == wanted;
763 * Returns 1 if the modifiers are active with the specified type(s), 0 if
764 * not, or -1 if any of the modifiers are invalid.
767 xkb_state_mod_indices_are_active(struct xkb_state *state,
768 enum xkb_state_component type,
769 enum xkb_state_match match,
773 xkb_mod_index_t idx = 0;
776 xkb_mod_index_t num_mods = xkb_map_num_mods(state->keymap);
780 idx = va_arg(ap, xkb_mod_index_t);
781 if (idx == XKB_MOD_INVALID)
783 if (idx >= num_mods) {
787 wanted |= (1 << idx);
794 return match_mod_masks(state, match, wanted);
798 * Returns 1 if the given modifier is active with the specified type(s), 0 if
799 * not, or -1 if the modifier is invalid.
802 xkb_state_mod_name_is_active(struct xkb_state *state, const char *name,
803 enum xkb_state_component type)
805 xkb_mod_index_t idx = xkb_map_mod_get_index(state->keymap, name);
807 if (idx == XKB_MOD_INVALID)
810 return xkb_state_mod_index_is_active(state, idx, type);
814 * Returns 1 if the modifiers are active with the specified type(s), 0 if
815 * not, or -1 if any of the modifiers are invalid.
817 XKB_EXPORT ATTR_NULL_SENTINEL int
818 xkb_state_mod_names_are_active(struct xkb_state *state,
819 enum xkb_state_component type,
820 enum xkb_state_match match,
824 xkb_mod_index_t idx = 0;
831 str = va_arg(ap, const char *);
834 idx = xkb_map_mod_get_index(state->keymap, str);
835 if (idx == XKB_MOD_INVALID) {
839 wanted |= (1 << idx);
846 return match_mod_masks(state, match, wanted);
850 * Returns 1 if the given group is active with the specified type(s), 0 if
851 * not, or -1 if the group is invalid.
854 xkb_state_group_index_is_active(struct xkb_state *state,
855 xkb_group_index_t idx,
856 enum xkb_state_component type)
860 if (idx >= xkb_map_num_groups(state->keymap))
863 if (type & XKB_STATE_DEPRESSED)
864 ret |= (state->base_group == idx);
865 if (type & XKB_STATE_LATCHED)
866 ret |= (state->latched_group == idx);
867 if (type & XKB_STATE_LOCKED)
868 ret |= (state->locked_group == idx);
874 * Returns 1 if the given modifier is active with the specified type(s), 0 if
875 * not, or -1 if the modifier is invalid.
878 xkb_state_group_name_is_active(struct xkb_state *state, const char *name,
879 enum xkb_state_component type)
881 xkb_group_index_t idx = xkb_map_group_get_index(state->keymap, name);
883 if (idx == XKB_GROUP_INVALID)
886 return xkb_state_group_index_is_active(state, idx, type);
890 * Returns 1 if the given LED is active, 0 if not, or -1 if the LED is invalid.
893 xkb_state_led_index_is_active(struct xkb_state *state, xkb_led_index_t idx)
895 if (idx >= xkb_map_num_leds(state->keymap))
898 return !!(state->leds & (1 << idx));
902 * Returns 1 if the given LED is active, 0 if not, or -1 if the LED is invalid.
905 xkb_state_led_name_is_active(struct xkb_state *state, const char *name)
907 xkb_led_index_t idx = xkb_map_led_get_index(state->keymap, name);
909 if (idx == XKB_LED_INVALID)
912 return xkb_state_led_index_is_active(state, idx);