kc3-lang/libxkbcommon

diff --git a/src/compat.c b/src/compat.c
index 244a723..3cc3ab3 100644
--- a/src/compat.c
+++ b/src/compat.c
@@ -29,7 +29,6 @@
 #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"
 
diff --git a/src/keymap-dump.c b/src/keymap-dump.c
index 357ba42..4306a7d 100644
--- a/src/keymap-dump.c
+++ b/src/keymap-dump.c
@@ -255,7 +255,7 @@ write_indicator_map(struct xkb_keymap *keymap, struct buf *buf,
               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));
         }
@@ -264,7 +264,7 @@ write_indicator_map(struct xkb_keymap *keymap, struct buf *buf,
     }
 
     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));
         }
diff --git a/src/state.c b/src/state.c
index 4c159fc..06e5334 100644
--- a/src/state.c
+++ b/src/state.c
@@ -114,7 +114,7 @@ get_entry_for_key_state(struct xkb_state *state, const struct xkb_key *key,
     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++)
@@ -191,7 +191,7 @@ XKB_EXPORT xkb_layout_index_t
 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)
@@ -598,20 +598,24 @@ xkb_state_led_update_all(struct xkb_state *state)
         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);
@@ -785,14 +789,14 @@ xkb_state_serialize_mods(struct xkb_state *state,
 {
     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;
@@ -808,14 +812,14 @@ xkb_state_serialize_layout(struct xkb_state *state,
 {
     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;
@@ -960,15 +964,13 @@ xkb_state_layout_index_is_active(struct xkb_state *state,
     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;
diff --git a/src/text.c b/src/text.c
index cc9b0f3..bb56b12 100644
--- a/src/text.c
+++ b/src/text.c
@@ -80,22 +80,22 @@ const LookupEntry ctrlMaskNames[] = {
 };
 
 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}
 };
diff --git a/src/xkbcomp/compat.c b/src/xkbcomp/compat.c
index fb654a6..ddd7583 100644
--- a/src/xkbcomp/compat.c
+++ b/src/xkbcomp/compat.c
@@ -1037,9 +1037,9 @@ CopyIndicatorMapDefs(CompatInfo *info)
 
         *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;
     }
 }
 
diff --git a/test/interactive.c b/test/interactive.c
index 15442c9..333f2ff 100644
--- a/test/interactive.c
+++ b/test/interactive.c
@@ -256,7 +256,8 @@ print_keycode(struct keyboard *kbd, xkb_keycode_t keycode)
 
     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);
     }
@@ -264,7 +265,8 @@ print_keycode(struct keyboard *kbd, xkb_keycode_t keycode)
 
     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));
diff --git a/test/state.c b/test/state.c
index cafc264..d23b94c 100644
--- a/test/state.c
+++ b/test/state.c
@@ -42,9 +42,9 @@ print_state(struct xkb_state *state)
     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;
@@ -53,32 +53,42 @@ print_state(struct xkb_state *state)
     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 " : "");
     }
 
@@ -106,31 +116,31 @@ test_update_key(struct xkb_keymap *keymap)
     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,
@@ -141,15 +151,15 @@ test_update_key(struct xkb_keymap *keymap)
     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,
@@ -158,19 +168,19 @@ test_update_key(struct xkb_keymap *keymap)
     /* 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);
@@ -181,9 +191,9 @@ test_update_key(struct xkb_keymap *keymap)
     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);
@@ -206,7 +216,7 @@ test_update_key(struct xkb_keymap *keymap)
     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);
@@ -252,31 +262,31 @@ test_serialisation(struct xkb_keymap *keymap)
 
     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);
 }
@@ -312,7 +322,7 @@ test_consume(struct xkb_keymap *keymap)
     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);
diff --git a/xkbcommon/xkbcommon-compat.h b/xkbcommon/xkbcommon-compat.h
index 0142bca..f96e4c8 100644
--- a/xkbcommon/xkbcommon-compat.h
+++ b/xkbcommon/xkbcommon-compat.h
@@ -34,6 +34,16 @@
 #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) \
diff --git a/xkbcommon/xkbcommon.h b/xkbcommon/xkbcommon.h
index 6387f92..846b619 100644
--- a/xkbcommon/xkbcommon.h
+++ b/xkbcommon/xkbcommon.h
@@ -1102,22 +1102,36 @@ xkb_keymap_key_get_syms_by_level(struct xkb_keymap *keymap,
 
 /**
  * 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),
 };
 
 /**
@@ -1163,30 +1177,48 @@ xkb_state_update_mask(struct xkb_state *state, xkb_mod_mask_t base_mods,
                       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.