actions: Add support for multiple actions per level

Author: wismill

src/keymap-priv.c

@@ -78,6 +78,7 @@ xkb_keymap_new(struct xkb_context *ctx,
         keymap->out_of_range_group_action = RANGE_WRAP;
     }
     log_err(ctx, 0, "xkb_keymap_new: flags: %d, out_of_range_group_action=%u\n", flags, keymap->out_of_range_group_action);
+
     update_builtin_keymap_fields(keymap);
 
     return keymap;
@@ -160,6 +161,20 @@ XkbLevelsSameSyms(const struct xkb_level *a, const struct xkb_level *b)
     return memcmp(a->s.syms, b->s.syms, sizeof(*a->s.syms) * a->num_syms) == 0;
 }
 
+bool
+XkbLevelHasNoAction(const struct xkb_level *level)
+{
+    if (level->num_syms == 0)
+        return true;
+    if (level->num_syms == 1)
+        return level->a.action.type == ACTION_TYPE_NONE;
+    for (unsigned int k = 0; k < level->num_syms; k++) {
+        if (level->a.actions[k].type != ACTION_TYPE_NONE)
+            return false;
+    }
+    return true;
+}
+
 xkb_layout_index_t
 XkbWrapGroupIntoRange(int32_t group,
                       xkb_layout_index_t num_groups,
@@ -196,3 +211,41 @@ XkbWrapGroupIntoRange(int32_t group,
             return group % num_groups;
     }
 }
+
+unsigned int
+xkb_keymap_key_get_actions_by_level(struct xkb_keymap *keymap,
+                                    xkb_keycode_t kc,
+                                    xkb_layout_index_t layout,
+                                    xkb_level_index_t level,
+                                    const union xkb_action **actions)
+{
+    const struct xkb_key *key = XkbKey(keymap, kc);
+    unsigned int count;
+
+    if (!key)
+        goto err;
+
+    layout = XkbWrapGroupIntoRange(layout, key->num_groups,
+                                   key->out_of_range_group_action,
+                                   key->out_of_range_group_number);
+    if (layout == XKB_LAYOUT_INVALID)
+        goto err;
+
+    if (level >= XkbKeyNumLevels(key, layout))
+        goto err;
+
+    count = key->groups[layout].levels[level].num_syms;
+    if (count == 0)
+        goto err;
+
+    if (count == 1)
+        *actions = &key->groups[layout].levels[level].a.action;
+    else
+        *actions = key->groups[layout].levels[level].a.actions;
+
+    return count;
+
+err:
+    *actions = NULL;
+    return 0;
+}

src/keymap.c

@@ -75,8 +75,10 @@ xkb_keymap_unref(struct xkb_keymap *keymap)
                 for (unsigned i = 0; i < key->num_groups; i++) {
                     if (key->groups[i].levels) {
                         for (unsigned j = 0; j < XkbKeyNumLevels(key, i); j++)
-                            if (key->groups[i].levels[j].num_syms > 1)
+                            if (key->groups[i].levels[j].num_syms > 1) {
                                 free(key->groups[i].levels[j].s.syms);
+                                free(key->groups[i].levels[j].a.actions);
+                            }
                         free(key->groups[i].levels);
                     }
                 }

src/keymap.h

@@ -316,12 +316,15 @@ enum xkb_explicit_components {
 };
 
 struct xkb_level {
-    union xkb_action action;
     unsigned int num_syms;
     union {
         xkb_keysym_t sym;       /* num_syms == 1 */
         xkb_keysym_t *syms;     /* num_syms > 1  */
     } s;
+    union {
+        union xkb_action action;   /* num_syms == 1 */
+        union xkb_action *actions; /* num_syms >  1 */
+    } a;
 };
 
 struct xkb_group {
@@ -476,6 +479,9 @@ XkbModNameToIndex(const struct xkb_mod_set *mods, xkb_atom_t name,
 bool
 XkbLevelsSameSyms(const struct xkb_level *a, const struct xkb_level *b);
 
+bool
+XkbLevelHasNoAction(const struct xkb_level *level);
+
 xkb_layout_index_t
 XkbWrapGroupIntoRange(int32_t group,
                       xkb_layout_index_t num_groups,
@@ -485,6 +491,13 @@ XkbWrapGroupIntoRange(int32_t group,
 xkb_mod_mask_t
 mod_mask_get_effective(struct xkb_keymap *keymap, xkb_mod_mask_t mods);
 
+unsigned int
+xkb_keymap_key_get_actions_by_level(struct xkb_keymap *keymap,
+                                    xkb_keycode_t kc,
+                                    xkb_layout_index_t layout,
+                                    xkb_level_index_t level,
+                                    const union xkb_action **actions);
+
 struct xkb_keymap_format_ops {
     bool (*keymap_new_from_names)(struct xkb_keymap *keymap,
                                   const struct xkb_rule_names *names);

src/state.c

@@ -176,23 +176,27 @@ xkb_state_key_get_layout(struct xkb_state *state, xkb_keycode_t kc)
                                  key->out_of_range_group_number);
 }
 
-static const union xkb_action *
-xkb_key_get_action(struct xkb_state *state, const struct xkb_key *key)
+static unsigned int
+xkb_key_get_actions(struct xkb_state *state, const struct xkb_key *key,
+                    const union xkb_action **actions)
 {
-    static const union xkb_action dummy = { .type = ACTION_TYPE_NONE };
-
     xkb_layout_index_t layout;
     xkb_level_index_t level;
 
     layout = xkb_state_key_get_layout(state, key->keycode);
     if (layout == XKB_LAYOUT_INVALID)
-        return &dummy;
+        goto err;
 
     level = xkb_state_key_get_level(state, key->keycode, layout);
     if (level == XKB_LEVEL_INVALID)
-        return &dummy;
+        goto err;
 
-    return &key->groups[layout].levels[level].action;
+    return xkb_keymap_key_get_actions_by_level(state->keymap, key->keycode,
+                                               layout, level, actions);
+
+err:
+    *actions = NULL;
+    return 0;
 }
 
 static struct xkb_filter *
@@ -377,34 +381,37 @@ xkb_filter_group_latch_func(struct xkb_state *state,
          * keypress, then either break the latch if any random key is pressed,
          * or promote it to a lock or plain base set if it's the same
          * group delta & flags. */
-        const union xkb_action *action = xkb_key_get_action(state, key);
-        if (action->type == ACTION_TYPE_GROUP_LATCH &&
-            action->group.group == filter->action.group.group &&
-            action->group.flags == filter->action.group.flags) {
-            filter->action = *action;
-            if (filter->action.group.flags & ACTION_LATCH_TO_LOCK &&
-                filter->action.group.group != 0) {
-                /* Promote to lock */
-                filter->action.type = ACTION_TYPE_GROUP_LOCK;
-                filter->func = xkb_filter_group_lock_func;
-                xkb_filter_group_lock_new(state, filter);
+        const union xkb_action *actions = NULL;
+        unsigned int count = xkb_key_get_actions(state, key, &actions);
+        for (unsigned int k = 0; k < count; k++) {
+            if (actions[k].type == ACTION_TYPE_GROUP_LATCH &&
+                actions[k].group.group == filter->action.group.group &&
+                actions[k].group.flags == filter->action.group.flags) {
+                filter->action = actions[k];
+                if (filter->action.group.flags & ACTION_LATCH_TO_LOCK &&
+                    filter->action.group.group != 0) {
+                    /* Promote to lock */
+                    filter->action.type = ACTION_TYPE_GROUP_LOCK;
+                    filter->func = xkb_filter_group_lock_func;
+                    xkb_filter_group_lock_new(state, filter);
+                }
+                else {
+                    /* Degrade to plain set */
+                    filter->action.type = ACTION_TYPE_GROUP_SET;
+                    filter->func = xkb_filter_group_set_func;
+                    xkb_filter_group_set_new(state, filter);
+                }
+                filter->key = key;
+                state->components.latched_group -= priv.group_delta;
+                /* XXX beep beep! */
+                return XKB_FILTER_CONSUME;
             }
-            else {
-                /* Degrade to plain set */
-                filter->action.type = ACTION_TYPE_GROUP_SET;
-                filter->func = xkb_filter_group_set_func;
-                xkb_filter_group_set_new(state, filter);
+            else if (xkb_action_breaks_latch(&(actions[k]))) {
+                /* Breaks the latch */
+                state->components.latched_group = 0;
+                filter->func = NULL;
+                return XKB_FILTER_CONTINUE;
             }
-            filter->key = key;
-            state->components.latched_group -= priv.group_delta;
-            /* XXX beep beep! */
-            return XKB_FILTER_CONSUME;
-        }
-        else if (xkb_action_breaks_latch(action)) {
-            /* Breaks the latch */
-            state->components.latched_group = 0;
-            filter->func = NULL;
-            return XKB_FILTER_CONTINUE;
         }
     }
     else if (direction == XKB_KEY_UP && key == filter->key) {
@@ -533,32 +540,35 @@ xkb_filter_mod_latch_func(struct xkb_state *state,
          * keypress, then either break the latch if any random key is pressed,
          * or promote it to a lock or plain base set if it's the same
          * modifier. */
-        const union xkb_action *action = xkb_key_get_action(state, key);
-        if (action->type == ACTION_TYPE_MOD_LATCH &&
-            action->mods.flags == filter->action.mods.flags &&
-            action->mods.mods.mask == filter->action.mods.mods.mask) {
-            filter->action = *action;
-            if (filter->action.mods.flags & ACTION_LATCH_TO_LOCK) {
-                filter->action.type = ACTION_TYPE_MOD_LOCK;
-                filter->func = xkb_filter_mod_lock_func;
-                state->components.locked_mods |= filter->action.mods.mods.mask;
+        const union xkb_action *actions = NULL;
+        unsigned int count = xkb_key_get_actions(state, key, &actions);
+        for (unsigned int k = 0; k < count; k++) {
+            if (actions[k].type == ACTION_TYPE_MOD_LATCH &&
+                actions[k].mods.flags == filter->action.mods.flags &&
+                actions[k].mods.mods.mask == filter->action.mods.mods.mask) {
+                filter->action = actions[k];
+                if (filter->action.mods.flags & ACTION_LATCH_TO_LOCK) {
+                    filter->action.type = ACTION_TYPE_MOD_LOCK;
+                    filter->func = xkb_filter_mod_lock_func;
+                    state->components.locked_mods |= filter->action.mods.mods.mask;
+                }
+                else {
+                    filter->action.type = ACTION_TYPE_MOD_SET;
+                    filter->func = xkb_filter_mod_set_func;
+                    state->set_mods = filter->action.mods.mods.mask;
+                }
+                filter->key = key;
+                state->components.latched_mods &= ~filter->action.mods.mods.mask;
+                /* XXX beep beep! */
+                return XKB_FILTER_CONSUME;
             }
-            else {
-                filter->action.type = ACTION_TYPE_MOD_SET;
-                filter->func = xkb_filter_mod_set_func;
-                state->set_mods = filter->action.mods.mods.mask;
+            else if (xkb_action_breaks_latch(&(actions[k]))) {
+                /* XXX: This may be totally broken, we might need to break the
+                *      latch in the next run after this press? */
+                state->components.latched_mods &= ~filter->action.mods.mods.mask;
+                filter->func = NULL;
+                return XKB_FILTER_CONTINUE;
             }
-            filter->key = key;
-            state->components.latched_mods &= ~filter->action.mods.mods.mask;
-            /* XXX beep beep! */
-            return XKB_FILTER_CONSUME;
-        }
-        else if (xkb_action_breaks_latch(action)) {
-            /* XXX: This may be totally broken, we might need to break the
-             *      latch in the next run after this press? */
-            state->components.latched_mods &= ~filter->action.mods.mods.mask;
-            filter->func = NULL;
-            return XKB_FILTER_CONTINUE;
         }
     }
     else if (direction == XKB_KEY_UP && key == filter->key) {
@@ -631,7 +641,8 @@ xkb_filter_apply_all(struct xkb_state *state,
                      enum xkb_key_direction direction)
 {
     struct xkb_filter *filter;
-    const union xkb_action *action;
+    const union xkb_action *actions = NULL;
+    unsigned int count;
     bool consumed;
 
     /* First run through all the currently active filters and see if any of
@@ -648,28 +659,38 @@ xkb_filter_apply_all(struct xkb_state *state,
         return;
 
     /* No filter consumed this event, so proceed with the key action */
-    action = xkb_key_get_action(state, key);
-
-    /*
-     * It's possible for the keymap to set action->type explicitly, like so:
-     *     interpret XF86_Next_VMode {
-     *         action = Private(type=0x86, data="+VMode");
-     *     };
-     * We don't handle those.
-     */
-    if (action->type >= _ACTION_TYPE_NUM_ENTRIES)
-        return;
+    count = xkb_key_get_actions(state, key, &actions);
+
+    for (unsigned int k = 0; k < count; k++) {
+        /* FIXME: remove debug */
+        if (count > 1) {
+            log_vrb(
+                state->keymap->ctx, 0, 0,
+                "xkb_filter_apply_all: key: %u, index: %u, action type: %d\n",
+                key->keycode, k, actions[k].type
+            );
+        }
+        /*
+        * It's possible for the keymap to set action->type explicitly, like so:
+        *     interpret XF86_Next_VMode {
+        *         action = Private(type=0x86, data="+VMode");
+        *     };
+        * We don't handle those.
+        */
+        if (actions[k].type >= _ACTION_TYPE_NUM_ENTRIES)
+            return;
 
     /* Return if no corresponding action */
-    if (!filter_action_funcs[action->type].new)
-        return;
+        if (!filter_action_funcs[actions[k].type].new)
+            return;
 
     /* Add a new filter and run the corresponding initial action */
-    filter = xkb_filter_new(state);
-    filter->key = key;
-    filter->func = filter_action_funcs[action->type].func;
-    filter->action = *action;
-    filter_action_funcs[action->type].new(state, filter);
+        filter = xkb_filter_new(state);
+        filter->key = key;
+        filter->func = filter_action_funcs[actions[k].type].func;
+        filter->action = actions[k];
+        filter_action_funcs[actions[k].type].new(state, filter);
+    }
 }
 
 XKB_EXPORT struct xkb_state *

src/x11/keymap.c

@@ -529,7 +529,7 @@ get_actions(struct xkb_keymap *keymap, xcb_connection_t *conn,
                     xcb_xkb_action_t *wire_action = acts_iter.data;
 
                     if (level < key->groups[group].type->num_levels) {
-                        union xkb_action *action = &key->groups[group].levels[level].action;
+                        union xkb_action *action = &key->groups[group].levels[level].a.action;
 
                         translate_action(action, wire_action);
                     }