Lines Matching refs:state
70 bool (*func)(struct xkb_state *state,
94 * Before updating the state, we keep a copy of just this struct. This
95 * allows us to report which components of the state have changed.
101 * modifiers, and apply them at the end. These keep track of this state.
120 get_entry_for_key_state(struct xkb_state *state, const struct xkb_key *key,
124 xkb_mod_mask_t active_mods = state->components.mods & type->mods.mask;
143 * Returns the level to use for the given key and state, or
147 xkb_state_key_get_level(struct xkb_state *state, xkb_keycode_t kc,
150 const struct xkb_key *key = XkbKey(state->keymap, kc);
157 entry = get_entry_for_key_state(state, key, layout);
202 * Returns the layout to use for the given key and state, taking
206 xkb_state_key_get_layout(struct xkb_state *state, xkb_keycode_t kc)
208 const struct xkb_key *key = XkbKey(state->keymap, kc);
213 return XkbWrapGroupIntoRange(state->components.group, key->num_groups,
221 xkb_key_get_action(struct xkb_state *state, const struct xkb_key *key)
226 layout = xkb_state_key_get_layout(state, key->keycode);
230 level = xkb_state_key_get_level(state, key->keycode, layout);
238 xkb_filter_new(struct xkb_state *state)
242 darray_foreach(iter, state->filters) {
250 darray_resize0(state->filters, darray_size(state->filters) + 1);
251 filter = &darray_item(state->filters, darray_size(state->filters) -1);
261 xkb_filter_group_set_func(struct xkb_state *state,
279 state->components.base_group = filter->priv;
282 state->components.locked_group = 0;
289 xkb_filter_group_set_new(struct xkb_state *state, struct xkb_filter *filter)
291 filter->priv = state->components.base_group;
293 state->components.base_group = filter->action.group.group;
295 state->components.base_group += filter->action.group.group;
299 xkb_filter_group_lock_func(struct xkb_state *state,
319 xkb_filter_group_lock_new(struct xkb_state *state, struct xkb_filter *filter)
322 state->components.locked_group = filter->action.group.group;
324 state->components.locked_group += filter->action.group.group;
328 xkb_filter_mod_set_func(struct xkb_state *state,
346 state->clear_mods = filter->action.mods.mods.mask;
348 state->components.locked_mods &= ~filter->action.mods.mods.mask;
355 xkb_filter_mod_set_new(struct xkb_state *state, struct xkb_filter *filter)
357 state->set_mods = filter->action.mods.mods.mask;
361 xkb_filter_mod_lock_func(struct xkb_state *state,
376 state->clear_mods |= filter->action.mods.mods.mask;
378 state->components.locked_mods &= ~filter->priv;
385 xkb_filter_mod_lock_new(struct xkb_state *state, struct xkb_filter *filter)
387 filter->priv = (state->components.locked_mods &
389 state->set_mods |= filter->action.mods.mods.mask;
391 state->components.locked_mods |= filter->action.mods.mods.mask;
418 xkb_filter_mod_latch_func(struct xkb_state *state,
430 const union xkb_action *action = xkb_key_get_action(state, key);
438 state->components.locked_mods |= filter->action.mods.mods.mask;
443 state->set_mods = filter->action.mods.mods.mask;
446 state->components.latched_mods &= ~filter->action.mods.mods.mask;
453 state->components.latched_mods &= ~filter->action.mods.mods.mask;
466 (state->components.locked_mods & filter->action.mods.mods.mask) ==
471 state->components.latched_mods &=
474 state->clear_mods = filter->action.mods.mods.mask;
475 state->components.locked_mods &= ~filter->action.mods.mods.mask;
480 state->clear_mods = filter->action.mods.mods.mask;
481 state->components.latched_mods |= filter->action.mods.mods.mask;
487 * key held down, so keep the base modifier state active (from
499 state, struct xkb_filter *filter)
502 state->set_mods = filter->action.mods.mods.mask;
506 void (*new)(struct xkb_state *state, struct xkb_filter *filter);
507 bool (*func)(struct xkb_state *state, struct xkb_filter *filter,
528 xkb_filter_apply_all(struct xkb_state *state,
538 darray_foreach(filter, state->filters) {
541 send = filter->func(state, filter, key, direction) && send;
547 action = xkb_key_get_action(state, key);
562 filter = xkb_filter_new(state);
569 filter_action_funcs[action->type].new(state, filter);
588 xkb_state_ref(struct xkb_state *state)
590 state->refcnt++;
591 return state;
595 xkb_state_unref(struct xkb_state *state)
597 if (!state || --state->refcnt > 0)
600 xkb_keymap_unref(state->keymap);
601 darray_free(state->filters);
602 free(state);
606 xkb_state_get_keymap(struct xkb_state *state)
608 return state->keymap;
612 * Update the LED state to match the rest of the xkb_state.
615 xkb_state_led_update_all(struct xkb_state *state)
620 state->components.leds = 0;
622 xkb_leds_enumerate(idx, led, state->keymap) {
628 mod_mask |= state->components.mods;
630 mod_mask |= state->components.base_mods;
632 mod_mask |= state->components.latched_mods;
634 mod_mask |= state->components.locked_mods;
637 state->components.leds |= (1u << idx);
644 group_mask |= (1u << state->components.group);
646 group_mask |= (1u << state->components.base_group);
648 group_mask |= (1u << state->components.latched_group);
650 group_mask |= (1u << state->components.locked_group);
653 state->components.leds |= (1u << idx);
658 if (led->ctrls & state->keymap->enabled_ctrls) {
659 state->components.leds |= (1u << idx);
666 * Calculates the derived state (effective mods/group and LEDs) from an
670 xkb_state_update_derived(struct xkb_state *state)
674 state->components.mods = (state->components.base_mods |
675 state->components.latched_mods |
676 state->components.locked_mods);
680 wrapped = XkbWrapGroupIntoRange(state->components.locked_group,
681 state->keymap->num_groups,
683 state->components.locked_group =
686 wrapped = XkbWrapGroupIntoRange(state->components.base_group +
687 state->components.latched_group +
688 state->components.locked_group,
689 state->keymap->num_groups,
691 state->components.group =
694 xkb_state_led_update_all(state);
726 * Given a particular key event, updates the state structure to reflect the
730 xkb_state_update_key(struct xkb_state *state, xkb_keycode_t kc,
736 const struct xkb_key *key = XkbKey(state->keymap, kc);
741 prev_components = state->components;
743 state->set_mods = 0;
744 state->clear_mods = 0;
746 xkb_filter_apply_all(state, key, direction);
748 for (i = 0, bit = 1; state->set_mods; i++, bit <<= 1) {
749 if (state->set_mods & bit) {
750 state->mod_key_count[i]++;
751 state->components.base_mods |= bit;
752 state->set_mods &= ~bit;
756 for (i = 0, bit = 1; state->clear_mods; i++, bit <<= 1) {
757 if (state->clear_mods & bit) {
758 state->mod_key_count[i]--;
759 if (state->mod_key_count[i] <= 0) {
760 state->components.base_mods &= ~bit;
761 state->mod_key_count[i] = 0;
763 state->clear_mods &= ~bit;
767 xkb_state_update_derived(state);
769 return get_state_component_changes(&prev_components, &state->components);
773 * Updates the state from a set of explicit masks as gained from
776 * lossy, and should only be used to update a slave state mirroring the
780 xkb_state_update_mask(struct xkb_state *state,
791 prev_components = state->components;
794 mask = (xkb_mod_mask_t) ((1ull << xkb_keymap_num_mods(state->keymap)) - 1u);
796 state->components.base_mods = base_mods & mask;
797 state->components.latched_mods = latched_mods & mask;
798 state->components.locked_mods = locked_mods & mask;
814 state->components.base_mods |=
815 mod_mask_get_effective(state->keymap, state->components.base_mods);
816 state->components.latched_mods |=
817 mod_mask_get_effective(state->keymap, state->components.latched_mods);
818 state->components.locked_mods |=
819 mod_mask_get_effective(state->keymap, state->components.locked_mods);
821 state->components.base_group = base_group;
822 state->components.latched_group = latched_group;
823 state->components.locked_group = locked_group;
825 xkb_state_update_derived(state);
827 return get_state_component_changes(&prev_components, &state->components);
831 * Provides the symbols to use for the given key and state. Returns the
835 xkb_state_key_get_syms(struct xkb_state *state, xkb_keycode_t kc,
841 layout = xkb_state_key_get_layout(state, kc);
845 level = xkb_state_key_get_level(state, kc, layout);
849 return xkb_keymap_key_get_syms_by_level(state->keymap, kc, layout, level,
861 should_do_caps_transformation(struct xkb_state *state, xkb_keycode_t kc)
864 xkb_keymap_mod_get_index(state->keymap, XKB_MOD_NAME_CAPS);
867 xkb_state_mod_index_is_active(state, caps, XKB_STATE_MODS_EFFECTIVE) > 0 &&
868 xkb_state_mod_index_is_consumed(state, kc, caps) == 0;
875 should_do_ctrl_transformation(struct xkb_state *state, xkb_keycode_t kc)
878 xkb_keymap_mod_get_index(state->keymap, XKB_MOD_NAME_CTRL);
881 xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_MODS_EFFECTIVE) > 0 &&
882 xkb_state_mod_index_is_consumed(state, kc, ctrl) == 0;
908 xkb_state_key_get_one_sym(struct xkb_state *state, xkb_keycode_t kc)
914 num_syms = xkb_state_key_get_syms(state, kc, &syms);
920 if (should_do_caps_transformation(state, kc))
936 get_one_sym_for_string(struct xkb_state *state, xkb_keycode_t kc)
944 layout = xkb_state_key_get_layout(state, kc);
945 num_layouts = xkb_keymap_num_layouts_for_key(state->keymap, kc);
946 level = xkb_state_key_get_level(state, kc, layout);
951 nsyms = xkb_keymap_key_get_syms_by_level(state->keymap, kc,
957 if (should_do_ctrl_transformation(state, kc) && sym > 127u) {
959 level = xkb_state_key_get_level(state, kc, i);
963 nsyms = xkb_keymap_key_get_syms_by_level(state->keymap, kc,
972 if (should_do_caps_transformation(state, kc)) {
980 xkb_state_key_get_utf8(struct xkb_state *state, xkb_keycode_t kc,
989 sym = get_one_sym_for_string(state, kc);
994 nsyms = xkb_state_key_get_syms(state, kc, &syms);
1018 should_do_ctrl_transformation(state, kc))
1035 xkb_state_key_get_utf32(struct xkb_state *state, xkb_keycode_t kc)
1040 sym = get_one_sym_for_string(state, kc);
1043 if (cp <= 127u && should_do_ctrl_transformation(state, kc))
1050 * Serialises the requested modifier state into an xkb_mod_mask_t, with all
1054 xkb_state_serialize_mods(struct xkb_state *state,
1060 return state->components.mods;
1063 ret |= state->components.base_mods;
1065 ret |= state->components.latched_mods;
1067 ret |= state->components.locked_mods;
1073 * Serialises the requested group state, with all the same disclaimers as
1077 xkb_state_serialize_layout(struct xkb_state *state,
1083 return state->components.group;
1086 ret += state->components.base_group;
1088 ret += state->components.latched_group;
1090 ret += state->components.locked_group;
1122 xkb_state_mod_index_is_active(struct xkb_state *state,
1126 if (idx >= xkb_keymap_num_mods(state->keymap))
1129 return !!(xkb_state_serialize_mods(state, type) & (1u << idx));
1137 match_mod_masks(struct xkb_state *state,
1142 xkb_mod_mask_t active = xkb_state_serialize_mods(state, type);
1160 xkb_state_mod_indices_are_active(struct xkb_state *state,
1169 xkb_mod_index_t num_mods = xkb_keymap_num_mods(state->keymap);
1187 return match_mod_masks(state, type, match, wanted);
1195 xkb_state_mod_name_is_active(struct xkb_state *state, const char *name,
1198 xkb_mod_index_t idx = xkb_keymap_mod_get_index(state->keymap, name);
1203 return xkb_state_mod_index_is_active(state, idx, type);
1211 xkb_state_mod_names_are_active(struct xkb_state *state,
1226 idx = xkb_keymap_mod_get_index(state->keymap, str);
1238 return match_mod_masks(state, type, match, wanted);
1246 xkb_state_layout_index_is_active(struct xkb_state *state,
1252 if (idx >= state->keymap->num_groups)
1256 ret |= (state->components.group == idx);
1258 ret |= (state->components.base_group == (int32_t) idx);
1260 ret |= (state->components.latched_group == (int32_t) idx);
1262 ret |= (state->components.locked_group == (int32_t) idx);
1272 xkb_state_layout_name_is_active(struct xkb_state *state, const char *name,
1275 xkb_layout_index_t idx = xkb_keymap_layout_get_index(state->keymap, name);
1280 return xkb_state_layout_index_is_active(state, idx, type);
1287 xkb_state_led_index_is_active(struct xkb_state *state, xkb_led_index_t idx)
1289 if (idx >= state->keymap->num_leds ||
1290 state->keymap->leds[idx].name == XKB_ATOM_NONE)
1293 return !!(state->components.leds & (1u << idx));
1300 xkb_state_led_name_is_active(struct xkb_state *state, const char *name)
1302 xkb_led_index_t idx = xkb_keymap_led_get_index(state->keymap, name);
1307 return xkb_state_led_index_is_active(state, idx);
1311 key_get_consumed(struct xkb_state *state, const struct xkb_key *key)
1318 group = xkb_state_key_get_layout(state, key->keycode);
1324 entry = get_entry_for_key_state(state, key, group);
1335 * keycode to keysyms, taking note of the current modifier state and
1346 xkb_state_mod_index_is_consumed(struct xkb_state *state, xkb_keycode_t kc,
1349 const struct xkb_key *key = XkbKey(state->keymap, kc);
1351 if (!key || idx >= xkb_keymap_num_mods(state->keymap))
1354 return !!((1u << idx) & key_get_consumed(state, key));
1360 * given a state of Alt and Shift active for a two-level alphabetic
1366 xkb_state_mod_mask_remove_consumed(struct xkb_state *state, xkb_keycode_t kc,
1369 const struct xkb_key *key = XkbKey(state->keymap, kc);
1374 return mask & ~key_get_consumed(state, key);
1378 xkb_state_key_get_consumed_mods(struct xkb_state *state, xkb_keycode_t kc)
1380 const struct xkb_key *key = XkbKey(state->keymap, kc);
1385 return key_get_consumed(state, key);
