config: key/mouse bindings: refactor: less parsing in keyboard_enter()

This simplifies the handling of mouse and keyboard bindings.

Before, the bindings where parsed *both* when loading the
configuration, and then on every keyboard enter event. This was done
since keys require a keymap to be decoded. Something we don't have at
configuration time. The idea was that at config time, we used a
default keymap just to verify the key combo strings were valid.

The following has changed:

* The bindings in the config struct is now *one* key combo per
  entry. Previously, it was one *action* per entry, and each entry
  had one or more key combos.

  Doing it this way makes it easier when converting the binding in the
  keyboard enter event (which previously had to expand the combos
  anyway).

* The bindings in the config struct no longer contains any unparsed
  strings.

  A key binding contains a decoded 'modifier' struct (which specifies
  whether e.g. ctrl, or shift, or ctrl+shift must be pressed for the
  binding to be used).

  It also contains a decoded XKB keysym.

* A mouse binding in the config struct is similar to a key binding,
  except it contains the button, and click count instead of the XKB
  key sym.

* The modifiers in the user-specified key combo is decoded at config
  time, by using the pre-defined XKB constants
  XKB_MOD_NAME_<modifier>.

  The result is stored in a 'modifiers' struct, which is just a
  collection of booleans; one for each supported modifier.

  The supported modifiers are: shift, ctrl, alt and meta/super.

* The key sym is decoded at config time using
  xkb_keysym_from_name(). This call does *not* depend on a keymap.

* The mouse button is decoded at config time using a hardcoded mapping
  table (just like before).

* The click count is currently hard-coded to 1.

* In the keyboard enter event, all we need to do is pre-compute the
  xkb_mod_mask_t variable for each key/mouse binding, and find all the
  *key codes* that map to the (already decoded) symbol.

  For mouse bindings, the modifiers are the *only* reason we convert
  the mouse bindings at all.

  In fact, on button events, we check if the seat has a keyboard. If
  not, we use the mouse bindings from the configuration directly, and
  simply filter out those with a non-empty set of modifiers.

config.c

@@ -652,106 +652,159 @@ parse_section_csd(const char *key, const char *value, struct config *conf,
     return true;
 }
 
-static bool
+/* Struct that holds temporary key/mouse binding parsed data */
-verify_key_combo(struct config *conf, const char *combo, const char *path, unsigned lineno)
+struct key_combo {
+    char *text;          /* Raw text, e.g. "Control+Shift+V" */
+    struct config_key_modifiers modifiers;
+    union {
+        xkb_keysym_t sym;    /* Key converted to an XKB symbol, e.g. XKB_KEY_V */
+        struct {
+            int button;
+            int count;
+        } m;
+    };
+};
+typedef tll(struct key_combo) key_combo_list_t;
+
+static void
+free_key_combo_list(key_combo_list_t *key_combos)
 {
-    /* Check regular key bindings */
+    tll_foreach(*key_combos, it)
-    tll_foreach(conf->bindings.key, it) {
+        free(it->item.text);
-        char *copy = xstrdup(it->item.combos);
+    tll_free(*key_combos);
-
-        for (char *save = NULL, *collision = strtok_r(copy, " ", &save);
-             collision != NULL;
-             collision = strtok_r(NULL, " ", &save))
-        {
-            if (strcmp(combo, collision) == 0) {
-                bool has_pipe = it->item.pipe.cmd != NULL;
-                LOG_AND_NOTIFY_ERR("%s:%d: %s already mapped to '%s%s%s%s'", path, lineno, combo,
-                        binding_action_map[it->item.action],
-                        has_pipe ? " [" : "",
-                        has_pipe ? it->item.pipe.cmd : "",
-                        has_pipe ? "]" : "");
-                free(copy);
-                return false;
-            }
-        }
-
-        free(copy);
-    }
-
-    /* Check scrollback search bindings */
-    tll_foreach(conf->bindings.search, it) {
-        char *copy = xstrdup(it->item.combos);
-
-        for (char *save = NULL, *collision = strtok_r(copy, " ", &save);
-             collision != NULL;
-             collision = strtok_r(NULL, " ", &save))
-        {
-            if (strcmp(combo, collision) == 0) {
-                LOG_AND_NOTIFY_ERR("%s:%d: %s already mapped to '%s'", path, lineno, combo,
-                        search_binding_action_map[it->item.action]);
-                free(copy);
-                return false;
-            }
-        }
-
-        free(copy);
-    }
-
-    struct xkb_context *ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
-    struct xkb_keymap *keymap = xkb_keymap_new_from_names(
-        ctx, &(struct xkb_rule_names){}, XKB_KEYMAP_COMPILE_NO_FLAGS);
-
-    bool valid_combo = input_parse_key_binding(keymap, combo, NULL);
-
-    xkb_keymap_unref(keymap);
-    xkb_context_unref(ctx);
-
-    if (!valid_combo) {
-        LOG_AND_NOTIFY_ERR("%s:%d: invalid key combination: %s", path, lineno, combo);
-        return false;
-    }
-
-    return true;
 }
 
 static bool
-verify_mouse_combo(struct config *conf,
+parse_modifiers(struct config *conf, const char *text, size_t len,
-                   const char *combo, enum bind_action_normal action,
+                struct config_key_modifiers *modifiers, const char *path, unsigned lineno)
-                   const char *path, unsigned lineno)
 {
-    tll_foreach(conf->bindings.mouse, it) {
+    bool ret = false;
-        char *copy = xstrdup(it->item.combos);
+
-        for (char *save = NULL, *collision = strtok_r(copy, " ", &save);
+    *modifiers = (struct config_key_modifiers){};
-             collision != NULL;
+    char *copy = xstrndup(text, len);
-             collision = strtok_r(NULL, " ", &save))
+
-        {
+    for (char *tok_ctx = NULL, *key = strtok_r(copy, "+", &tok_ctx);
-            if (strcmp(combo, collision) == 0) {
+         key != NULL;
-                LOG_AND_NOTIFY_ERR("%s:%d: %s already mapped to '%s'", path, lineno, combo,
+         key = strtok_r(NULL, "+", &tok_ctx))
-                                   binding_action_map[it->item.action]);
+    {
-                free(copy);
+        if (strcmp(key, XKB_MOD_NAME_SHIFT) == 0)
-                return false;
+            modifiers->shift = true;
-            }
+        else if (strcmp(key, XKB_MOD_NAME_CTRL) == 0)
+            modifiers->ctrl = true;
+        else if (strcmp(key, XKB_MOD_NAME_ALT) == 0)
+            modifiers->alt = true;
+        else if (strcmp(key, XKB_MOD_NAME_LOGO) == 0)
+            modifiers->meta = true;
+        else {
+            LOG_AND_NOTIFY_ERR("%s:%d: %s: not a valid modifier name",
+                               path, lineno, key);
+            goto out;
+        }
+    }
+
+    ret = true;
+
+out:
+    free(copy);
+    return ret;
+}
+
+static bool
+parse_key_combos(struct config *conf, const char *combos, key_combo_list_t *key_combos,
+                 const char *path, unsigned lineno)
+{
+    assert(tll_length(*key_combos) == 0);
+
+    char *copy = xstrdup(combos);
+
+    for (char *tok_ctx = NULL, *combo = strtok_r(copy, " ", &tok_ctx);
+         combo != NULL;
+         combo = strtok_r(NULL, " ", &tok_ctx))
+    {
+        struct config_key_modifiers modifiers = {};
+        const char *key = strrchr(combo, '+');
+
+        if (key == NULL) {
+            /* No modifiers */
+            key = combo;
+        } else {
+            if (!parse_modifiers(conf, combo, key - combo, &modifiers, path, lineno))
+                goto err;
+            key++;  /* Skip past the '+' */
         }
 
-        free(copy);
+        /* Translate key name to symbol */
-    }
+        xkb_keysym_t sym = xkb_keysym_from_name(key, 0);
-
+        if (sym == XKB_KEY_NoSymbol) {
-    struct xkb_context *ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
+            LOG_AND_NOTIFY_ERR("%s:%d: %s: key is not a valid XKB key name",
-    struct xkb_keymap *keymap = xkb_keymap_new_from_names(
+                               path, lineno, key);
-        ctx, &(struct xkb_rule_names){}, XKB_KEYMAP_COMPILE_NO_FLAGS);
+            goto err;
-
+        }
-    bool valid_combo = input_parse_mouse_binding(keymap, combo, action, NULL);
+
-
+        tll_push_back(
-    xkb_keymap_unref(keymap);
+            *key_combos,
-    xkb_context_unref(ctx);
+            ((struct key_combo){.text = xstrdup(combo), .modifiers = modifiers, .sym = sym}));
-
-    if (!valid_combo) {
-        LOG_AND_NOTIFY_ERR("%s:%d: invalid mouse binding: %s",
-                           path, lineno, combo);
-        return false;
     }
 
+    free(copy);
     return true;
+
+err:
+    tll_foreach(*key_combos, it)
+        free(it->item.text);
+    tll_free(*key_combos);
+    free(copy);
+    return false;
+}
+
+static bool
+has_key_binding_collisions(struct config *conf, const key_combo_list_t *key_combos,
+                           const char *path, unsigned lineno)
+{
+    tll_foreach(conf->bindings.key, it) {
+        tll_foreach(*key_combos, it2) {
+            const struct config_key_modifiers *mods1 = &it->item.modifiers;
+            const struct config_key_modifiers *mods2 = &it2->item.modifiers;
+
+            if (memcmp(mods1, mods2, sizeof(*mods1)) == 0 &&
+                it->item.sym == it2->item.sym)
+            {
+                bool has_pipe = it->item.pipe.cmd != NULL;
+                LOG_AND_NOTIFY_ERR("%s:%d: %s already mapped to '%s%s%s%s'",
+                                   path, lineno, it2->item.text,
+                                   binding_action_map[it->item.action],
+                                   has_pipe ? " [" : "",
+                                   has_pipe ? it->item.pipe.cmd : "",
+                                   has_pipe ? "]" : "");
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+static bool
+has_search_binding_collisions(struct config *conf, const key_combo_list_t *key_combos,
+                              const char *path, unsigned lineno)
+{
+    tll_foreach(conf->bindings.search, it) {
+        tll_foreach(*key_combos, it2) {
+            const struct config_key_modifiers *mods1 = &it->item.modifiers;
+            const struct config_key_modifiers *mods2 = &it2->item.modifiers;
+
+            if (memcmp(mods1, mods2, sizeof(*mods1)) == 0 &&
+                it->item.sym == it2->item.sym)
+            {
+                LOG_AND_NOTIFY_ERR("%s:%d: %s already mapped to '%s'",
+                                   path, lineno, it2->item.text,
+                                   search_binding_action_map[it->item.action]);
+                return true;
+            }
+        }
+    }
+
+    return false;
 }
 
 static int
@@ -817,12 +870,14 @@ parse_section_key_bindings(
         if (strcmp(key, binding_action_map[action]) != 0)
             continue;
 
+        /* Unset binding */
         if (strcasecmp(value, "none") == 0) {
             tll_foreach(conf->bindings.key, it) {
                 if (it->item.action == action) {
-                    free(it->item.combos);
+                    if (it->item.pipe.master_copy) {
-                    free(it->item.pipe.cmd);
+                        free(it->item.pipe.cmd);
-                    free(it->item.pipe.argv);
+                        free(it->item.pipe.argv);
+                    }
                     tll_remove(conf->bindings.key, it);
                 }
             }
@@ -831,13 +886,17 @@ parse_section_key_bindings(
             return true;
         }
 
-        if (!verify_key_combo(conf, value, path, lineno)) {
+        key_combo_list_t key_combos = tll_init();
+        if (!parse_key_combos(conf, value, &key_combos, path, lineno) ||
+            has_key_binding_collisions(conf, &key_combos, path, lineno))
+        {
             free(pipe_argv);
             free(pipe_cmd);
+            free_key_combo_list(&key_combos);
             return false;
         }
 
-        bool already_added = false;
+        /* Remove existing bindings for this action+pipe */
         tll_foreach(conf->bindings.key, it) {
             if (it->item.action == action &&
                 ((it->item.pipe.argv == NULL && pipe_argv == NULL) ||
@@ -845,29 +904,33 @@ parse_section_key_bindings(
                   argv_compare(it->item.pipe.argv, pipe_argv) == 0)))
             {
 
-                free(it->item.combos);
+                if (it->item.pipe.master_copy) {
-                free(it->item.pipe.cmd);
+                    free(it->item.pipe.cmd);
-                free(it->item.pipe.argv);
+                    free(it->item.pipe.argv);
-
+                }
-                it->item.combos = xstrdup(value);
+                tll_remove(conf->bindings.key, it);
-                it->item.pipe.cmd = pipe_cmd;
-                it->item.pipe.argv = pipe_argv;
-                already_added = true;
-                break;
             }
         }
 
-        if (!already_added) {
+        /* Emit key bindings */
+        bool first = true;
+        tll_foreach(key_combos, it) {
             struct config_key_binding_normal binding = {
                 .action = action,
-                .combos = xstrdup(value),
+                .modifiers = it->item.modifiers,
+                .sym = it->item.sym,
                 .pipe = {
                     .cmd = pipe_cmd,
                     .argv = pipe_argv,
+                    .master_copy = first,
                 },
             };
+
             tll_push_back(conf->bindings.key, binding);
+            first = false;
         }
+
+        free_key_combo_list(&key_combos);
         return true;
     }
 
@@ -891,36 +954,40 @@ parse_section_search_bindings(
         if (strcmp(key, search_binding_action_map[action]) != 0)
             continue;
 
+        /* Unset binding */
         if (strcasecmp(value, "none") == 0) {
             tll_foreach(conf->bindings.search, it) {
-                if (it->item.action == action) {
+                if (it->item.action == action)
-                    free(it->item.combos);
                     tll_remove(conf->bindings.search, it);
-                }
             }
             return true;
         }
 
-        if (!verify_key_combo(conf, value, path, lineno))
+        key_combo_list_t key_combos = tll_init();
+        if (!parse_key_combos(conf, value, &key_combos, path, lineno) ||
+            has_search_binding_collisions(conf, &key_combos, path, lineno))
+        {
+            free_key_combo_list(&key_combos);
             return false;
+        }
 
-        bool already_added = false;
+        /* Remove existing bindings for this action */
         tll_foreach(conf->bindings.search, it) {
-            if (it->item.action == action) {
+            if (it->item.action == action)
-                free(it->item.combos);
+                tll_remove(conf->bindings.search, it);
-                it->item.combos = xstrdup(value);
-                already_added = true;
-                break;
-            }
         }
 
-        if (!already_added) {
+        /* Emit key bindings */
-            struct config_key_binding_search binding = {
+        tll_foreach(key_combos, it) {
+            struct config_key_binding_normal binding = {
                 .action = action,
-                .combos = xstrdup(value),
+                .modifiers = it->item.modifiers,
+                .sym = it->item.sym,
             };
-            tll_push_back(conf->bindings.search, binding);
+            tll_push_back(conf->bindings.key, binding);
         }
+
+        free_key_combo_list(&key_combos);
         return true;
     }
 
@@ -929,6 +996,104 @@ parse_section_search_bindings(
 
 }
 
+static bool
+parse_mouse_combos(struct config *conf, const char *combos, key_combo_list_t *key_combos,
+                   const char *path, unsigned lineno)
+{
+    assert(tll_length(*key_combos) == 0);
+
+    char *copy = xstrdup(combos);
+
+    for (char *tok_ctx = NULL, *combo = strtok_r(copy, " ", &tok_ctx);
+         combo != NULL;
+         combo = strtok_r(NULL, " ", &tok_ctx))
+    {
+        struct config_key_modifiers modifiers = {};
+        const char *key = strrchr(combo, '+');
+
+        if (key == NULL) {
+            /* No modifiers */
+            key = combo;
+        } else {
+            if (!parse_modifiers(conf, combo, key - combo, &modifiers, path, lineno))
+                goto err;
+            key++;  /* Skip past the '+' */
+        }
+
+        static const struct {
+            const char *name;
+            int code;
+        } map[] = {
+            {"BTN_LEFT", BTN_LEFT},
+            {"BTN_RIGHT", BTN_RIGHT},
+            {"BTN_MIDDLE", BTN_MIDDLE},
+            {"BTN_SIDE", BTN_SIDE},
+            {"BTN_EXTRA", BTN_EXTRA},
+            {"BTN_FORWARD", BTN_FORWARD},
+            {"BTN_BACK", BTN_BACK},
+            {"BTN_TASK", BTN_TASK},
+        };
+
+        int button = 0;
+        for (size_t i = 0; i < ALEN(map); i++) {
+            if (strcmp(key, map[i].name) == 0) {
+                button = map[i].code;
+                break;
+            }
+        }
+
+        if (button == 0) {
+            LOG_AND_NOTIFY_ERR("%s:%d: %s: invalid mouse button name", path, lineno, key);
+            goto err;
+        }
+
+        struct key_combo new = {
+            .text = xstrdup(combo),
+            .modifiers = modifiers,
+            .m = {
+                .button = button,
+                .count = 1,
+            },
+        };
+        tll_push_back(*key_combos, new);
+    }
+
+    free(copy);
+    return true;
+
+err:
+    tll_foreach(*key_combos, it)
+        free(it->item.text);
+    tll_free(*key_combos);
+    free(copy);
+    return false;
+}
+
+static bool
+has_mouse_binding_collisions(struct config *conf, const key_combo_list_t *key_combos,
+                             const char *path, unsigned lineno)
+{
+    tll_foreach(conf->bindings.mouse, it) {
+        tll_foreach(*key_combos, it2) {
+            const struct config_key_modifiers *mods1 = &it->item.modifiers;
+            const struct config_key_modifiers *mods2 = &it2->item.modifiers;
+
+            if (memcmp(mods1, mods2, sizeof(*mods1)) == 0 &&
+                it->item.button == it2->item.m.button &&
+                it->item.count == it2->item.m.count)
+            {
+                LOG_AND_NOTIFY_ERR("%s:%d: %s already mapped to '%s'",
+                                   path, lineno, it2->item.text,
+                                   binding_action_map[it->item.action]);
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+
 static bool
 parse_section_mouse_bindings(
     const char *key, const char *value, struct config *conf,
@@ -941,91 +1106,43 @@ parse_section_mouse_bindings(
         if (strcmp(key, binding_action_map[action]) != 0)
             continue;
 
-        if (strcmp(value, "NONE") == 0) {
+        /* Unset binding */
+        if (strcasecmp(value, "none") == 0) {
             tll_foreach(conf->bindings.mouse, it) {
-                if (it->item.action == action) {
+                if (it->item.action == action)
-                    free(it->item.combos);
                     tll_remove(conf->bindings.mouse, it);
-                    break;
-                }
             }
             return true;
         }
 
-        if (!verify_mouse_combo(conf, value, action, path, lineno))
+        key_combo_list_t key_combos = tll_init();
+        if (!parse_mouse_combos(conf, value, &key_combos, path, lineno) ||
+            has_mouse_binding_collisions(conf, &key_combos, path, lineno))
+        {
+            free_key_combo_list(&key_combos);
             return false;
+        }
 
-        bool already_added = false;
+        /* Remove existing bindings for this action */
         tll_foreach(conf->bindings.mouse, it) {
             if (it->item.action == action) {
-                free(it->item.combos);
+                tll_remove(conf->bindings.mouse, it);
-                it->item.combos = xstrdup(value);
-                already_added = true;
-                break;
             }
         }
 
-        if (!already_added) {
+        /* Emit mouse bindings */
+        tll_foreach(key_combos, it) {
             struct config_mouse_binding binding = {
                 .action = action,
-                .combos = xstrdup(value),
+                .modifiers = it->item.modifiers,
+                .button = it->item.m.button,
+                .count = it->item.m.count,
             };
             tll_push_back(conf->bindings.mouse, binding);
         }
 
+        free_key_combo_list(&key_combos);
         return true;
-#if 0
-        const char *map[] = {
-            [BTN_LEFT] = "BTN_LEFT",
-            [BTN_RIGHT] = "BTN_RIGHT",
-            [BTN_MIDDLE] = "BTN_MIDDLE",
-            [BTN_SIDE] = "BTN_SIDE",
-            [BTN_EXTRA] = "BTN_EXTRA",
-            [BTN_FORWARD] = "BTN_FORWARD",
-            [BTN_BACK] = "BTN_BACK",
-            [BTN_TASK] = "BTN_TASK",
-        };
-
-        for (size_t i = 0; i < ALEN(map); i++) {
-            if (map[i] == NULL || strcmp(map[i], value) != 0)
-                continue;
-
-            const int count = 1;
-
-            /* Make sure button isn't already mapped to another action */
-            tll_foreach(conf->bindings.mouse, it) {
-                if (it->item.button == i && it->item.count == count) {
-                    LOG_AND_NOTIFY_ERR("%s:%d: %s already mapped to %s", path, lineno,
-                            value, binding_action_map[it->item.action]);
-                    return false;
-                }
-            }
-
-            bool already_added = false;
-            tll_foreach(conf->bindings.mouse, it) {
-                if (it->item.action == action) {
-                    it->item.button = i;
-                    it->item.count = count;
-                    already_added = true;
-                    break;
-                }
-            }
-
-            if (!already_added) {
-                struct config_mouse_binding binding = {
-                    .action = action,
-                    .mods = xstrdup(""),
-                    .button = i,
-                    .count = count,
-                };
-                tll_push_back(conf->bindings.mouse, binding);
-            }
-            return true;
-        }
-
-        LOG_AND_NOTIFY_ERR("%s:%d: invalid mouse button: %s", path, lineno, value);
-        return false;
-#endif
     }
 
     LOG_AND_NOTIFY_ERR("%s:%u: [mouse-bindings]: %s: invalid key", path, lineno, key);
@@ -1294,6 +1411,98 @@ get_server_socket_path(void)
     return xasprintf("%s/foot-%s.sock", xdg_runtime, wayland_display);
 }
 
+static void
+add_default_key_bindings(struct config *conf)
+{
+#define add_binding(action, mods, sym)                                  \
+    do {                                                                \
+        tll_push_back(                                                  \
+            conf->bindings.key,                                         \
+            ((struct config_key_binding_normal){action, mods, sym}));   \
+    } while (0)
+
+    const struct config_key_modifiers shift = {.shift = true};
+    const struct config_key_modifiers ctrl = {.ctrl = true};
+    const struct config_key_modifiers ctrl_shift = {.ctrl = true, .shift = true};
+
+    add_binding(BIND_ACTION_SCROLLBACK_UP, shift, XKB_KEY_Page_Up);
+    add_binding(BIND_ACTION_SCROLLBACK_DOWN, shift, XKB_KEY_Page_Down);
+    add_binding(BIND_ACTION_CLIPBOARD_COPY, ctrl_shift, XKB_KEY_C);
+    add_binding(BIND_ACTION_CLIPBOARD_PASTE, ctrl_shift, XKB_KEY_V);
+    add_binding(BIND_ACTION_SEARCH_START, ctrl_shift, XKB_KEY_R);
+    add_binding(BIND_ACTION_FONT_SIZE_UP, ctrl, XKB_KEY_plus);
+    add_binding(BIND_ACTION_FONT_SIZE_UP, ctrl, XKB_KEY_equal);
+    add_binding(BIND_ACTION_FONT_SIZE_UP, ctrl, XKB_KEY_KP_Add);
+    add_binding(BIND_ACTION_FONT_SIZE_DOWN, ctrl, XKB_KEY_minus);
+    add_binding(BIND_ACTION_FONT_SIZE_DOWN, ctrl, XKB_KEY_KP_Subtract);
+    add_binding(BIND_ACTION_FONT_SIZE_RESET, ctrl, XKB_KEY_0);
+    add_binding(BIND_ACTION_FONT_SIZE_RESET, ctrl, XKB_KEY_KP_0);
+    add_binding(BIND_ACTION_SPAWN_TERMINAL, ctrl_shift, XKB_KEY_N);
+
+#undef add_binding
+}
+
+static void
+add_default_search_bindings(struct config *conf)
+{
+#define add_binding(action, mods, sym)                                  \
+    do {                                                                \
+        tll_push_back(                                                  \
+            conf->bindings.search,                                      \
+            ((struct config_key_binding_search){action, mods, sym}));   \
+} while (0)
+
+    const struct config_key_modifiers none = {};
+    const struct config_key_modifiers alt = {.alt = true};
+    const struct config_key_modifiers ctrl = {.ctrl = true};
+    const struct config_key_modifiers ctrl_shift = {.ctrl = true, .shift = true};
+
+    add_binding(BIND_ACTION_SEARCH_CANCEL, ctrl, XKB_KEY_g);
+    add_binding(BIND_ACTION_SEARCH_CANCEL, none, XKB_KEY_Escape);
+    add_binding(BIND_ACTION_SEARCH_COMMIT, none, XKB_KEY_Return);
+    add_binding(BIND_ACTION_SEARCH_FIND_PREV, ctrl, XKB_KEY_r);
+    add_binding(BIND_ACTION_SEARCH_FIND_NEXT, ctrl, XKB_KEY_s);
+    add_binding(BIND_ACTION_SEARCH_EDIT_LEFT, none, XKB_KEY_Left);
+    add_binding(BIND_ACTION_SEARCH_EDIT_LEFT, ctrl, XKB_KEY_b);
+    add_binding(BIND_ACTION_SEARCH_EDIT_LEFT_WORD, ctrl, XKB_KEY_Left);
+    add_binding(BIND_ACTION_SEARCH_EDIT_LEFT_WORD, alt, XKB_KEY_b);
+    add_binding(BIND_ACTION_SEARCH_EDIT_RIGHT, none, XKB_KEY_Right);
+    add_binding(BIND_ACTION_SEARCH_EDIT_RIGHT, ctrl, XKB_KEY_f);
+    add_binding(BIND_ACTION_SEARCH_EDIT_RIGHT_WORD, ctrl, XKB_KEY_Right);
+    add_binding(BIND_ACTION_SEARCH_EDIT_RIGHT_WORD, alt, XKB_KEY_f);
+    add_binding(BIND_ACTION_SEARCH_EDIT_HOME, none, XKB_KEY_Home);
+    add_binding(BIND_ACTION_SEARCH_EDIT_HOME, ctrl, XKB_KEY_a);
+    add_binding(BIND_ACTION_SEARCH_EDIT_END, none, XKB_KEY_End);
+    add_binding(BIND_ACTION_SEARCH_EDIT_END, ctrl, XKB_KEY_e);
+    add_binding(BIND_ACTION_SEARCH_DELETE_PREV, none, XKB_KEY_BackSpace);
+    add_binding(BIND_ACTION_SEARCH_DELETE_PREV_WORD, ctrl, XKB_KEY_BackSpace);
+    add_binding(BIND_ACTION_SEARCH_DELETE_PREV_WORD, alt, XKB_KEY_BackSpace);
+    add_binding(BIND_ACTION_SEARCH_DELETE_NEXT, none, XKB_KEY_Delete);
+    add_binding(BIND_ACTION_SEARCH_DELETE_NEXT_WORD, ctrl, XKB_KEY_Delete);
+    add_binding(BIND_ACTION_SEARCH_DELETE_NEXT_WORD, alt, XKB_KEY_d);
+    add_binding(BIND_ACTION_SEARCH_EXTEND_WORD, ctrl, XKB_KEY_w);
+    add_binding(BIND_ACTION_SEARCH_EXTEND_WORD_WS, ctrl_shift, XKB_KEY_W);
+
+#undef add_binding
+}
+
+static void
+add_default_mouse_bindings(struct config *conf)
+{
+#define add_binding(action, mods, btn, count)                           \
+    do {                                                                \
+        tll_push_back(                                                  \
+            conf->bindings.mouse,                                       \
+            ((struct config_mouse_binding){action, mods, btn, count})); \
+} while (0)
+
+    const struct config_key_modifiers none = {};
+
+    add_binding(BIND_ACTION_PRIMARY_PASTE, none, BTN_MIDDLE, 1);
+
+#undef add_binding
+}
+
 bool
 config_load(struct config *conf, const char *conf_path, bool errors_are_fatal)
 {
@@ -1382,62 +1591,9 @@ config_load(struct config *conf, const char *conf_path, bool errors_are_fatal)
         .notifications = tll_init(),
     };
 
-    struct config_key_binding_normal scrollback_up =   {BIND_ACTION_SCROLLBACK_UP,   xstrdup("Shift+Page_Up")};
+    add_default_key_bindings(conf);
-    struct config_key_binding_normal scrollback_down = {BIND_ACTION_SCROLLBACK_DOWN, xstrdup("Shift+Page_Down")};
+    add_default_search_bindings(conf);
-    struct config_key_binding_normal clipboard_copy =  {BIND_ACTION_CLIPBOARD_COPY,  xstrdup("Control+Shift+C")};
+    add_default_mouse_bindings(conf);
-    struct config_key_binding_normal clipboard_paste = {BIND_ACTION_CLIPBOARD_PASTE, xstrdup("Control+Shift+V")};
-    struct config_key_binding_normal search_start =    {BIND_ACTION_SEARCH_START,    xstrdup("Control+Shift+R")};
-    struct config_key_binding_normal font_size_up =    {BIND_ACTION_FONT_SIZE_UP,    xstrdup("Control+plus Control+equal Control+KP_Add")};
-    struct config_key_binding_normal font_size_down =  {BIND_ACTION_FONT_SIZE_DOWN,  xstrdup("Control+minus Control+KP_Subtract")};
-    struct config_key_binding_normal font_size_reset = {BIND_ACTION_FONT_SIZE_RESET, xstrdup("Control+0 Control+KP_0")};
-    struct config_key_binding_normal spawn_terminal =  {BIND_ACTION_SPAWN_TERMINAL,  xstrdup("Control+Shift+N")};
-
-    tll_push_back(conf->bindings.key, scrollback_up);
-    tll_push_back(conf->bindings.key, scrollback_down);
-    tll_push_back(conf->bindings.key, clipboard_copy);
-    tll_push_back(conf->bindings.key, clipboard_paste);
-    tll_push_back(conf->bindings.key, search_start);
-    tll_push_back(conf->bindings.key, font_size_up);
-    tll_push_back(conf->bindings.key, font_size_down);
-    tll_push_back(conf->bindings.key, font_size_reset);
-    tll_push_back(conf->bindings.key, spawn_terminal);
-
-    struct config_mouse_binding primary_paste = {BIND_ACTION_PRIMARY_PASTE, xstrdup("BTN_MIDDLE")};
-    tll_push_back(conf->bindings.mouse, primary_paste);
-
-    struct config_key_binding_search search_cancel =          {BIND_ACTION_SEARCH_CANCEL,           xstrdup("Control+g Escape")};
-    struct config_key_binding_search search_commit =          {BIND_ACTION_SEARCH_COMMIT,           xstrdup("Return")};
-    struct config_key_binding_search search_find_prev =       {BIND_ACTION_SEARCH_FIND_PREV,        xstrdup("Control+r")};
-    struct config_key_binding_search search_find_next =       {BIND_ACTION_SEARCH_FIND_NEXT,        xstrdup("Control+s")};
-    struct config_key_binding_search search_edit_left =       {BIND_ACTION_SEARCH_EDIT_LEFT,        xstrdup("Left Control+b")};
-    struct config_key_binding_search search_edit_left_word =  {BIND_ACTION_SEARCH_EDIT_LEFT_WORD,   xstrdup("Control+Left Mod1+b")};
-    struct config_key_binding_search search_edit_right =      {BIND_ACTION_SEARCH_EDIT_RIGHT,       xstrdup("Right Control+f")};
-    struct config_key_binding_search search_edit_right_word = {BIND_ACTION_SEARCH_EDIT_RIGHT_WORD,  xstrdup("Control+Right Mod1+f")};
-    struct config_key_binding_search search_edit_home =       {BIND_ACTION_SEARCH_EDIT_HOME,        xstrdup("Home Control+a")};
-    struct config_key_binding_search search_edit_end =        {BIND_ACTION_SEARCH_EDIT_END,         xstrdup("End Control+e")};
-    struct config_key_binding_search search_del_prev =        {BIND_ACTION_SEARCH_DELETE_PREV,      xstrdup("BackSpace")};
-    struct config_key_binding_search search_del_prev_word =   {BIND_ACTION_SEARCH_DELETE_PREV_WORD, xstrdup("Mod1+BackSpace Control+BackSpace")};
-    struct config_key_binding_search search_del_next =        {BIND_ACTION_SEARCH_DELETE_NEXT,      xstrdup("Delete")};
-    struct config_key_binding_search search_del_next_word =   {BIND_ACTION_SEARCH_DELETE_NEXT_WORD, xstrdup("Mod1+d Control+Delete")};
-    struct config_key_binding_search search_ext_word =        {BIND_ACTION_SEARCH_EXTEND_WORD,      xstrdup("Control+w")};
-    struct config_key_binding_search search_ext_word_ws =     {BIND_ACTION_SEARCH_EXTEND_WORD_WS,   xstrdup("Control+Shift+W")};
-
-    tll_push_back(conf->bindings.search, search_cancel);
-    tll_push_back(conf->bindings.search, search_commit);
-    tll_push_back(conf->bindings.search, search_find_prev);
-    tll_push_back(conf->bindings.search, search_find_next);
-    tll_push_back(conf->bindings.search, search_edit_left);
-    tll_push_back(conf->bindings.search, search_edit_left_word);
-    tll_push_back(conf->bindings.search, search_edit_right);
-    tll_push_back(conf->bindings.search, search_edit_right_word);
-    tll_push_back(conf->bindings.search, search_edit_home);
-    tll_push_back(conf->bindings.search, search_edit_end);
-    tll_push_back(conf->bindings.search, search_del_prev);
-    tll_push_back(conf->bindings.search, search_del_prev_word);
-    tll_push_back(conf->bindings.search, search_del_next);
-    tll_push_back(conf->bindings.search, search_del_next_word);
-    tll_push_back(conf->bindings.search, search_ext_word);
-    tll_push_back(conf->bindings.search, search_ext_word_ws);
 
     char *default_path = NULL;
     if (conf_path == NULL) {
@@ -1490,14 +1646,11 @@ config_free(struct config conf)
     free(conf.server_socket_path);
 
     tll_foreach(conf.bindings.key, it) {
-        free(it->item.combos);
+        if (it->item.pipe.master_copy) {
-        free(it->item.pipe.cmd);
+            free(it->item.pipe.cmd);
-        free(it->item.pipe.argv);
+            free(it->item.pipe.argv);
+        }
     }
-    tll_foreach(conf.bindings.mouse, it)
-        free(it->item.combos);
-    tll_foreach(conf.bindings.search, it)
-        free(it->item.combos);
 
     tll_free(conf.bindings.key);
     tll_free(conf.bindings.mouse);

config.h

@@ -15,23 +15,35 @@ struct config_font {
     int px_size;
 };
 
+struct config_key_modifiers {
+    bool shift;
+    bool alt;
+    bool ctrl;
+    bool meta;
+};
+
 struct config_key_binding_normal {
     enum bind_action_normal action;
-    char *combos;
+    struct config_key_modifiers modifiers;
+    xkb_keysym_t sym;
     struct {
         char *cmd;
         char **argv;
+        bool master_copy;
     } pipe;
 };
 
-struct config_mouse_binding {
-    enum bind_action_normal action;
-    char *combos;
-};
-
 struct config_key_binding_search {
     enum bind_action_search action;
-    char *combos;
+    struct config_key_modifiers modifiers;
+    xkb_keysym_t sym;
+};
+
+struct config_mouse_binding {
+    enum bind_action_normal action;
+    struct config_key_modifiers modifiers;
+    int button;
+    int count;
 };
 
 struct config {

input.c

@@ -260,182 +260,110 @@ execute_binding(struct seat *seat, struct terminal *term,
     }
 }
 
-bool
+static xkb_mod_mask_t
-input_parse_key_binding(struct xkb_keymap *keymap, const char *combos,
+conf_modifiers_to_mask(const struct seat *seat,
-                        key_binding_list_t *bindings)
+                       const struct config_key_modifiers *modifiers)
 {
-    if (combos == NULL)
+    xkb_mod_mask_t mods = 0;
-        return true;
+    mods |= modifiers->shift << seat->kbd.mod_shift;
-
+    mods |= modifiers->ctrl << seat->kbd.mod_ctrl;
-    xkb_keysym_t sym = XKB_KEY_NoSymbol;
+    mods |= modifiers->alt << seat->kbd.mod_alt;
-
+    mods |= modifiers->meta << seat->kbd.mod_meta;
-    char *copy = xstrdup(combos);
+    return mods;
-
-    for (char *save1 = NULL, *combo = strtok_r(copy, " ", &save1);
-         combo != NULL;
-         combo = strtok_r(NULL, " ", &save1))
-    {
-        xkb_mod_mask_t mod_mask = 0;
-        xkb_keycode_list_t key_codes = tll_init();
-
-        LOG_DBG("%s", combo);
-        for (char *save2 = NULL, *key = strtok_r(combo, "+", &save2),
-                 *next_key = strtok_r(NULL, "+", &save2);
-             key != NULL;
-             key = next_key, next_key = strtok_r(NULL, "+", &save2))
-        {
-            if (next_key != NULL) {
-                /* Modifier */
-                xkb_mod_index_t mod = xkb_keymap_mod_get_index(keymap, key);
-
-                if (mod == -1) {
-                    LOG_ERR("%s: not a valid modifier name", key);
-                    free(copy);
-                    return false;
-                }
-
-                mod_mask |= 1 << mod;
-                LOG_DBG("MOD: %d - %s", mod, key);
-            } else {
-                /* Symbol */
-                sym = xkb_keysym_from_name(key, 0);
-
-                if (sym == XKB_KEY_NoSymbol) {
-                    LOG_ERR("%s: key binding is not a valid XKB symbol name",
-                            key);
-                    free(copy);
-                    return false;
-                }
-
-                /*
-                 * Find all key codes that map to the lower case
-                 * version of the symbol.
-                 *
-                 * This allows us to match bindings in other layouts
-                 * too.
-                 */
-                xkb_keysym_t lower_sym = xkb_keysym_to_lower(sym);
-                struct xkb_state *state = xkb_state_new(keymap);
-
-                for (xkb_keycode_t code = xkb_keymap_min_keycode(keymap);
-                     code <= xkb_keymap_max_keycode(keymap);
-                     code++)
-                {
-                    if (xkb_state_key_get_one_sym(state, code) == lower_sym)
-                        tll_push_back(key_codes, code);
-                }
-
-                xkb_state_unref(state);
-            }
-        }
-
-        LOG_DBG("mods=0x%08x, sym=%d", mod_mask, sym);
-
-        if (sym == XKB_KEY_NoSymbol) {
-            assert(tll_length(key_codes) == 0);
-            tll_free(key_codes);
-            continue;
-        }
-
-        assert(sym != 0);
-        if (bindings != NULL) {
-            const struct key_binding binding = {
-                .mods = mod_mask,
-                .sym = sym,
-                .key_codes = key_codes,
-            };
-
-            tll_push_back(*bindings, binding);
-        } else
-            tll_free(key_codes);
-    }
-
-    free(copy);
-    return true;
 }
 
-bool
+static xkb_keycode_list_t
-input_parse_mouse_binding(struct xkb_keymap *keymap, const char *combos,
+key_codes_for_xkb_sym(struct xkb_keymap *keymap, xkb_keysym_t sym)
-                          enum bind_action_normal action,
-                          mouse_binding_list_t *bindings)
 {
-    if (combos == NULL)
+    xkb_keycode_list_t key_codes = tll_init();
-        return true;
 
-    char *copy = xstrdup(combos);
+    /*
-    for (char *save1 = NULL, *combo = strtok_r(copy, " ", &save1);
+     * Find all key codes that map to the lower case
-         combo != NULL;
+     * version of the symbol.
-         combo = strtok_r(NULL, " ", &save1))
+     *
+     * This allows us to match bindings in other layouts
+     * too.
+     */
+    xkb_keysym_t lower_sym = xkb_keysym_to_lower(sym);
+    struct xkb_state *state = xkb_state_new(keymap);
+
+    for (xkb_keycode_t code = xkb_keymap_min_keycode(keymap);
+         code <= xkb_keymap_max_keycode(keymap);
+         code++)
     {
-        xkb_mod_mask_t mod_mask = 0;
+        if (xkb_state_key_get_one_sym(state, code) == lower_sym)
-        int button = 0;
+            tll_push_back(key_codes, code);
-
-        for (char *save2 = NULL, *key = strtok_r(combo, "+", &save2),
-                 *next_key = strtok_r(NULL, "+", &save2);
-             key != NULL;
-             key = next_key, next_key = strtok_r(NULL, "+", &save2))
-        {
-            if (next_key != NULL) {
-                /* Modifier */
-                xkb_mod_index_t mod = xkb_keymap_mod_get_index(keymap, key);
-
-                if (mod == -1) {
-                    LOG_ERR("%s: not a valid modifier name", key);
-                    free(copy);
-                    return false;
-                }
-
-                mod_mask |= 1 << mod;
-            }
-
-            else {
-                /* Button */
-                static const struct {
-                    const char *name;
-                    int code;
-                } map[] = {
-                    {"BTN_LEFT", BTN_LEFT},
-                    {"BTN_RIGHT", BTN_RIGHT},
-                    {"BTN_MIDDLE", BTN_MIDDLE},
-                    {"BTN_SIDE", BTN_SIDE},
-                    {"BTN_EXTRA", BTN_EXTRA},
-                    {"BTN_FORWARD", BTN_FORWARD},
-                    {"BTN_BACK", BTN_BACK},
-                    {"BTN_TASK", BTN_TASK},
-                };
-
-                for (size_t i = 0; i < ALEN(map); i++) {
-                    if (strcmp(key, map[i].name) == 0) {
-                        button = map[i].code;
-                        break;
-                    }
-                }
-
-                if (button == 0) {
-                    LOG_ERR("%s: invalid mouse button name", key);
-                    free(copy);
-                    return false;
-                }
-            }
-        }
-
-        if (button == 0)
-            continue;
-
-        if (bindings != NULL) {
-            const struct mouse_binding binding = {
-                .action = action,
-                .mods = mod_mask,
-                .button = button,
-                .count = 1,
-            };
-
-            tll_push_back(*bindings, binding);
-        }
     }
 
-    free(copy);
+    xkb_state_unref(state);
-    return true;
+    return key_codes;
+}
+
+static void
+convert_key_binding(struct seat *seat,
+                    const struct config_key_binding_normal *conf_binding)
+{
+    struct key_binding_normal binding = {
+        .action = conf_binding->action,
+        .bind = {
+            .mods = conf_modifiers_to_mask(seat, &conf_binding->modifiers),
+            .sym = conf_binding->sym,
+            .key_codes = key_codes_for_xkb_sym(
+                seat->kbd.xkb_keymap, conf_binding->sym),
+        },
+        .pipe_argv = conf_binding->pipe.argv,
+    };
+    tll_push_back(seat->kbd.bindings.key, binding);
+}
+
+static void
+convert_key_bindings(const struct config *conf, struct seat *seat)
+{
+    tll_foreach(conf->bindings.key, it)
+        convert_key_binding(seat, &it->item);
+}
+
+static void
+convert_search_binding(struct seat *seat,
+                       const struct config_key_binding_search *conf_binding)
+{
+    struct key_binding_search binding = {
+        .action = conf_binding->action,
+        .bind = {
+            .mods = conf_modifiers_to_mask(seat, &conf_binding->modifiers),
+            .sym = conf_binding->sym,
+            .key_codes = key_codes_for_xkb_sym(
+                seat->kbd.xkb_keymap, conf_binding->sym),
+        },
+    };
+    tll_push_back(seat->kbd.bindings.search, binding);
+}
+
+static void
+convert_search_bindings(const struct config *conf, struct seat *seat)
+{
+    tll_foreach(conf->bindings.search, it)
+        convert_search_binding(seat, &it->item);
+}
+
+static void
+convert_mouse_binding(struct seat *seat,
+                      const struct config_mouse_binding *conf_binding)
+{
+    struct mouse_binding binding = {
+        .action = conf_binding->action,
+        .mods = conf_modifiers_to_mask(seat, &conf_binding->modifiers),
+        .button = conf_binding->button,
+        .count = conf_binding->count,
+    };
+    tll_push_back(seat->mouse.bindings, binding);
+}
+
+static void
+convert_mouse_bindings(const struct config *conf, struct seat *seat)
+{
+    tll_foreach(conf->bindings.mouse, it)
+        convert_mouse_binding(seat, &it->item);
 }
 
 static void
@@ -494,7 +422,6 @@ keyboard_keymap(void *data, struct wl_keyboard *wl_keyboard,
         seat->kbd.xkb, map_str, size, XKB_KEYMAP_FORMAT_TEXT_V1,
         XKB_KEYMAP_COMPILE_NO_FLAGS);
 
-    /* TODO: initialize in enter? */
     seat->kbd.xkb_state = xkb_state_new(seat->kbd.xkb_keymap);
 
     seat->kbd.mod_shift = xkb_keymap_mod_get_index(seat->kbd.xkb_keymap, "Shift");
@@ -511,41 +438,9 @@ keyboard_keymap(void *data, struct wl_keyboard *wl_keyboard,
     munmap(map_str, size);
     close(fd);
 
-    tll_foreach(wayl->conf->bindings.key, it) {
+    convert_key_bindings(wayl->conf, seat);
-        key_binding_list_t bindings = tll_init();
+    convert_search_bindings(wayl->conf, seat);
-        input_parse_key_binding(
+    convert_mouse_bindings(wayl->conf, seat);
-            seat->kbd.xkb_keymap, it->item.combos, &bindings);
-
-        tll_foreach(bindings, it2) {
-            tll_push_back(
-                seat->kbd.bindings.key,
-                ((struct key_binding_normal){
-                    .bind = it2->item,
-                    .action = it->item.action,
-                    .pipe_argv = it->item.pipe.argv}));
-        }
-        tll_free(bindings);
-    }
-
-    tll_foreach(wayl->conf->bindings.search, it) {
-        key_binding_list_t bindings = tll_init();
-        input_parse_key_binding(
-            seat->kbd.xkb_keymap, it->item.combos, &bindings);
-
-        tll_foreach(bindings, it2) {
-            tll_push_back(
-                seat->kbd.bindings.search,
-                ((struct key_binding_search){
-                    .bind = it2->item, .action = it->item.action}));
-        }
-        tll_free(bindings);
-    }
-
-    tll_foreach(wayl->conf->bindings.mouse, it) {
-        input_parse_mouse_binding(
-            seat->kbd.xkb_keymap, it->item.combos, it->item.action,
-            &seat->mouse.bindings);
-    }
 }
 
 static void
@@ -1574,7 +1469,8 @@ wl_pointer_button(void *data, struct wl_pointer *wl_pointer,
                 }
             }
 
-            else {
+            else if (seat->wl_keyboard != NULL) {
+                /* Seat has keyboard - use mouse bindings *with* modifiers */
                 tll_foreach(seat->mouse.bindings, it) {
                     const struct mouse_binding *binding = &it->item;
 
@@ -1598,6 +1494,32 @@ wl_pointer_button(void *data, struct wl_pointer *wl_pointer,
                 }
             }
 
+            else {
+                /* Seat does NOT have a keyboard - use mouse bindings *without* modifiers */
+                tll_foreach(seat->wayl->conf->bindings.mouse, it) {
+                    const struct config_mouse_binding *binding = &it->item;
+
+                    if (binding->button != button) {
+                        /* Wrong button */
+                        continue;
+                    }
+
+                    if (binding->count != seat->mouse.count) {
+                        /* Incorrect click count */
+                        continue;
+                    }
+
+                    const struct config_key_modifiers no_mods = {};
+                    if (memcmp(&binding->modifiers, &no_mods, sizeof(no_mods)) != 0) {
+                        /* Binding has modifiers */
+                        continue;
+                    }
+
+                    execute_binding(seat, term, binding->action, NULL, serial);
+                    break;
+                }
+            }
+
             if (!term_mouse_grabbed(term, seat) && cursor_is_on_grid) {
                 term_mouse_down(
                     term, button, seat->mouse.row, seat->mouse.col,

input.h

@@ -9,9 +9,3 @@ extern const struct wl_keyboard_listener keyboard_listener;
 extern const struct wl_pointer_listener pointer_listener;
 
 void input_repeat(struct seat *seat, uint32_t key);
-
-bool input_parse_key_binding(struct xkb_keymap *keymap, const char *combos,
-                             key_binding_list_t *bindings);
-bool input_parse_mouse_binding(struct xkb_keymap *keymap, const char *combos,
-                               enum bind_action_normal action,
-                               mouse_binding_list_t *bindings);