From a09c144b8b5f9d0518e7239a27e2fb86e00644b3 Mon Sep 17 00:00:00 2001 From: Konstantin Pospelov Date: Sun, 17 Feb 2019 19:08:22 +0300 Subject: Implement bindsym --to-code * `bindsym --to-code` enables keysym to keycode translation. * If there are no `xkb_layout` commands in the config file, the translation uses the XKB_DEFAULT_LAYOUT value. * It there is one or more `xkb_layout` command, the translation uses the first one. * If the translation is unsuccessful, a message is logged and the binding is stored as BINDING_KEYSYM. * The binding keysyms are stored and re-translated when a change in the input configuration may affect the translated bindings. --- include/sway/config.h | 30 ++++++--- sway/commands/bind.c | 169 ++++++++++++++++++++++++++++++++++++++++++++------ sway/commands/input.c | 25 ++++++++ sway/config.c | 76 +++++++++++++++++++++++ 4 files changed, 274 insertions(+), 26 deletions(-) diff --git a/include/sway/config.h b/include/sway/config.h index 86410544..392f6538 100644 --- a/include/sway/config.h +++ b/include/sway/config.h @@ -24,7 +24,6 @@ struct sway_variable { char *value; }; - enum binding_input_type { BINDING_KEYCODE, BINDING_KEYSYM, @@ -39,6 +38,7 @@ enum binding_flags { BINDING_BORDER=4, // mouse only; trigger on container border BINDING_CONTENTS=8, // mouse only; trigger on container contents BINDING_TITLEBAR=16, // mouse only; trigger on container titlebar + BINDING_CODE=32, // keyboard only; convert keysyms into keycodes }; /** @@ -50,6 +50,7 @@ struct sway_binding { char *input; uint32_t flags; list_t *keys; // sorted in ascending order + list_t *syms; // sorted in ascending order; NULL if BINDING_CODE is not set uint32_t modifiers; char *command; }; @@ -406,6 +407,14 @@ enum alignment { ALIGN_RIGHT }; +/** + * The keysym to keycode translation. + */ +struct keysym_translation_data { + struct xkb_keymap *xkb_keymap; + struct xkb_state *xkb_state; +}; + /** * The configuration struct. The result of loading a config file. */ @@ -508,6 +517,9 @@ struct sway_config { list_t *feature_policies; list_t *ipc_policies; + // The keysym to keycode translation + struct keysym_translation_data keysym_translation; + // Context for command handlers struct { struct input_config *input_config; @@ -617,12 +629,6 @@ bool spawn_swaybg(void); int workspace_output_cmp_workspace(const void *a, const void *b); -int sway_binding_cmp(const void *a, const void *b); - -int sway_binding_cmp_qsort(const void *a, const void *b); - -int sway_binding_cmp_keys(const void *a, const void *b); - void free_sway_binding(struct sway_binding *sb); void free_switch_binding(struct sway_switch_binding *binding); @@ -651,6 +657,16 @@ void free_workspace_config(struct workspace_config *wsc); */ void config_update_font_height(bool recalculate); +/** + * Convert bindsym into bindcode using the first configured layout. + * Return false in case the conversion is unsuccessful. + */ +bool translate_binding(struct sway_binding *binding); + +void translate_keysyms(const char *layout); + +void binding_add_translated(struct sway_binding *binding, list_t *bindings); + /* Global config singleton. */ extern struct sway_config *config; diff --git a/sway/commands/bind.c b/sway/commands/bind.c index dc7e0b19..e5fd4433 100644 --- a/sway/commands/bind.c +++ b/sway/commands/bind.c @@ -24,6 +24,7 @@ void free_sway_binding(struct sway_binding *binding) { } list_free_items_and_destroy(binding->keys); + list_free_items_and_destroy(binding->syms); free(binding->input); free(binding->command); free(binding); @@ -249,31 +250,41 @@ static struct cmd_results *switch_binding_remove( switchcombo); } -static struct cmd_results *binding_add(struct sway_binding *binding, - list_t *mode_bindings, const char *bindtype, - const char *keycombo, bool warn) { - // overwrite the binding if it already exists - bool overwritten = false; +/** + * Insert or update the binding. + * Return the binding which has been replaced or NULL. + */ +static struct sway_binding *binding_upsert(struct sway_binding *binding, + list_t *mode_bindings) { for (int i = 0; i < mode_bindings->length; ++i) { struct sway_binding *config_binding = mode_bindings->items[i]; if (binding_key_compare(binding, config_binding)) { - sway_log(SWAY_INFO, "Overwriting binding '%s' for device '%s' " - "to `%s` from `%s`", keycombo, binding->input, - binding->command, config_binding->command); - if (warn) { - config_add_swaynag_warning("Overwriting binding" - "'%s' for device '%s' to `%s` from `%s`", - keycombo, binding->input, binding->command, - config_binding->command); - } - free_sway_binding(config_binding); mode_bindings->items[i] = binding; - overwritten = true; + return config_binding; } } - if (!overwritten) { - list_add(mode_bindings, binding); + list_add(mode_bindings, binding); + return NULL; +} + +static struct cmd_results *binding_add(struct sway_binding *binding, + list_t *mode_bindings, const char *bindtype, + const char *keycombo, bool warn) { + struct sway_binding *config_binding = binding_upsert(binding, mode_bindings); + + if (config_binding) { + sway_log(SWAY_INFO, "Overwriting binding '%s' for device '%s' " + "to `%s` from `%s`", keycombo, binding->input, + binding->command, config_binding->command); + if (warn) { + config_add_swaynag_warning("Overwriting binding" + "'%s' for device '%s' to `%s` from `%s`", + keycombo, binding->input, binding->command, + config_binding->command); + } + free_sway_binding(config_binding); + } else { sway_log(SWAY_DEBUG, "%s - Bound %s to command `%s` for device '%s'", bindtype, keycombo, binding->command, binding->input); } @@ -329,7 +340,6 @@ static struct cmd_results *cmd_bindsym_or_bindcode(int argc, char **argv, bool exclude_titlebar = false; bool warn = true; - // Handle --release and --locked while (argc > 0) { if (strcmp("--release", argv[0]) == 0) { binding->flags |= BINDING_RELEASE; @@ -339,6 +349,10 @@ static struct cmd_results *cmd_bindsym_or_bindcode(int argc, char **argv, binding->flags |= BINDING_BORDER | BINDING_CONTENTS | BINDING_TITLEBAR; } else if (strcmp("--border", argv[0]) == 0) { binding->flags |= BINDING_BORDER; + } else if (strcmp("--to-code", argv[0]) == 0) { + if (!bindcode) { + binding->flags |= BINDING_CODE; + } } else if (strcmp("--exclude-titlebar", argv[0]) == 0) { exclude_titlebar = true; } else if (strncmp("--input-device=", argv[0], @@ -410,6 +424,12 @@ static struct cmd_results *cmd_bindsym_or_bindcode(int argc, char **argv, // sort ascending list_qsort(binding->keys, key_qsort_cmp); + // translate keysyms into keycodes + if (!translate_binding(binding)) { + sway_log(SWAY_INFO, + "Unable to translate bindsym into bindcode: %s", argv[0]); + } + list_t *mode_bindings; if (binding->type == BINDING_KEYCODE) { mode_bindings = config->current_mode->keycode_bindings; @@ -566,3 +586,114 @@ void seat_execute_command(struct sway_seat *seat, struct sway_binding *binding) ipc_event_binding(binding); } } + +/** + * The last found keycode associated with the keysym + * and the total count of matches. + */ +struct keycode_matches { + xkb_keysym_t keysym; + xkb_keycode_t keycode; + int count; +}; + +/** + * Iterate through keycodes in the keymap to find ones matching + * the specified keysym. + */ +static void find_keycode(struct xkb_keymap *keymap, + xkb_keycode_t keycode, void *data) { + xkb_keysym_t keysym = xkb_state_key_get_one_sym( + config->keysym_translation.xkb_state, keycode); + + if (keysym == XKB_KEY_NoSymbol) { + return; + } + + struct keycode_matches *matches = data; + if (matches->keysym == keysym) { + matches->keycode = keycode; + matches->count++; + } +} + +/** + * Return the keycode for the specified keysym. + */ +static struct keycode_matches get_keycode_for_keysym(xkb_keysym_t keysym) { + struct keycode_matches matches = { + .keysym = keysym, + .keycode = XKB_KEYCODE_INVALID, + .count = 0, + }; + + xkb_keymap_key_for_each(config->keysym_translation.xkb_keymap, + find_keycode, &matches); + return matches; +} + +bool translate_binding(struct sway_binding *binding) { + if ((binding->flags & BINDING_CODE) == 0) { + return true; + } + + switch (binding->type) { + // a bindsym to translate + case BINDING_KEYSYM: + binding->syms = binding->keys; + binding->keys = create_list(); + break; + // a bindsym to re-translate + case BINDING_KEYCODE: + list_free_items_and_destroy(binding->keys); + binding->keys = create_list(); + break; + default: + return true; + } + + for (int i = 0; i < binding->syms->length; ++i) { + xkb_keysym_t *keysym = binding->syms->items[i]; + struct keycode_matches matches = get_keycode_for_keysym(*keysym); + + if (matches.count != 1) { + sway_log(SWAY_INFO, "Unable to convert keysym %d into" + " a single keycode (found %d matches)", + *keysym, matches.count); + goto error; + } + + xkb_keycode_t *keycode = malloc(sizeof(xkb_keycode_t)); + if (!keycode) { + sway_log(SWAY_ERROR, "Unable to allocate memory for a keycode"); + goto error; + } + + *keycode = matches.keycode; + list_add(binding->keys, keycode); + } + + list_qsort(binding->keys, key_qsort_cmp); + binding->type = BINDING_KEYCODE; + return true; + +error: + list_free_items_and_destroy(binding->keys); + binding->type = BINDING_KEYSYM; + binding->keys = binding->syms; + binding->syms = NULL; + return false; +} + +void binding_add_translated(struct sway_binding *binding, + list_t *mode_bindings) { + struct sway_binding *config_binding = + binding_upsert(binding, mode_bindings); + + if (config_binding) { + sway_log(SWAY_INFO, "Overwriting binding for device '%s' " + "to `%s` from `%s`", binding->input, + binding->command, config_binding->command); + free_sway_binding(config_binding); + } +} diff --git a/sway/commands/input.c b/sway/commands/input.c index b72bd76b..903d574f 100644 --- a/sway/commands/input.c +++ b/sway/commands/input.c @@ -39,6 +39,30 @@ static struct cmd_handler input_config_handlers[] = { { "xkb_numlock", input_cmd_xkb_numlock }, }; +/** + * Re-translate keysyms if a change in the input config could affect them. + */ +static void retranslate_keysyms(struct input_config *input_config) { + bool matched = false; + for (int i = 0; i < config->input_configs->length; ++i) { + struct input_config *ic = config->input_configs->items[i]; + matched |= ic->identifier == input_config->identifier; + + // the first configured xkb_layout + if (ic->xkb_layout) { + if (matched) { + translate_keysyms(ic->xkb_layout); + } + + // nothing has changed + return; + } + } + + // no xkb_layout has been set, restore the default + translate_keysyms(getenv("XKB_DEFAULT_LAYOUT")); +} + struct cmd_results *cmd_input(int argc, char **argv) { struct cmd_results *error = NULL; if ((error = checkarg(argc, "input", EXPECTED_AT_LEAST, 2))) { @@ -73,6 +97,7 @@ struct cmd_results *cmd_input(int argc, char **argv) { store_input_config(config->handler_context.input_config); input_manager_apply_input_config(ic); + retranslate_keysyms(ic); } else { free_input_config(config->handler_context.input_config); } diff --git a/sway/config.c b/sway/config.c index e14ea83a..45d16758 100644 --- a/sway/config.c +++ b/sway/config.c @@ -33,6 +33,31 @@ struct sway_config *config = NULL; +static struct keysym_translation_data new_keysym_translation_data( + const char *layout) { + struct xkb_rule_names rules = { + .layout = layout, + }; + + struct xkb_keymap *xkb_keymap = xkb_keymap_new_from_names( + xkb_context_new(XKB_CONTEXT_NO_FLAGS), + &rules, + XKB_KEYMAP_COMPILE_NO_FLAGS); + + struct keysym_translation_data result = { + .xkb_keymap = xkb_keymap, + .xkb_state = xkb_state_new(xkb_keymap), + }; + + return result; +} + +static void free_keysym_translation_data( + struct keysym_translation_data config) { + xkb_state_unref(config.xkb_state); + xkb_keymap_unref(config.xkb_keymap); +} + static void free_mode(struct sway_mode *mode) { if (!mode) { return; @@ -146,6 +171,7 @@ void free_config(struct sway_config *config) { free(config->swaynag_command); free((char *)config->current_config_path); free((char *)config->current_config); + free_keysym_translation_data(config->keysym_translation); free(config); } @@ -317,6 +343,9 @@ static void config_defaults(struct sway_config *config) { if (!(config->feature_policies = create_list())) goto cleanup; if (!(config->ipc_policies = create_list())) goto cleanup; + // The keysym to keycode translation + config->keysym_translation = new_keysym_translation_data(getenv("XKB_DEFAULT_LAYOUT")); + return; cleanup: sway_abort("Unable to allocate config structures"); @@ -937,3 +966,50 @@ void config_update_font_height(bool recalculate) { arrange_root(); } } + +static void translate_binding_list(list_t *bindings, list_t *bindsyms, + list_t *bindcodes) { + for (int i = 0; i < bindings->length; ++i) { + struct sway_binding *binding = bindings->items[i]; + translate_binding(binding); + + list_t *bindings; + switch (binding->type) { + case BINDING_KEYSYM: + bindings = bindsyms; + break; + case BINDING_KEYCODE: + bindings = bindcodes; + break; + default: + sway_assert(false, "unexpected translated binding type: %d", + binding->type); + break; + } + + binding_add_translated(binding, bindings); + } +} + +void translate_keysyms(const char *layout) { + free_keysym_translation_data(config->keysym_translation); + config->keysym_translation = new_keysym_translation_data(layout); + + for (int i = 0; i < config->modes->length; ++i) { + struct sway_mode *mode = config->modes->items[i]; + + list_t *bindsyms = create_list(); + list_t *bindcodes = create_list(); + + translate_binding_list(mode->keysym_bindings, bindsyms, bindcodes); + translate_binding_list(mode->keycode_bindings, bindsyms, bindcodes); + + list_free(mode->keysym_bindings); + list_free(mode->keycode_bindings); + + mode->keysym_bindings = bindsyms; + mode->keycode_bindings = bindcodes; + } + + sway_log(SWAY_DEBUG, "Translated keysyms for layout %s", layout); +} -- cgit v1.2.3