#include "utils.h"
/* We don't carry any prototypes for these functions, as we #define them
-<<<<<<< HEAD
* to their newer versions so people link against those. */
#pragma GCC diagnostic ignored "-Wmissing-prototypes"
xkb_atom_text(keymap->ctx, led->name));
if (led->which_groups) {
- if (led->which_groups != XKB_STATE_EFFECTIVE) {
+ if (led->which_groups != XKB_STATE_LAYOUT_EFFECTIVE) {
write_buf(buf, "\t\t\twhichGroupState= %s;\n",
IndicatorStateText(keymap->ctx, led->which_groups));
}
}
if (led->which_mods) {
- if (led->which_mods != XKB_STATE_EFFECTIVE) {
+ if (led->which_mods != XKB_STATE_MODS_EFFECTIVE) {
write_buf(buf, "\t\t\twhichModState= %s;\n",
IndicatorStateText(keymap->ctx, led->which_mods));
}
unsigned int i;
type = key->groups[group].type;
- active_mods = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
+ active_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE);
active_mods &= type->mods.mask;
for (i = 0; i < type->num_entries; i++)
xkb_state_key_get_layout(struct xkb_state *state, xkb_keycode_t kc)
{
xkb_layout_index_t group =
- xkb_state_serialize_layout(state, XKB_STATE_EFFECTIVE);
+ xkb_state_serialize_layout(state, XKB_STATE_LAYOUT_EFFECTIVE);
const struct xkb_key *key = XkbKey(state->keymap, kc);
if (!key)
xkb_mod_mask_t mod_mask = 0;
xkb_layout_mask_t group_mask = 0;
- if (map->which_mods & XKB_STATE_DEPRESSED)
+ if (map->which_mods & XKB_STATE_MODS_EFFECTIVE)
+ mod_mask |= state->mods;
+ if (map->which_mods & XKB_STATE_MODS_DEPRESSED)
mod_mask |= state->base_mods;
- if (map->which_mods & XKB_STATE_LATCHED)
+ if (map->which_mods & XKB_STATE_MODS_LATCHED)
mod_mask |= state->latched_mods;
- if (map->which_mods & XKB_STATE_LOCKED)
+ if (map->which_mods & XKB_STATE_MODS_LOCKED)
mod_mask |= state->locked_mods;
if (map->mods.mask & mod_mask)
state->leds |= (1 << led);
- if (map->which_groups & XKB_STATE_DEPRESSED)
+ if (map->which_groups & XKB_STATE_LAYOUT_EFFECTIVE)
+ group_mask |= (1 << state->group);
+ if (map->which_groups & XKB_STATE_LAYOUT_DEPRESSED)
group_mask |= (1 << state->base_group);
- if (map->which_groups & XKB_STATE_LATCHED)
+ if (map->which_groups & XKB_STATE_LAYOUT_LATCHED)
group_mask |= (1 << state->latched_group);
- if (map->which_groups & XKB_STATE_LOCKED)
+ if (map->which_groups & XKB_STATE_LAYOUT_LOCKED)
group_mask |= (1 << state->locked_group);
if (map->groups & group_mask)
state->leds |= (1 << led);
{
xkb_mod_mask_t ret = 0;
- if (type == XKB_STATE_EFFECTIVE)
+ if (type & XKB_STATE_MODS_EFFECTIVE)
return state->mods;
- if (type & XKB_STATE_DEPRESSED)
+ if (type & XKB_STATE_MODS_DEPRESSED)
ret |= state->base_mods;
- if (type & XKB_STATE_LATCHED)
+ if (type & XKB_STATE_MODS_LATCHED)
ret |= state->latched_mods;
- if (type & XKB_STATE_LOCKED)
+ if (type & XKB_STATE_MODS_LOCKED)
ret |= state->locked_mods;
return ret;
{
xkb_layout_index_t ret = 0;
- if (type == XKB_STATE_EFFECTIVE)
+ if (type & XKB_STATE_LAYOUT_EFFECTIVE)
return state->group;
- if (type & XKB_STATE_DEPRESSED)
+ if (type & XKB_STATE_LAYOUT_DEPRESSED)
ret += state->base_group;
- if (type & XKB_STATE_LATCHED)
+ if (type & XKB_STATE_LAYOUT_LATCHED)
ret += state->latched_group;
- if (type & XKB_STATE_LOCKED)
+ if (type & XKB_STATE_LAYOUT_LOCKED)
ret += state->locked_group;
return ret;
if (idx >= xkb_keymap_num_layouts(state->keymap))
return -1;
- /* Can only have one effective group. */
- if (type == XKB_STATE_EFFECTIVE)
- return state->group == idx;
-
- if (type & XKB_STATE_DEPRESSED)
+ if (type & XKB_STATE_LAYOUT_EFFECTIVE)
+ ret |= (state->group == idx);
+ if (type & XKB_STATE_LAYOUT_DEPRESSED)
ret |= (state->base_group == idx);
- if (type & XKB_STATE_LATCHED)
+ if (type & XKB_STATE_LAYOUT_LATCHED)
ret |= (state->latched_group == idx);
- if (type & XKB_STATE_LOCKED)
+ if (type & XKB_STATE_LAYOUT_LOCKED)
ret |= (state->locked_group == idx);
return ret;
};
const LookupEntry modComponentMaskNames[] = {
- {"base", XKB_STATE_DEPRESSED},
- {"latched", XKB_STATE_LATCHED},
- {"locked", XKB_STATE_LOCKED},
- {"effective", XKB_STATE_EFFECTIVE},
- {"compat", XKB_STATE_EFFECTIVE},
- {"any", XKB_STATE_EFFECTIVE},
+ {"base", XKB_STATE_MODS_DEPRESSED},
+ {"latched", XKB_STATE_MODS_LATCHED},
+ {"locked", XKB_STATE_MODS_LOCKED},
+ {"effective", XKB_STATE_MODS_EFFECTIVE},
+ {"compat", XKB_STATE_MODS_EFFECTIVE},
+ {"any", XKB_STATE_MODS_EFFECTIVE},
{"none", 0},
{NULL, 0}
};
const LookupEntry groupComponentMaskNames[] = {
- {"base", XKB_STATE_DEPRESSED},
- {"latched", XKB_STATE_LATCHED},
- {"locked", XKB_STATE_LOCKED},
- {"effective", XKB_STATE_EFFECTIVE},
- {"any", XKB_STATE_EFFECTIVE},
+ {"base", XKB_STATE_LAYOUT_DEPRESSED},
+ {"latched", XKB_STATE_LAYOUT_LATCHED},
+ {"locked", XKB_STATE_LAYOUT_LOCKED},
+ {"effective", XKB_STATE_LAYOUT_EFFECTIVE},
+ {"any", XKB_STATE_LAYOUT_EFFECTIVE},
{"none", 0},
{NULL, 0}
};
*im = led->im;
if (im->groups != 0 && im->which_groups == 0)
- im->which_groups = XKB_STATE_EFFECTIVE;
+ im->which_groups = XKB_STATE_LAYOUT_EFFECTIVE;
if (im->mods.mods != 0 && im->which_mods == 0)
- im->which_mods = XKB_STATE_EFFECTIVE;
+ im->which_mods = XKB_STATE_MODS_EFFECTIVE;
}
}
printf("groups [ ");
for (group = 0; group < xkb_keymap_num_layouts(keymap); group++) {
- if (!xkb_state_layout_index_is_active(state, group, XKB_STATE_EFFECTIVE))
+ if (xkb_state_layout_index_is_active(state, group,
+ XKB_STATE_LAYOUT_EFFECTIVE) <= 0)
continue;
printf("%s (%d) ", xkb_keymap_layout_get_name(keymap, group), group);
}
printf("mods [ ");
for (mod = 0; mod < xkb_keymap_num_mods(keymap); mod++) {
- if (!xkb_state_mod_index_is_active(state, mod, XKB_STATE_EFFECTIVE))
+ if (xkb_state_mod_index_is_active(state, mod,
+ XKB_STATE_MODS_EFFECTIVE) <= 0)
continue;
if (xkb_state_mod_index_is_consumed(state, keycode, mod))
printf("-%s ", xkb_keymap_mod_get_name(keymap, mod));
xkb_mod_index_t mod;
xkb_led_index_t led;
- group = xkb_state_serialize_layout(state, XKB_STATE_EFFECTIVE);
- mod = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
- /* led = xkb_state_serialize_leds(state, XKB_STATE_EFFECTIVE); */
+ group = xkb_state_serialize_layout(state, XKB_STATE_LAYOUT_EFFECTIVE);
+ mod = xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE);
+ /* led = xkb_state_serialize_leds(state, XKB_STATE_LEDS); */
if (!group && !mod /* && !led */) {
fprintf(stderr, "\tno state\n");
return;
keymap = xkb_state_get_keymap(state);
for (group = 0; group < xkb_keymap_num_layouts(keymap); group++) {
- if (xkb_state_layout_index_is_active(state, group, XKB_STATE_EFFECTIVE) != 1)
+ if (xkb_state_layout_index_is_active(state, group,
+ XKB_STATE_LAYOUT_EFFECTIVE |
+ XKB_STATE_LAYOUT_DEPRESSED |
+ XKB_STATE_LAYOUT_LATCHED |
+ XKB_STATE_LAYOUT_LOCKED) <= 0)
continue;
fprintf(stderr, "\tgroup %s (%d): %s%s%s%s\n",
xkb_keymap_layout_get_name(keymap, group),
group,
- xkb_state_layout_index_is_active(state, group, XKB_STATE_EFFECTIVE) > 0 ?
+ xkb_state_layout_index_is_active(state, group, XKB_STATE_LAYOUT_EFFECTIVE) > 0 ?
"effective " : "",
- xkb_state_layout_index_is_active(state, group, XKB_STATE_DEPRESSED) > 0 ?
+ xkb_state_layout_index_is_active(state, group, XKB_STATE_LAYOUT_DEPRESSED) > 0 ?
"depressed " : "",
- xkb_state_layout_index_is_active(state, group, XKB_STATE_LATCHED) > 0 ?
+ xkb_state_layout_index_is_active(state, group, XKB_STATE_LAYOUT_LATCHED) > 0 ?
"latched " : "",
- xkb_state_layout_index_is_active(state, group, XKB_STATE_LOCKED) > 0 ?
+ xkb_state_layout_index_is_active(state, group, XKB_STATE_LAYOUT_LOCKED) > 0 ?
"locked " : "");
}
for (mod = 0; mod < xkb_keymap_num_mods(keymap); mod++) {
- if (!xkb_state_mod_index_is_active(state, mod, XKB_STATE_EFFECTIVE))
+ if (xkb_state_mod_index_is_active(state, mod,
+ XKB_STATE_MODS_EFFECTIVE |
+ XKB_STATE_MODS_DEPRESSED |
+ XKB_STATE_MODS_LATCHED |
+ XKB_STATE_MODS_LOCKED) <= 0)
continue;
- fprintf(stderr, "\tmod %s (%d): %s%s%s\n",
+ fprintf(stderr, "\tmod %s (%d): %s%s%s%s\n",
xkb_keymap_mod_get_name(keymap, mod),
mod,
- xkb_state_mod_index_is_active(state, mod, XKB_STATE_DEPRESSED) > 0 ?
+ xkb_state_mod_index_is_active(state, mod, XKB_STATE_MODS_EFFECTIVE) > 0 ?
+ "effective " : "",
+ xkb_state_mod_index_is_active(state, mod, XKB_STATE_MODS_DEPRESSED) > 0 ?
"depressed " : "",
- xkb_state_mod_index_is_active(state, mod, XKB_STATE_LATCHED) > 0 ?
+ xkb_state_mod_index_is_active(state, mod, XKB_STATE_MODS_LATCHED) > 0 ?
"latched " : "",
- xkb_state_mod_index_is_active(state, mod, XKB_STATE_LOCKED) > 0 ?
+ xkb_state_mod_index_is_active(state, mod, XKB_STATE_MODS_LOCKED) > 0 ?
"locked " : "");
}
fprintf(stderr, "dumping state for LCtrl down:\n");
print_state(state);
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CTRL,
- XKB_STATE_DEPRESSED) > 0);
+ XKB_STATE_MODS_DEPRESSED) > 0);
/* LCtrl + RAlt down */
xkb_state_update_key(state, KEY_RIGHTALT + EVDEV_OFFSET, XKB_KEY_DOWN);
fprintf(stderr, "dumping state for LCtrl + RAlt down:\n");
print_state(state);
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CTRL,
- XKB_STATE_DEPRESSED) > 0);
+ XKB_STATE_MODS_DEPRESSED) > 0);
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT,
- XKB_STATE_DEPRESSED) > 0);
- assert(xkb_state_mod_names_are_active(state, XKB_STATE_DEPRESSED,
+ XKB_STATE_MODS_DEPRESSED) > 0);
+ assert(xkb_state_mod_names_are_active(state, XKB_STATE_MODS_DEPRESSED,
XKB_STATE_MATCH_ALL,
XKB_MOD_NAME_CTRL,
XKB_MOD_NAME_ALT,
NULL) > 0);
- assert(xkb_state_mod_indices_are_active(state, XKB_STATE_DEPRESSED,
+ assert(xkb_state_mod_indices_are_active(state, XKB_STATE_MODS_DEPRESSED,
XKB_STATE_MATCH_ALL,
xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CTRL),
xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_ALT),
XKB_MOD_INVALID) > 0);
- assert(!xkb_state_mod_names_are_active(state, XKB_STATE_DEPRESSED,
+ assert(!xkb_state_mod_names_are_active(state, XKB_STATE_MODS_DEPRESSED,
XKB_STATE_MATCH_ALL,
XKB_MOD_NAME_ALT,
NULL) > 0);
- assert(xkb_state_mod_names_are_active(state, XKB_STATE_DEPRESSED,
+ assert(xkb_state_mod_names_are_active(state, XKB_STATE_MODS_DEPRESSED,
(XKB_STATE_MATCH_ANY |
XKB_STATE_MATCH_NON_EXCLUSIVE),
XKB_MOD_NAME_ALT,
fprintf(stderr, "dumping state for RAlt down:\n");
print_state(state);
assert(!xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CTRL,
- XKB_STATE_EFFECTIVE) > 0);
+ XKB_STATE_MODS_EFFECTIVE) > 0);
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT,
- XKB_STATE_DEPRESSED) > 0);
- assert(xkb_state_mod_names_are_active(state, XKB_STATE_DEPRESSED,
+ XKB_STATE_MODS_DEPRESSED) > 0);
+ assert(xkb_state_mod_names_are_active(state, XKB_STATE_MODS_DEPRESSED,
XKB_STATE_MATCH_ANY,
XKB_MOD_NAME_CTRL,
XKB_MOD_NAME_ALT,
NULL) > 0);
- assert(xkb_state_mod_names_are_active(state, XKB_STATE_LATCHED,
+ assert(xkb_state_mod_names_are_active(state, XKB_STATE_MODS_LATCHED,
XKB_STATE_MATCH_ANY,
XKB_MOD_NAME_CTRL,
XKB_MOD_NAME_ALT,
/* none down */
xkb_state_update_key(state, KEY_RIGHTALT + EVDEV_OFFSET, XKB_KEY_UP);
assert(!xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT,
- XKB_STATE_EFFECTIVE));
+ XKB_STATE_MODS_EFFECTIVE));
/* Caps locked */
xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
- XKB_STATE_DEPRESSED) > 0);
+ XKB_STATE_MODS_DEPRESSED) > 0);
xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
fprintf(stderr, "dumping state for Caps Lock:\n");
print_state(state);
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
- XKB_STATE_DEPRESSED) == 0);
+ XKB_STATE_MODS_DEPRESSED) == 0);
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
- XKB_STATE_LOCKED) > 0);
+ XKB_STATE_MODS_LOCKED) > 0);
assert(xkb_state_led_name_is_active(state, XKB_LED_NAME_CAPS) > 0);
num_syms = xkb_state_key_get_syms(state, KEY_Q + EVDEV_OFFSET, &syms);
assert(num_syms == 1 && syms[0] == XKB_KEY_Q);
fprintf(stderr, "dumping state for Caps Lock + Num Lock:\n");
print_state(state);
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
- XKB_STATE_LOCKED) > 0);
+ XKB_STATE_MODS_LOCKED) > 0);
assert(xkb_state_mod_name_is_active(state, "Mod2",
- XKB_STATE_LOCKED) > 0);
+ XKB_STATE_MODS_LOCKED) > 0);
num_syms = xkb_state_key_get_syms(state, KEY_KP1 + EVDEV_OFFSET, &syms);
assert(num_syms == 1 && syms[0] == XKB_KEY_KP_1);
assert(xkb_state_led_name_is_active(state, XKB_LED_NAME_NUM) > 0);
xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
assert(!xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
- XKB_STATE_EFFECTIVE) > 0);
+ XKB_STATE_MODS_EFFECTIVE) > 0);
assert(!xkb_state_led_name_is_active(state, XKB_LED_NAME_CAPS) > 0);
num_syms = xkb_state_key_get_syms(state, KEY_Q + EVDEV_OFFSET, &syms);
assert(num_syms == 1 && syms[0] == XKB_KEY_q);
xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
- base_mods = xkb_state_serialize_mods(state, XKB_STATE_DEPRESSED);
+ base_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_DEPRESSED);
assert(base_mods == 0);
- latched_mods = xkb_state_serialize_mods(state, XKB_STATE_LATCHED);
+ latched_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_LATCHED);
assert(latched_mods == 0);
- locked_mods = xkb_state_serialize_mods(state, XKB_STATE_LOCKED);
+ locked_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_LOCKED);
assert(locked_mods == (1 << caps));
- effective_mods = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
+ effective_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE);
assert(effective_mods == locked_mods);
xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
- base_mods = xkb_state_serialize_mods(state, XKB_STATE_DEPRESSED);
+ base_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_DEPRESSED);
assert(base_mods == (1 << shift));
- latched_mods = xkb_state_serialize_mods(state, XKB_STATE_LATCHED);
+ latched_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_LATCHED);
assert(latched_mods == 0);
- locked_mods = xkb_state_serialize_mods(state, XKB_STATE_LOCKED);
+ locked_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_LOCKED);
assert(locked_mods == (1 << caps));
- effective_mods = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
+ effective_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE);
assert(effective_mods == (base_mods | locked_mods));
base_mods |= (1 << ctrl);
xkb_state_update_mask(state, base_mods, latched_mods, locked_mods,
base_group, latched_group, locked_group);
- assert(xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_DEPRESSED));
- assert(xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_EFFECTIVE));
+ assert(xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_MODS_DEPRESSED));
+ assert(xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_MODS_EFFECTIVE));
xkb_state_unref(state);
}
fprintf(stderr, "dumping state for Alt-Shift-+\n");
print_state(state);
- mask = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
+ mask = xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE);
assert(mask == ((1 << alt) | (1 << shift)));
mask = xkb_state_mod_mask_remove_consumed(state, KEY_EQUAL + EVDEV_OFFSET,
mask);
#define xkb_map_compile_flags xkb_keymap_compile_flags
#define XKB_GROUP_INVALID XKB_LAYOUT_INVALID
+#define XKB_STATE_DEPRESSED \
+ (XKB_STATE_MODS_DEPRESSED | XKB_STATE_LAYOUT_DEPRESSED)
+#define XKB_STATE_LATCHED \
+ (XKB_STATE_MODS_LATCHED | XKB_STATE_LAYOUT_LATCHED)
+#define XKB_STATE_LOCKED \
+ (XKB_STATE_MODS_LOCKED | XKB_STATE_LAYOUT_LOCKED)
+#define XKB_STATE_EFFECTIVE \
+ (XKB_STATE_DEPRESSED | XKB_STATE_LATCHED | XKB_STATE_LOCKED | \
+ XKB_STATE_MODS_EFFECTIVE | XKB_STATE_LAYOUT_EFFECTIVE)
+
#define xkb_map_new_from_names(context, names, flags) \
xkb_keymap_new_from_names(context, names, flags)
#define xkb_map_new_from_file(context, file, format, flags) \
/**
* Modifier and layout types for state objects. This enum is bitmaskable,
- * e.g. (XKB_STATE_DEPRESSED | XKB_STATE_LATCHED) is valid to exclude
- * locked modifiers.
+ * e.g. (XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_LATCHED) is valid to
+ * exclude locked modifiers.
+ *
+ * In XKB, the DEPRESSED states are also known as 'base'.
*/
enum xkb_state_component {
- /** A key holding this modifier or layout is currently physically
- * depressed; also known as 'base'. */
- XKB_STATE_DEPRESSED = (1 << 0),
- /** Modifier or layout is latched, i.e. will be unset after the next
- * non-modifier key press. */
- XKB_STATE_LATCHED = (1 << 1),
- /** Modifier or layout is locked, i.e. will be unset after the key
- * provoking the lock has been pressed again. */
- XKB_STATE_LOCKED = (1 << 2),
- /** Combinatination of depressed, latched, and locked. */
- XKB_STATE_EFFECTIVE =
- (XKB_STATE_DEPRESSED | XKB_STATE_LATCHED | XKB_STATE_LOCKED),
+ /** Depressed modifiers, i.e. a key is physically holding them. */
+ XKB_STATE_MODS_DEPRESSED = (1 << 0),
+ /** Latched modifiers, i.e. will be unset after the next non-modifier
+ * key press. */
+ XKB_STATE_MODS_LATCHED = (1 << 1),
+ /** Locked modifiers, i.e. will be unset after the key provoking the
+ * lock has been pressed again. */
+ XKB_STATE_MODS_LOCKED = (1 << 2),
+ /** Effective modifiers, i.e. currently active and affect key
+ * processing (derived from the other state components). */
+ XKB_STATE_MODS_EFFECTIVE = (1 << 3),
+ /** Depressed layout, i.e. a key is physically holding it. */
+ XKB_STATE_LAYOUT_DEPRESSED = (1 << 4),
+ /** Latched layout, i.e. will be unset after the next non-modifier
+ * key press. */
+ XKB_STATE_LAYOUT_LATCHED = (1 << 5),
+ /** Locked layout, i.e. will be unset after the key provoking the lock
+ * has been pressed again. */
+ XKB_STATE_LAYOUT_LOCKED = (1 << 6),
+ /** Effective layout, i.e. currently active and affects key processing
+ * (derived from the other state components). */
+ XKB_STATE_LAYOUT_EFFECTIVE = (1 << 7),
+ /** LEDs (derived from the other state components). */
+ XKB_STATE_LEDS = (1 << 8),
};
/**
xkb_layout_index_t locked_layout);
/**
- * The counterpart to xkb_state_update_mask, to be used on the server side
- * of serialization.
+ * The counterpart to xkb_state_update_mask for modifiers, to be used on
+ * the server side of serialization.
*
- * @returns A xkb_mod_mask_t representing the given component(s) of the
- * state.
+ * @param state The keyboard state.
+ * @param components A mask of the modifier state components to serialize.
+ * State components other than XKB_STATE_MODS_* are ignored.
+ * If XKB_STATE_MODS_EFFECTIVE is included, all other state components are
+ * ignored.
+ *
+ * @returns A xkb_mod_mask_t representing the given components of the
+ * modifier state.
*
* This function should not be used in regular clients; please use the
- * xkb_state_mod_*_is_active or xkb_state_foreach_active_mod API instead.
+ * xkb_state_mod_*_is_active API instead.
*
* @memberof xkb_state
*/
xkb_mod_mask_t
xkb_state_serialize_mods(struct xkb_state *state,
- enum xkb_state_component component);
+ enum xkb_state_component components);
/**
- * The layout equivalent of xkb_state_serialize_mods.
+ * The counterpart to xkb_state_update_mask for layouts, to be used on
+ * the server side of serialization.
+ *
+ * @param state The keyboard state.
+ * @param components A mask of the layout state components to serialize.
+ * State components other than XKB_STATE_LAYOUT_* are ignored.
+ * If XKB_STATE_LAYOUT_EFFECTIVE is included, all other state components are
+ * ignored.
+ *
+ * @returns A xkb_layout_mask_t representing the given components of the
+ * layout state.
+ *
+ * This function should not be used in regular clients; please use the
+ * xkb_state_layout_*_is_active API instead.
*
- * @sa xkb_state_serialize_mods
* @memberof xkb_state
*/
xkb_layout_index_t
xkb_state_serialize_layout(struct xkb_state *state,
- enum xkb_state_component component);
+ enum xkb_state_component components);
/**
* Test whether a modifier is active in a given keyboard state by name.
projects / platform / upstream / libxkbcommon.git / commitdiff