From ba69f06695c24f98a05d138a53ba130108ebce6f Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Wed, 27 Dec 2017 10:08:18 -0500 Subject: [PATCH 01/12] binding config --- include/sway/config.h | 3 +- sway/commands.c | 2 + sway/commands/bind.c | 173 ++++++++++++++++++++++++++++++++++++++++++ sway/config.c | 3 +- sway/meson.build | 1 + 5 files changed, 180 insertions(+), 2 deletions(-) create mode 100644 sway/commands/bind.c diff --git a/include/sway/config.h b/include/sway/config.h index 83ded7206..7146623eb 100644 --- a/include/sway/config.h +++ b/include/sway/config.h @@ -46,7 +46,8 @@ struct sway_mouse_binding { */ struct sway_mode { char *name; - list_t *bindings; + list_t *keysym_bindings; + list_t *keycode_bindings; }; /** diff --git a/sway/commands.c b/sway/commands.c index 34afb6a0f..b0078a468 100644 --- a/sway/commands.c +++ b/sway/commands.c @@ -127,6 +127,8 @@ struct cmd_results *add_color(const char *name, char *buffer, const char *color) /* Keep alphabetized */ static struct cmd_handler handlers[] = { + { "bindcode", cmd_bindcode }, + { "bindsym", cmd_bindsym }, { "exec", cmd_exec }, { "exec_always", cmd_exec_always }, { "exit", cmd_exit }, diff --git a/sway/commands/bind.c b/sway/commands/bind.c new file mode 100644 index 000000000..62aa535af --- /dev/null +++ b/sway/commands/bind.c @@ -0,0 +1,173 @@ +#ifdef __linux__ +#include +#elif __FreeBSD__ +#include +#endif +#include +#include +#include +#include "sway/commands.h" +#include "sway/config.h" +#include "list.h" +#include "log.h" +#include "stringop.h" +#include "util.h" + +int binding_order = 0; + +void free_sway_binding(struct sway_binding *binding) { + if (binding->keys) { + for (int i = 0; i < binding->keys->length; i++) { + free(binding->keys->items[i]); + } + list_free(binding->keys); + } + if (binding->command) { + free(binding->command); + } + free(binding); +} + +struct cmd_results *cmd_bindsym(int argc, char **argv) { + struct cmd_results *error = NULL; + if ((error = checkarg(argc, "bindsym", EXPECTED_MORE_THAN, 1))) { + return error; + } + + struct sway_binding *binding = malloc(sizeof(struct sway_binding)); + if (!binding) { + return cmd_results_new(CMD_FAILURE, "bindsym", + "Unable to allocate binding"); + } + binding->keys = create_list(); + binding->modifiers = 0; + binding->release = false; + binding->bindcode = false; + + // Handle --release + if (strcmp("--release", argv[0]) == 0) { + if (argc >= 3) { + binding->release = true; + argv++; + argc--; + } else { + free_sway_binding(binding); + return cmd_results_new(CMD_FAILURE, "bindsym", + "Invalid bindsym command " + "(expected more than 2 arguments, got %d)", argc); + } + } + + binding->command = join_args(argv + 1, argc - 1); + + list_t *split = split_string(argv[0], "+"); + for (int i = 0; i < split->length; ++i) { + // Check for a modifier key + uint32_t mod; + if ((mod = get_modifier_mask_by_name(split->items[i])) > 0) { + binding->modifiers |= mod; + continue; + } + // Check for xkb key + xkb_keysym_t sym = xkb_keysym_from_name(split->items[i], + XKB_KEYSYM_CASE_INSENSITIVE); + + // Check for mouse binding + if (strncasecmp(split->items[i], "button", strlen("button")) == 0 && + strlen(split->items[i]) == strlen("button0")) { + sym = ((char *)split->items[i])[strlen("button")] - '1' + BTN_LEFT; + } + if (!sym) { + struct cmd_results *ret = cmd_results_new(CMD_INVALID, "bindsym", + "Unknown key '%s'", (char *)split->items[i]); + free_sway_binding(binding); + free_flat_list(split); + return ret; + } + xkb_keysym_t *key = malloc(sizeof(xkb_keysym_t)); + if (!key) { + free_sway_binding(binding); + free_flat_list(split); + return cmd_results_new(CMD_FAILURE, "bindsym", + "Unable to allocate binding"); + } + *key = sym; + list_add(binding->keys, key); + } + free_flat_list(split); + + struct sway_mode *mode = config->current_mode; + // TODO overwrite the binding if it already exists + binding->order = binding_order++; + list_add(mode->keysym_bindings, binding); + + sway_log(L_DEBUG, "bindsym - Bound %s to command %s", + argv[0], binding->command); + return cmd_results_new(CMD_SUCCESS, NULL, NULL); +} + +struct cmd_results *cmd_bindcode(int argc, char **argv) { + struct cmd_results *error = NULL; + if ((error = checkarg(argc, "bindcode", EXPECTED_MORE_THAN, 1))) { + return error; + } + + struct sway_binding *binding = malloc(sizeof(struct sway_binding)); + if (!binding) { + return cmd_results_new(CMD_FAILURE, "bindsym", + "Unable to allocate binding"); + } + binding->keys = create_list(); + binding->modifiers = 0; + binding->release = false; + binding->bindcode = true; + + // Handle --release + if (strcmp("--release", argv[0]) == 0) { + if (argc >= 3) { + binding->release = true; + argv++; + argc--; + } else { + free_sway_binding(binding); + return cmd_results_new(CMD_FAILURE, "bindcode", + "Invalid bindcode command " + "(expected more than 2 arguments, got %d)", argc); + } + } + + binding->command = join_args(argv + 1, argc - 1); + + list_t *split = split_string(argv[0], "+"); + for (int i = 0; i < split->length; ++i) { + // Check for a modifier key + uint32_t mod; + if ((mod = get_modifier_mask_by_name(split->items[i])) > 0) { + binding->modifiers |= mod; + continue; + } + // parse keycode + xkb_keycode_t keycode = (int)strtol(split->items[i], NULL, 10); + if (!xkb_keycode_is_legal_ext(keycode)) { + error = + cmd_results_new(CMD_INVALID, "bindcode", + "Invalid keycode '%s'", (char *)split->items[i]); + free_sway_binding(binding); + list_free(split); + return error; + } + xkb_keycode_t *key = malloc(sizeof(xkb_keycode_t)); + *key = keycode - 8; + list_add(binding->keys, key); + } + free_flat_list(split); + + struct sway_mode *mode = config->current_mode; + // TODO overwrite binding if it already exists + binding->order = binding_order++; + list_add(mode->keycode_bindings, binding); + + sway_log(L_DEBUG, "bindcode - Bound %s to command %s", + argv[0], binding->command); + return cmd_results_new(CMD_SUCCESS, NULL, NULL); +} diff --git a/sway/config.c b/sway/config.c index b591ae9e4..312e0779c 100644 --- a/sway/config.c +++ b/sway/config.c @@ -53,7 +53,8 @@ static void config_defaults(struct sway_config *config) { goto cleanup; if (!(config->current_mode->name = malloc(sizeof("default")))) goto cleanup; strcpy(config->current_mode->name, "default"); - if (!(config->current_mode->bindings = create_list())) goto cleanup; + if (!(config->current_mode->keysym_bindings = create_list())) goto cleanup; + if (!(config->current_mode->keycode_bindings = create_list())) goto cleanup; list_add(config->modes, config->current_mode); config->floating_mod = 0; diff --git a/sway/meson.build b/sway/meson.build index fee2ddd21..01d5ef36d 100644 --- a/sway/meson.build +++ b/sway/meson.build @@ -6,6 +6,7 @@ sway_sources = files( 'input/seat.c', 'input/cursor.c', 'input/keyboard.c', + 'commands/bind.c', 'commands/exit.c', 'commands/exec.c', 'commands/exec_always.c', From eea80e7276f49e5d07b22db071f3ab0b6f9ffe18 Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Wed, 27 Dec 2017 13:20:28 -0500 Subject: [PATCH 02/12] keyboard translate keysyms --- include/sway/input/keyboard.h | 5 ++ sway/input/keyboard.c | 147 +++++++++++++++++++++++++++++++++- 2 files changed, 149 insertions(+), 3 deletions(-) diff --git a/include/sway/input/keyboard.h b/include/sway/input/keyboard.h index d9251f4c3..0a5857f0a 100644 --- a/include/sway/input/keyboard.h +++ b/include/sway/input/keyboard.h @@ -3,6 +3,8 @@ #include "sway/input/seat.h" +#define SWAY_KEYBOARD_PRESSED_KEYSYMS_CAP 32 + struct sway_keyboard { struct sway_seat_device *seat_device; @@ -10,6 +12,9 @@ struct sway_keyboard { struct wl_listener keyboard_key; struct wl_listener keyboard_modifiers; + + xkb_keysym_t pressed_keysyms_translated[SWAY_KEYBOARD_PRESSED_KEYSYMS_CAP]; + xkb_keysym_t pressed_keysyms_raw[SWAY_KEYBOARD_PRESSED_KEYSYMS_CAP]; }; struct sway_keyboard *sway_keyboard_create(struct sway_seat *seat, diff --git a/sway/input/keyboard.c b/sway/input/keyboard.c index 724941d85..25def7acc 100644 --- a/sway/input/keyboard.c +++ b/sway/input/keyboard.c @@ -3,6 +3,121 @@ #include "sway/input/input-manager.h" #include "log.h" +/* + * Get keysyms and modifiers from the keyboard as xkb sees them. + * + * This uses the xkb keysyms translation based on pressed modifiers and clears + * the consumed modifiers from the list of modifiers passed to keybind + * detection. + * + * On US layout, pressing Alt+Shift+2 will trigger Alt+@. + */ +static size_t keyboard_keysyms_translated(struct sway_keyboard *keyboard, + xkb_keycode_t keycode, const xkb_keysym_t **keysyms, + uint32_t *modifiers) { + struct wlr_input_device *device = + keyboard->seat_device->input_device->wlr_device; + *modifiers = wlr_keyboard_get_modifiers(device->keyboard); + xkb_mod_mask_t consumed = xkb_state_key_get_consumed_mods2( + device->keyboard->xkb_state, keycode, XKB_CONSUMED_MODE_XKB); + *modifiers = *modifiers & ~consumed; + + return xkb_state_key_get_syms(device->keyboard->xkb_state, + keycode, keysyms); +} + +/* + * Get keysyms and modifiers from the keyboard as if modifiers didn't change + * keysyms. + * + * This avoids the xkb keysym translation based on modifiers considered pressed + * in the state. + * + * This will trigger keybinds such as Alt+Shift+2. + */ +static size_t keyboard_keysyms_raw(struct sway_keyboard *keyboard, + xkb_keycode_t keycode, const xkb_keysym_t **keysyms, + uint32_t *modifiers) { + struct wlr_input_device *device = + keyboard->seat_device->input_device->wlr_device; + *modifiers = wlr_keyboard_get_modifiers(device->keyboard); + + xkb_layout_index_t layout_index = xkb_state_key_get_layout( + device->keyboard->xkb_state, keycode); + return xkb_keymap_key_get_syms_by_level(device->keyboard->keymap, + keycode, layout_index, 0, keysyms); +} + +static ssize_t pressed_keysyms_index(xkb_keysym_t *pressed_keysyms, + xkb_keysym_t keysym) { + for (size_t i = 0; i < SWAY_KEYBOARD_PRESSED_KEYSYMS_CAP; ++i) { + if (pressed_keysyms[i] == keysym) { + return i; + } + } + return -1; +} + +static size_t pressed_keysyms_length(xkb_keysym_t *pressed_keysyms) { + size_t n = 0; + for (size_t i = 0; i < SWAY_KEYBOARD_PRESSED_KEYSYMS_CAP; ++i) { + if (pressed_keysyms[i] != XKB_KEY_NoSymbol) { + ++n; + } + } + return n; +} + +static void pressed_keysyms_add(xkb_keysym_t *pressed_keysyms, + xkb_keysym_t keysym) { + ssize_t i = pressed_keysyms_index(pressed_keysyms, keysym); + if (i < 0) { + i = pressed_keysyms_index(pressed_keysyms, XKB_KEY_NoSymbol); + if (i >= 0) { + pressed_keysyms[i] = keysym; + } + } +} + +static void pressed_keysyms_remove(xkb_keysym_t *pressed_keysyms, + xkb_keysym_t keysym) { + ssize_t i = pressed_keysyms_index(pressed_keysyms, keysym); + if (i >= 0) { + pressed_keysyms[i] = XKB_KEY_NoSymbol; + } +} + +static bool keysym_is_modifier(xkb_keysym_t keysym) { + switch (keysym) { + case XKB_KEY_Shift_L: case XKB_KEY_Shift_R: + case XKB_KEY_Control_L: case XKB_KEY_Control_R: + case XKB_KEY_Caps_Lock: + case XKB_KEY_Shift_Lock: + case XKB_KEY_Meta_L: case XKB_KEY_Meta_R: + case XKB_KEY_Alt_L: case XKB_KEY_Alt_R: + case XKB_KEY_Super_L: case XKB_KEY_Super_R: + case XKB_KEY_Hyper_L: case XKB_KEY_Hyper_R: + return true; + default: + return false; + } +} + +static void pressed_keysyms_update(xkb_keysym_t *pressed_keysyms, + const xkb_keysym_t *keysyms, size_t keysyms_len, + enum wlr_key_state state) { + for (size_t i = 0; i < keysyms_len; ++i) { + if (keysym_is_modifier(keysyms[i])) { + continue; + } + if (state == WLR_KEY_PRESSED) { + pressed_keysyms_add(pressed_keysyms, keysyms[i]); + } else { // WLR_KEY_RELEASED + pressed_keysyms_remove(pressed_keysyms, keysyms[i]); + } + } +} + static void handle_keyboard_key(struct wl_listener *listener, void *data) { struct sway_keyboard *keyboard = wl_container_of(listener, keyboard, keyboard_key); @@ -10,9 +125,35 @@ static void handle_keyboard_key(struct wl_listener *listener, void *data) { struct wlr_input_device *wlr_device = keyboard->seat_device->input_device->wlr_device; struct wlr_event_keyboard_key *event = data; - wlr_seat_set_keyboard(wlr_seat, wlr_device); - wlr_seat_keyboard_notify_key(wlr_seat, event->time_msec, - event->keycode, event->state); + + xkb_keycode_t keycode = event->keycode + 8; + bool handled = false; + uint32_t modifiers; + const xkb_keysym_t *keysyms; + size_t keysyms_len; + + // handle translated keysyms + keysyms_len = keyboard_keysyms_translated(keyboard, keycode, &keysyms, + &modifiers); + pressed_keysyms_update(keyboard->pressed_keysyms_translated, keysyms, + keysyms_len, event->state); + if (event->state == WLR_KEY_PRESSED) { + // TODO execute binding + } + + // Handle raw keysyms + keysyms_len = keyboard_keysyms_raw(keyboard, keycode, &keysyms, &modifiers); + pressed_keysyms_update(keyboard->pressed_keysyms_raw, keysyms, keysyms_len, + event->state); + if (event->state == WLR_KEY_PRESSED && !handled) { + // TODO execute binding + } + + if (!handled) { + wlr_seat_set_keyboard(wlr_seat, wlr_device); + wlr_seat_keyboard_notify_key(wlr_seat, event->time_msec, + event->keycode, event->state); + } } static void handle_keyboard_modifiers(struct wl_listener *listener, From daad22233765716d0b7ba5ba5dc7492f59e63097 Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Wed, 27 Dec 2017 13:31:31 -0500 Subject: [PATCH 03/12] compositor bindings --- sway/input/keyboard.c | 51 +++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 49 insertions(+), 2 deletions(-) diff --git a/sway/input/keyboard.c b/sway/input/keyboard.c index 25def7acc..68a95bac2 100644 --- a/sway/input/keyboard.c +++ b/sway/input/keyboard.c @@ -1,8 +1,52 @@ +#include +#include #include "sway/input/seat.h" #include "sway/input/keyboard.h" #include "sway/input/input-manager.h" #include "log.h" +/** + * Execute a built-in, hardcoded compositor binding. These are triggered from a + * single keysym. + * + * Returns true if the keysym was handled by a binding and false if the event + * should be propagated to clients. + */ +static bool keyboard_execute_compositor_binding(xkb_keysym_t keysym) { + if (keysym >= XKB_KEY_XF86Switch_VT_1 && + keysym <= XKB_KEY_XF86Switch_VT_12) { + if (wlr_backend_is_multi(server.backend)) { + struct wlr_session *session = + wlr_multi_get_session(server.backend); + if (session) { + unsigned vt = keysym - XKB_KEY_XF86Switch_VT_1 + 1; + wlr_session_change_vt(session, vt); + } + } + return true; + } + + return false; +} + +/** + * Execute keyboard bindings. These include compositor bindings and user-defined + * bindings. + * + * Returns true if the keysym was handled by a binding and false if the event + * should be propagated to clients. + */ +static bool keyboard_execute_binding(struct sway_keyboard *keyboard, + xkb_keysym_t *pressed_keysyms, uint32_t modifiers, + const xkb_keysym_t *keysyms, size_t keysyms_len) { + for (size_t i = 0; i < keysyms_len; ++i) { + if (keyboard_execute_compositor_binding(keysyms[i])) { + return true; + } + } + return false; +} + /* * Get keysyms and modifiers from the keyboard as xkb sees them. * @@ -138,7 +182,9 @@ static void handle_keyboard_key(struct wl_listener *listener, void *data) { pressed_keysyms_update(keyboard->pressed_keysyms_translated, keysyms, keysyms_len, event->state); if (event->state == WLR_KEY_PRESSED) { - // TODO execute binding + handled = keyboard_execute_binding(keyboard, + keyboard->pressed_keysyms_translated, modifiers, keysyms, + keysyms_len); } // Handle raw keysyms @@ -146,7 +192,8 @@ static void handle_keyboard_key(struct wl_listener *listener, void *data) { pressed_keysyms_update(keyboard->pressed_keysyms_raw, keysyms, keysyms_len, event->state); if (event->state == WLR_KEY_PRESSED && !handled) { - // TODO execute binding + handled = keyboard_execute_binding(keyboard, + keyboard->pressed_keysyms_raw, modifiers, keysyms, keysyms_len); } if (!handled) { From d941246d58b55b56179cfe159bec5b4bfb201d2e Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Wed, 27 Dec 2017 15:17:01 -0500 Subject: [PATCH 04/12] match user bindsym --- sway/input/keyboard.c | 69 ++++++++++++++++++++++++++++++------------- 1 file changed, 49 insertions(+), 20 deletions(-) diff --git a/sway/input/keyboard.c b/sway/input/keyboard.c index 68a95bac2..326ee5845 100644 --- a/sway/input/keyboard.c +++ b/sway/input/keyboard.c @@ -5,6 +5,27 @@ #include "sway/input/input-manager.h" #include "log.h" +static size_t pressed_keysyms_length(xkb_keysym_t *pressed_keysyms) { + size_t n = 0; + for (size_t i = 0; i < SWAY_KEYBOARD_PRESSED_KEYSYMS_CAP; ++i) { + if (pressed_keysyms[i] != XKB_KEY_NoSymbol) { + ++n; + } + } + return n; +} + +static ssize_t pressed_keysyms_index(xkb_keysym_t *pressed_keysyms, + xkb_keysym_t keysym) { + for (size_t i = 0; i < SWAY_KEYBOARD_PRESSED_KEYSYMS_CAP; ++i) { + if (pressed_keysyms[i] == keysym) { + return i; + } + } + return -1; +} + + /** * Execute a built-in, hardcoded compositor binding. These are triggered from a * single keysym. @@ -39,11 +60,39 @@ static bool keyboard_execute_compositor_binding(xkb_keysym_t keysym) { static bool keyboard_execute_binding(struct sway_keyboard *keyboard, xkb_keysym_t *pressed_keysyms, uint32_t modifiers, const xkb_keysym_t *keysyms, size_t keysyms_len) { + // compositor bindings for (size_t i = 0; i < keysyms_len; ++i) { if (keyboard_execute_compositor_binding(keysyms[i])) { return true; } } + + // configured bindings + int n = pressed_keysyms_length(pressed_keysyms); + list_t *keysym_bindings = config->current_mode->keysym_bindings; + for (int i = 0; i < keysym_bindings->length; ++i) { + struct sway_binding *binding = keysym_bindings->items[i]; + if (modifiers ^ binding->modifiers || n != binding->keys->length) { + continue; + } + + bool match = true; + for (int j = 0; j < binding->keys->length; ++j) { + match = + pressed_keysyms_index(pressed_keysyms, + *(int*)binding->keys->items[j]) < 0; + + if (!match) { + break; + } + } + + if (match) { + sway_log(L_DEBUG, "TODO: executing binding command: %s", binding->command); + return true; + } + } + return false; } @@ -92,26 +141,6 @@ static size_t keyboard_keysyms_raw(struct sway_keyboard *keyboard, keycode, layout_index, 0, keysyms); } -static ssize_t pressed_keysyms_index(xkb_keysym_t *pressed_keysyms, - xkb_keysym_t keysym) { - for (size_t i = 0; i < SWAY_KEYBOARD_PRESSED_KEYSYMS_CAP; ++i) { - if (pressed_keysyms[i] == keysym) { - return i; - } - } - return -1; -} - -static size_t pressed_keysyms_length(xkb_keysym_t *pressed_keysyms) { - size_t n = 0; - for (size_t i = 0; i < SWAY_KEYBOARD_PRESSED_KEYSYMS_CAP; ++i) { - if (pressed_keysyms[i] != XKB_KEY_NoSymbol) { - ++n; - } - } - return n; -} - static void pressed_keysyms_add(xkb_keysym_t *pressed_keysyms, xkb_keysym_t keysym) { ssize_t i = pressed_keysyms_index(pressed_keysyms, keysym); From ccaedf5b1535db37f36d7eb1424d6fae5b1ac12a Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Wed, 27 Dec 2017 15:25:16 -0500 Subject: [PATCH 05/12] run binding command --- sway/input/keyboard.c | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/sway/input/keyboard.c b/sway/input/keyboard.c index 326ee5845..8b43df825 100644 --- a/sway/input/keyboard.c +++ b/sway/input/keyboard.c @@ -3,6 +3,7 @@ #include "sway/input/seat.h" #include "sway/input/keyboard.h" #include "sway/input/input-manager.h" +#include "sway/commands.h" #include "log.h" static size_t pressed_keysyms_length(xkb_keysym_t *pressed_keysyms) { @@ -80,7 +81,7 @@ static bool keyboard_execute_binding(struct sway_keyboard *keyboard, for (int j = 0; j < binding->keys->length; ++j) { match = pressed_keysyms_index(pressed_keysyms, - *(int*)binding->keys->items[j]) < 0; + *(int*)binding->keys->items[j]) >= 0; if (!match) { break; @@ -88,7 +89,13 @@ static bool keyboard_execute_binding(struct sway_keyboard *keyboard, } if (match) { - sway_log(L_DEBUG, "TODO: executing binding command: %s", binding->command); + sway_log(L_DEBUG, "running command for binding: %s", binding->command); + struct cmd_results *results = handle_command(binding->command); + if (results->status != CMD_SUCCESS) { + sway_log(L_DEBUG, "could not run command for binding: %s", + binding->command); + } + free_cmd_results(results); return true; } } From 27cd633b409bbe6692538a26738e052e7d865be0 Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Wed, 27 Dec 2017 19:07:17 -0500 Subject: [PATCH 06/12] run compositor bindings last --- sway/input/keyboard.c | 82 ++++++++++++++++++++++++++----------------- 1 file changed, 49 insertions(+), 33 deletions(-) diff --git a/sway/input/keyboard.c b/sway/input/keyboard.c index 8b43df825..032083e9d 100644 --- a/sway/input/keyboard.c +++ b/sway/input/keyboard.c @@ -34,18 +34,22 @@ static ssize_t pressed_keysyms_index(xkb_keysym_t *pressed_keysyms, * Returns true if the keysym was handled by a binding and false if the event * should be propagated to clients. */ -static bool keyboard_execute_compositor_binding(xkb_keysym_t keysym) { - if (keysym >= XKB_KEY_XF86Switch_VT_1 && - keysym <= XKB_KEY_XF86Switch_VT_12) { - if (wlr_backend_is_multi(server.backend)) { - struct wlr_session *session = - wlr_multi_get_session(server.backend); - if (session) { - unsigned vt = keysym - XKB_KEY_XF86Switch_VT_1 + 1; - wlr_session_change_vt(session, vt); +static bool keyboard_execute_compositor_binding(struct sway_keyboard *keyboard, + xkb_keysym_t *pressed_keysyms, uint32_t modifiers, size_t keysyms_len) { + for (size_t i = 0; i < keysyms_len; ++i) { + xkb_keysym_t keysym = pressed_keysyms[i]; + if (keysym >= XKB_KEY_XF86Switch_VT_1 && + keysym <= XKB_KEY_XF86Switch_VT_12) { + if (wlr_backend_is_multi(server.backend)) { + struct wlr_session *session = + wlr_multi_get_session(server.backend); + if (session) { + unsigned vt = keysym - XKB_KEY_XF86Switch_VT_1 + 1; + wlr_session_change_vt(session, vt); + } } + return true; } - return true; } return false; @@ -58,16 +62,8 @@ static bool keyboard_execute_compositor_binding(xkb_keysym_t keysym) { * Returns true if the keysym was handled by a binding and false if the event * should be propagated to clients. */ -static bool keyboard_execute_binding(struct sway_keyboard *keyboard, - xkb_keysym_t *pressed_keysyms, uint32_t modifiers, - const xkb_keysym_t *keysyms, size_t keysyms_len) { - // compositor bindings - for (size_t i = 0; i < keysyms_len; ++i) { - if (keyboard_execute_compositor_binding(keysyms[i])) { - return true; - } - } - +static bool keyboard_execute_bindsym(struct sway_keyboard *keyboard, + xkb_keysym_t *pressed_keysyms, uint32_t modifiers, size_t keysyms_len) { // configured bindings int n = pressed_keysyms_length(pressed_keysyms); list_t *keysym_bindings = config->current_mode->keysym_bindings; @@ -208,28 +204,48 @@ static void handle_keyboard_key(struct wl_listener *listener, void *data) { xkb_keycode_t keycode = event->keycode + 8; bool handled = false; - uint32_t modifiers; const xkb_keysym_t *keysyms; - size_t keysyms_len; + + // handle keycodes + // TODO + handled = keyboard_execute_bindcode(keyboard); // handle translated keysyms - keysyms_len = keyboard_keysyms_translated(keyboard, keycode, &keysyms, - &modifiers); + uint32_t translated_modifiers; + size_t translated_keysyms_len = + keyboard_keysyms_translated(keyboard, keycode, &keysyms, + &translated_modifiers); pressed_keysyms_update(keyboard->pressed_keysyms_translated, keysyms, - keysyms_len, event->state); - if (event->state == WLR_KEY_PRESSED) { - handled = keyboard_execute_binding(keyboard, - keyboard->pressed_keysyms_translated, modifiers, keysyms, - keysyms_len); + translated_keysyms_len, event->state); + if (event->state == WLR_KEY_PRESSED && !handled) { + handled = keyboard_execute_bindsym(keyboard, + keyboard->pressed_keysyms_translated, translated_modifiers, + translated_keysyms_len); } // Handle raw keysyms - keysyms_len = keyboard_keysyms_raw(keyboard, keycode, &keysyms, &modifiers); - pressed_keysyms_update(keyboard->pressed_keysyms_raw, keysyms, keysyms_len, + uint32_t raw_modifiers; + size_t raw_keysyms_len = keyboard_keysyms_raw(keyboard, keycode, &keysyms, &raw_modifiers); + pressed_keysyms_update(keyboard->pressed_keysyms_raw, keysyms, raw_keysyms_len, event->state); if (event->state == WLR_KEY_PRESSED && !handled) { - handled = keyboard_execute_binding(keyboard, - keyboard->pressed_keysyms_raw, modifiers, keysyms, keysyms_len); + handled = keyboard_execute_bindsym(keyboard, + keyboard->pressed_keysyms_raw, raw_modifiers, + raw_keysyms_len); + } + + // Compositor bindings + if (event->state == WLR_KEY_PRESSED && !handled) { + handled = + keyboard_execute_compositor_binding(keyboard, + keyboard->pressed_keysyms_translated, translated_modifiers, + translated_keysyms_len); + } + if (event->state == WLR_KEY_PRESSED && !handled) { + handled = + keyboard_execute_compositor_binding(keyboard, + keyboard->pressed_keysyms_raw, raw_modifiers, + raw_keysyms_len); } if (!handled) { From 8d567cd06202b4d68bf45af6e76e5bdc49bfffee Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Thu, 28 Dec 2017 14:51:17 -0500 Subject: [PATCH 07/12] bindcode --- sway/input/keyboard.c | 128 ++++++++++++++++++++++++++++++++++-------- 1 file changed, 106 insertions(+), 22 deletions(-) diff --git a/sway/input/keyboard.c b/sway/input/keyboard.c index 032083e9d..2464db121 100644 --- a/sway/input/keyboard.c +++ b/sway/input/keyboard.c @@ -26,7 +26,6 @@ static ssize_t pressed_keysyms_index(xkb_keysym_t *pressed_keysyms, return -1; } - /** * Execute a built-in, hardcoded compositor binding. These are triggered from a * single keysym. @@ -56,8 +55,7 @@ static bool keyboard_execute_compositor_binding(struct sway_keyboard *keyboard, } /** - * Execute keyboard bindings. These include compositor bindings and user-defined - * bindings. + * Execute keyboard bindings bound with `bindysm`. * * Returns true if the keysym was handled by a binding and false if the event * should be propagated to clients. @@ -99,7 +97,110 @@ static bool keyboard_execute_bindsym(struct sway_keyboard *keyboard, return false; } -/* +static bool keysym_is_modifier(xkb_keysym_t keysym) { + switch (keysym) { + case XKB_KEY_Shift_L: case XKB_KEY_Shift_R: + case XKB_KEY_Control_L: case XKB_KEY_Control_R: + case XKB_KEY_Caps_Lock: + case XKB_KEY_Shift_Lock: + case XKB_KEY_Meta_L: case XKB_KEY_Meta_R: + case XKB_KEY_Alt_L: case XKB_KEY_Alt_R: + case XKB_KEY_Super_L: case XKB_KEY_Super_R: + case XKB_KEY_Hyper_L: case XKB_KEY_Hyper_R: + return true; + default: + return false; + } +} + +static bool binding_matches_keycodes(struct wlr_keyboard *keyboard, + struct sway_binding *binding) { + uint32_t modifiers = wlr_keyboard_get_modifiers(keyboard); + if (modifiers ^ binding->modifiers) { + return false; + } + + // every keycode in the binding must be present in the pressed keys on the + // keyboard + for (int i = 0; i < binding->keys->length; ++i) { + uint32_t binding_keycode = *(uint32_t*)binding->keys->items[i] + 8; + bool found = false; + for (size_t j = 0; j < keyboard->num_keycodes; ++j) { + xkb_keycode_t keycode = keyboard->keycodes[j] + 8; + if (keycode == binding_keycode) { + found = true; + break; + } + } + + if (!found) { + return false; + } + } + + // every keycode pressed on the keyboard must be present within the binding + // keys (unless it is a modifier) + for (size_t i = 0; i < keyboard->num_keycodes; ++i) { + xkb_keycode_t keycode = keyboard->keycodes[i] + 8; + bool found = false; + for (int j = 0; j < binding->keys->length; ++j) { + uint32_t binding_keycode = *(uint32_t*)binding->keys->items[j] + 8; + if (binding_keycode == keycode) { + found = true; + break; + } + } + + if (!found) { + if (!binding->modifiers) { + return false; + } + + // check if it is a modifier, which we know matched from the check + // above + const xkb_keysym_t *keysyms; + int num_keysyms = + xkb_state_key_get_syms(keyboard->xkb_state, + keycode, &keysyms); + if (num_keysyms != 1 || !keysym_is_modifier(keysyms[0])) { + return false; + } + } + } + + return true; +} + +/** + * Execute keyboard bindings bound with `bindcode`. + * + * Returns true if the keysym was handled by a binding and false if the event + * should be propagated to clients. + */ +static bool keyboard_execute_bindcode(struct sway_keyboard *keyboard) { + struct wlr_keyboard *wlr_keyboard = + keyboard->seat_device->input_device->wlr_device->keyboard; + list_t *keycode_bindings = config->current_mode->keycode_bindings; + for (int i = 0; i < keycode_bindings->length; ++i) { + struct sway_binding *binding = keycode_bindings->items[i]; + //bool match = true; + for (int j = 0; j < binding->keys->length; ++j) { + if (binding_matches_keycodes(wlr_keyboard, binding)) { + struct cmd_results *results = handle_command(binding->command); + if (results->status != CMD_SUCCESS) { + sway_log(L_DEBUG, "could not run command for binding: %s", + binding->command); + } + free_cmd_results(results); + return true; + } + } + } + + return false; +} + +/** * Get keysyms and modifiers from the keyboard as xkb sees them. * * This uses the xkb keysyms translation based on pressed modifiers and clears @@ -122,7 +223,7 @@ static size_t keyboard_keysyms_translated(struct sway_keyboard *keyboard, keycode, keysyms); } -/* +/** * Get keysyms and modifiers from the keyboard as if modifiers didn't change * keysyms. * @@ -163,22 +264,6 @@ static void pressed_keysyms_remove(xkb_keysym_t *pressed_keysyms, } } -static bool keysym_is_modifier(xkb_keysym_t keysym) { - switch (keysym) { - case XKB_KEY_Shift_L: case XKB_KEY_Shift_R: - case XKB_KEY_Control_L: case XKB_KEY_Control_R: - case XKB_KEY_Caps_Lock: - case XKB_KEY_Shift_Lock: - case XKB_KEY_Meta_L: case XKB_KEY_Meta_R: - case XKB_KEY_Alt_L: case XKB_KEY_Alt_R: - case XKB_KEY_Super_L: case XKB_KEY_Super_R: - case XKB_KEY_Hyper_L: case XKB_KEY_Hyper_R: - return true; - default: - return false; - } -} - static void pressed_keysyms_update(xkb_keysym_t *pressed_keysyms, const xkb_keysym_t *keysyms, size_t keysyms_len, enum wlr_key_state state) { @@ -207,7 +292,6 @@ static void handle_keyboard_key(struct wl_listener *listener, void *data) { const xkb_keysym_t *keysyms; // handle keycodes - // TODO handled = keyboard_execute_bindcode(keyboard); // handle translated keysyms From 0b8481f41af32daf75324fc1f202bce62cc702f4 Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Thu, 28 Dec 2017 16:52:12 -0500 Subject: [PATCH 08/12] fix keyboard_execute_bindcode --- sway/input/keyboard.c | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/sway/input/keyboard.c b/sway/input/keyboard.c index 2464db121..eacb6ceb4 100644 --- a/sway/input/keyboard.c +++ b/sway/input/keyboard.c @@ -183,17 +183,14 @@ static bool keyboard_execute_bindcode(struct sway_keyboard *keyboard) { list_t *keycode_bindings = config->current_mode->keycode_bindings; for (int i = 0; i < keycode_bindings->length; ++i) { struct sway_binding *binding = keycode_bindings->items[i]; - //bool match = true; - for (int j = 0; j < binding->keys->length; ++j) { - if (binding_matches_keycodes(wlr_keyboard, binding)) { - struct cmd_results *results = handle_command(binding->command); - if (results->status != CMD_SUCCESS) { - sway_log(L_DEBUG, "could not run command for binding: %s", - binding->command); - } - free_cmd_results(results); - return true; + if (binding_matches_keycodes(wlr_keyboard, binding)) { + struct cmd_results *results = handle_command(binding->command); + if (results->status != CMD_SUCCESS) { + sway_log(L_DEBUG, "could not run command for binding: %s", + binding->command); } + free_cmd_results(results); + return true; } } From 62b7ab3959468124086a1ba95361b3eed069b4a7 Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Thu, 28 Dec 2017 18:50:22 -0500 Subject: [PATCH 09/12] overwrite old bindings --- sway/commands/bind.c | 83 +++++++++++++++++++++++++++++++++++++++---- sway/input/keyboard.c | 14 +++++--- 2 files changed, 85 insertions(+), 12 deletions(-) diff --git a/sway/commands/bind.c b/sway/commands/bind.c index 62aa535af..99f54f465 100644 --- a/sway/commands/bind.c +++ b/sway/commands/bind.c @@ -28,6 +28,44 @@ void free_sway_binding(struct sway_binding *binding) { free(binding); } +/** + * Returns true if the bindings have the same key and modifier combinations. + * Note that keyboard layout is not considered, so the bindings might actually + * not be equivalent on some layouts. + */ +bool binding_key_compare(struct sway_binding *binding_a, + struct sway_binding *binding_b) { + if (binding_a->bindcode != binding_b->bindcode) { + return false; + } + + if (binding_a->modifiers ^ binding_b->modifiers) { + return false; + } + + if (binding_a->keys->length != binding_b->keys->length) { + return false; + } + + int keys_len = binding_a->keys->length; + for (int i = 0; i < keys_len; ++i) { + uint32_t key_a = *(uint32_t*)binding_a->keys->items[i]; + bool found = false; + for (int j = 0; j < keys_len; ++j) { + uint32_t key_b = *(uint32_t*)binding_b->keys->items[j]; + if (key_b == key_a) { + found = true; + break; + } + } + if (!found) { + return false; + } + } + + return true; +} + struct cmd_results *cmd_bindsym(int argc, char **argv) { struct cmd_results *error = NULL; if ((error = checkarg(argc, "bindsym", EXPECTED_MORE_THAN, 1))) { @@ -95,11 +133,26 @@ struct cmd_results *cmd_bindsym(int argc, char **argv) { list_add(binding->keys, key); } free_flat_list(split); - - struct sway_mode *mode = config->current_mode; - // TODO overwrite the binding if it already exists binding->order = binding_order++; - list_add(mode->keysym_bindings, binding); + + list_t *mode_bindings = config->current_mode->keysym_bindings; + + // overwrite the binding if it already exists + bool overwritten = false; + 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(L_DEBUG, "overwriting old binding with command '%s'", + config_binding->command); + free_sway_binding(config_binding); + mode_bindings->items[i] = binding; + overwritten = true; + } + } + + if (!overwritten) { + list_add(mode_bindings, binding); + } sway_log(L_DEBUG, "bindsym - Bound %s to command %s", argv[0], binding->command); @@ -162,10 +215,26 @@ struct cmd_results *cmd_bindcode(int argc, char **argv) { } free_flat_list(split); - struct sway_mode *mode = config->current_mode; - // TODO overwrite binding if it already exists binding->order = binding_order++; - list_add(mode->keycode_bindings, binding); + + list_t *mode_bindings = config->current_mode->keycode_bindings; + + // overwrite the binding if it already exists + bool overwritten = false; + 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(L_DEBUG, "overwriting old binding with command '%s'", + config_binding->command); + free_sway_binding(config_binding); + mode_bindings->items[i] = binding; + overwritten = true; + } + } + + if (!overwritten) { + list_add(mode_bindings, binding); + } sway_log(L_DEBUG, "bindcode - Bound %s to command %s", argv[0], binding->command); diff --git a/sway/input/keyboard.c b/sway/input/keyboard.c index eacb6ceb4..6272dcce5 100644 --- a/sway/input/keyboard.c +++ b/sway/input/keyboard.c @@ -67,7 +67,9 @@ static bool keyboard_execute_bindsym(struct sway_keyboard *keyboard, list_t *keysym_bindings = config->current_mode->keysym_bindings; for (int i = 0; i < keysym_bindings->length; ++i) { struct sway_binding *binding = keysym_bindings->items[i]; + sway_log(L_DEBUG, "@@ checking binding: %s", binding->command); if (modifiers ^ binding->modifiers || n != binding->keys->length) { + sway_log(L_DEBUG, "@@ modifiers or key num dont match"); continue; } @@ -286,17 +288,18 @@ static void handle_keyboard_key(struct wl_listener *listener, void *data) { xkb_keycode_t keycode = event->keycode + 8; bool handled = false; - const xkb_keysym_t *keysyms; // handle keycodes handled = keyboard_execute_bindcode(keyboard); + sway_log(L_DEBUG, "@@ handled by bindcode? %d", handled); // handle translated keysyms + const xkb_keysym_t *translated_keysyms; uint32_t translated_modifiers; size_t translated_keysyms_len = - keyboard_keysyms_translated(keyboard, keycode, &keysyms, + keyboard_keysyms_translated(keyboard, keycode, &translated_keysyms, &translated_modifiers); - pressed_keysyms_update(keyboard->pressed_keysyms_translated, keysyms, + pressed_keysyms_update(keyboard->pressed_keysyms_translated, translated_keysyms, translated_keysyms_len, event->state); if (event->state == WLR_KEY_PRESSED && !handled) { handled = keyboard_execute_bindsym(keyboard, @@ -305,9 +308,10 @@ static void handle_keyboard_key(struct wl_listener *listener, void *data) { } // Handle raw keysyms + const xkb_keysym_t *raw_keysyms; uint32_t raw_modifiers; - size_t raw_keysyms_len = keyboard_keysyms_raw(keyboard, keycode, &keysyms, &raw_modifiers); - pressed_keysyms_update(keyboard->pressed_keysyms_raw, keysyms, raw_keysyms_len, + size_t raw_keysyms_len = keyboard_keysyms_raw(keyboard, keycode, &raw_keysyms, &raw_modifiers); + pressed_keysyms_update(keyboard->pressed_keysyms_raw, raw_keysyms, raw_keysyms_len, event->state); if (event->state == WLR_KEY_PRESSED && !handled) { handled = keyboard_execute_bindsym(keyboard, From bd3ca70e3d67476f4d66e9bc31c67b11aefb3519 Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Fri, 29 Dec 2017 09:10:07 -0500 Subject: [PATCH 10/12] fix nitpicks --- sway/commands/bind.c | 21 ++++++++++----------- sway/input/keyboard.c | 17 ++++++++--------- 2 files changed, 18 insertions(+), 20 deletions(-) diff --git a/sway/commands/bind.c b/sway/commands/bind.c index 99f54f465..ef9a4b7aa 100644 --- a/sway/commands/bind.c +++ b/sway/commands/bind.c @@ -16,15 +16,14 @@ int binding_order = 0; void free_sway_binding(struct sway_binding *binding) { + if (!binding) { + return; + } + if (binding->keys) { - for (int i = 0; i < binding->keys->length; i++) { - free(binding->keys->items[i]); - } - list_free(binding->keys); - } - if (binding->command) { - free(binding->command); + free_flat_list(binding->keys); } + free(binding->command); free(binding); } @@ -72,7 +71,7 @@ struct cmd_results *cmd_bindsym(int argc, char **argv) { return error; } - struct sway_binding *binding = malloc(sizeof(struct sway_binding)); + struct sway_binding *binding = calloc(1, sizeof(struct sway_binding)); if (!binding) { return cmd_results_new(CMD_FAILURE, "bindsym", "Unable to allocate binding"); @@ -122,7 +121,7 @@ struct cmd_results *cmd_bindsym(int argc, char **argv) { free_flat_list(split); return ret; } - xkb_keysym_t *key = malloc(sizeof(xkb_keysym_t)); + xkb_keysym_t *key = calloc(1, sizeof(xkb_keysym_t)); if (!key) { free_sway_binding(binding); free_flat_list(split); @@ -165,7 +164,7 @@ struct cmd_results *cmd_bindcode(int argc, char **argv) { return error; } - struct sway_binding *binding = malloc(sizeof(struct sway_binding)); + struct sway_binding *binding = calloc(1, sizeof(struct sway_binding)); if (!binding) { return cmd_results_new(CMD_FAILURE, "bindsym", "Unable to allocate binding"); @@ -209,7 +208,7 @@ struct cmd_results *cmd_bindcode(int argc, char **argv) { list_free(split); return error; } - xkb_keycode_t *key = malloc(sizeof(xkb_keycode_t)); + xkb_keycode_t *key = calloc(1, sizeof(xkb_keycode_t)); *key = keycode - 8; list_add(binding->keys, key); } diff --git a/sway/input/keyboard.c b/sway/input/keyboard.c index 6272dcce5..3090d32f2 100644 --- a/sway/input/keyboard.c +++ b/sway/input/keyboard.c @@ -67,9 +67,7 @@ static bool keyboard_execute_bindsym(struct sway_keyboard *keyboard, list_t *keysym_bindings = config->current_mode->keysym_bindings; for (int i = 0; i < keysym_bindings->length; ++i) { struct sway_binding *binding = keysym_bindings->items[i]; - sway_log(L_DEBUG, "@@ checking binding: %s", binding->command); if (modifiers ^ binding->modifiers || n != binding->keys->length) { - sway_log(L_DEBUG, "@@ modifiers or key num dont match"); continue; } @@ -85,7 +83,8 @@ static bool keyboard_execute_bindsym(struct sway_keyboard *keyboard, } if (match) { - sway_log(L_DEBUG, "running command for binding: %s", binding->command); + sway_log(L_DEBUG, "running command for binding: %s", + binding->command); struct cmd_results *results = handle_command(binding->command); if (results->status != CMD_SUCCESS) { sway_log(L_DEBUG, "could not run command for binding: %s", @@ -291,7 +290,6 @@ static void handle_keyboard_key(struct wl_listener *listener, void *data) { // handle keycodes handled = keyboard_execute_bindcode(keyboard); - sway_log(L_DEBUG, "@@ handled by bindcode? %d", handled); // handle translated keysyms const xkb_keysym_t *translated_keysyms; @@ -299,8 +297,8 @@ static void handle_keyboard_key(struct wl_listener *listener, void *data) { size_t translated_keysyms_len = keyboard_keysyms_translated(keyboard, keycode, &translated_keysyms, &translated_modifiers); - pressed_keysyms_update(keyboard->pressed_keysyms_translated, translated_keysyms, - translated_keysyms_len, event->state); + pressed_keysyms_update(keyboard->pressed_keysyms_translated, + translated_keysyms, translated_keysyms_len, event->state); if (event->state == WLR_KEY_PRESSED && !handled) { handled = keyboard_execute_bindsym(keyboard, keyboard->pressed_keysyms_translated, translated_modifiers, @@ -310,9 +308,10 @@ static void handle_keyboard_key(struct wl_listener *listener, void *data) { // Handle raw keysyms const xkb_keysym_t *raw_keysyms; uint32_t raw_modifiers; - size_t raw_keysyms_len = keyboard_keysyms_raw(keyboard, keycode, &raw_keysyms, &raw_modifiers); - pressed_keysyms_update(keyboard->pressed_keysyms_raw, raw_keysyms, raw_keysyms_len, - event->state); + size_t raw_keysyms_len = + keyboard_keysyms_raw(keyboard, keycode, &raw_keysyms, &raw_modifiers); + pressed_keysyms_update(keyboard->pressed_keysyms_raw, raw_keysyms, + raw_keysyms_len, event->state); if (event->state == WLR_KEY_PRESSED && !handled) { handled = keyboard_execute_bindsym(keyboard, keyboard->pressed_keysyms_raw, raw_modifiers, From 50e791cadbfc51d531fff44cfbe3323a3b456adf Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Thu, 4 Jan 2018 07:25:52 -0500 Subject: [PATCH 11/12] binding release --- include/sway/input/keyboard.h | 3 ++ sway/commands/bind.c | 4 ++ sway/input/keyboard.c | 96 +++++++++++++++++++++++++++-------- 3 files changed, 82 insertions(+), 21 deletions(-) diff --git a/include/sway/input/keyboard.h b/include/sway/input/keyboard.h index 0a5857f0a..8ec3eb356 100644 --- a/include/sway/input/keyboard.h +++ b/include/sway/input/keyboard.h @@ -14,7 +14,10 @@ struct sway_keyboard { struct wl_listener keyboard_modifiers; xkb_keysym_t pressed_keysyms_translated[SWAY_KEYBOARD_PRESSED_KEYSYMS_CAP]; + uint32_t modifiers_translated; + xkb_keysym_t pressed_keysyms_raw[SWAY_KEYBOARD_PRESSED_KEYSYMS_CAP]; + uint32_t modifiers_raw; }; struct sway_keyboard *sway_keyboard_create(struct sway_seat *seat, diff --git a/sway/commands/bind.c b/sway/commands/bind.c index ef9a4b7aa..791214041 100644 --- a/sway/commands/bind.c +++ b/sway/commands/bind.c @@ -34,6 +34,10 @@ void free_sway_binding(struct sway_binding *binding) { */ bool binding_key_compare(struct sway_binding *binding_a, struct sway_binding *binding_b) { + if (binding_a->release != binding_b->release) { + return false; + } + if (binding_a->bindcode != binding_b->bindcode) { return false; } diff --git a/sway/input/keyboard.c b/sway/input/keyboard.c index 3090d32f2..7b90dacf1 100644 --- a/sway/input/keyboard.c +++ b/sway/input/keyboard.c @@ -1,3 +1,4 @@ +#include #include #include #include "sway/input/seat.h" @@ -54,6 +55,18 @@ static bool keyboard_execute_compositor_binding(struct sway_keyboard *keyboard, return false; } +static bool binding_matches_keystate(struct sway_binding *binding, + enum wlr_key_state key_state) { + if (key_state == WLR_KEY_PRESSED && !binding->release) { + return true; + } + if (key_state == WLR_KEY_RELEASED && binding->release) { + return true; + } + + return false; +} + /** * Execute keyboard bindings bound with `bindysm`. * @@ -61,13 +74,15 @@ static bool keyboard_execute_compositor_binding(struct sway_keyboard *keyboard, * should be propagated to clients. */ static bool keyboard_execute_bindsym(struct sway_keyboard *keyboard, - xkb_keysym_t *pressed_keysyms, uint32_t modifiers, size_t keysyms_len) { + xkb_keysym_t *pressed_keysyms, uint32_t modifiers, enum wlr_key_state key_state) { // configured bindings int n = pressed_keysyms_length(pressed_keysyms); list_t *keysym_bindings = config->current_mode->keysym_bindings; for (int i = 0; i < keysym_bindings->length; ++i) { struct sway_binding *binding = keysym_bindings->items[i]; - if (modifiers ^ binding->modifiers || n != binding->keys->length) { + if (!binding_matches_keystate(binding, key_state) || + modifiers ^ binding->modifiers || + n != binding->keys->length) { continue; } @@ -115,16 +130,43 @@ static bool keysym_is_modifier(xkb_keysym_t keysym) { } static bool binding_matches_keycodes(struct wlr_keyboard *keyboard, - struct sway_binding *binding) { + struct sway_binding *binding, struct wlr_event_keyboard_key *event) { + assert(binding->bindcode); + + uint32_t keycode = event->keycode + 8; + + if (!binding_matches_keystate(binding, event->state)) { + return false; + } + uint32_t modifiers = wlr_keyboard_get_modifiers(keyboard); if (modifiers ^ binding->modifiers) { return false; } + // on release, the released key must be in the binding + if (event->state == WLR_KEY_RELEASED) { + bool found = false; + for (int i = 0; i < binding->keys->length; ++i) { + uint32_t binding_keycode = *(uint32_t*)binding->keys->items[i] + 8; + if (binding_keycode == keycode) { + found = true; + break; + } + } + if (!found) { + return false; + } + } + // every keycode in the binding must be present in the pressed keys on the // keyboard for (int i = 0; i < binding->keys->length; ++i) { uint32_t binding_keycode = *(uint32_t*)binding->keys->items[i] + 8; + if (event->state == WLR_KEY_RELEASED && keycode == binding_keycode) { + continue; + } + bool found = false; for (size_t j = 0; j < keyboard->num_keycodes; ++j) { xkb_keycode_t keycode = keyboard->keycodes[j] + 8; @@ -178,13 +220,14 @@ static bool binding_matches_keycodes(struct wlr_keyboard *keyboard, * Returns true if the keysym was handled by a binding and false if the event * should be propagated to clients. */ -static bool keyboard_execute_bindcode(struct sway_keyboard *keyboard) { +static bool keyboard_execute_bindcode(struct sway_keyboard *keyboard, + struct wlr_event_keyboard_key *event) { struct wlr_keyboard *wlr_keyboard = keyboard->seat_device->input_device->wlr_device->keyboard; list_t *keycode_bindings = config->current_mode->keycode_bindings; for (int i = 0; i < keycode_bindings->length; ++i) { struct sway_binding *binding = keycode_bindings->items[i]; - if (binding_matches_keycodes(wlr_keyboard, binding)) { + if (binding_matches_keycodes(wlr_keyboard, binding, event)) { struct cmd_results *results = handle_command(binding->command); if (results->status != CMD_SUCCESS) { sway_log(L_DEBUG, "could not run command for binding: %s", @@ -289,50 +332,61 @@ static void handle_keyboard_key(struct wl_listener *listener, void *data) { bool handled = false; // handle keycodes - handled = keyboard_execute_bindcode(keyboard); + handled = keyboard_execute_bindcode(keyboard, event); // handle translated keysyms + if (!handled && event->state == WLR_KEY_RELEASED) { + handled = keyboard_execute_bindsym(keyboard, + keyboard->pressed_keysyms_translated, + keyboard->modifiers_translated, + event->state); + } const xkb_keysym_t *translated_keysyms; - uint32_t translated_modifiers; size_t translated_keysyms_len = keyboard_keysyms_translated(keyboard, keycode, &translated_keysyms, - &translated_modifiers); + &keyboard->modifiers_translated); pressed_keysyms_update(keyboard->pressed_keysyms_translated, translated_keysyms, translated_keysyms_len, event->state); - if (event->state == WLR_KEY_PRESSED && !handled) { + if (!handled && event->state == WLR_KEY_PRESSED) { handled = keyboard_execute_bindsym(keyboard, - keyboard->pressed_keysyms_translated, translated_modifiers, - translated_keysyms_len); + keyboard->pressed_keysyms_translated, + keyboard->modifiers_translated, + event->state); } // Handle raw keysyms + if (!handled && event->state == WLR_KEY_RELEASED) { + handled = keyboard_execute_bindsym(keyboard, + keyboard->pressed_keysyms_raw, keyboard->modifiers_raw, + event->state); + } const xkb_keysym_t *raw_keysyms; - uint32_t raw_modifiers; size_t raw_keysyms_len = - keyboard_keysyms_raw(keyboard, keycode, &raw_keysyms, &raw_modifiers); + keyboard_keysyms_raw(keyboard, keycode, &raw_keysyms, &keyboard->modifiers_raw); pressed_keysyms_update(keyboard->pressed_keysyms_raw, raw_keysyms, raw_keysyms_len, event->state); - if (event->state == WLR_KEY_PRESSED && !handled) { + if (!handled && event->state == WLR_KEY_PRESSED) { handled = keyboard_execute_bindsym(keyboard, - keyboard->pressed_keysyms_raw, raw_modifiers, - raw_keysyms_len); + keyboard->pressed_keysyms_raw, keyboard->modifiers_raw, + event->state); } // Compositor bindings - if (event->state == WLR_KEY_PRESSED && !handled) { + if (!handled && event->state == WLR_KEY_PRESSED) { handled = keyboard_execute_compositor_binding(keyboard, - keyboard->pressed_keysyms_translated, translated_modifiers, + keyboard->pressed_keysyms_translated, + keyboard->modifiers_translated, translated_keysyms_len); } - if (event->state == WLR_KEY_PRESSED && !handled) { + if (!handled && event->state == WLR_KEY_PRESSED) { handled = keyboard_execute_compositor_binding(keyboard, - keyboard->pressed_keysyms_raw, raw_modifiers, + keyboard->pressed_keysyms_raw, keyboard->modifiers_raw, raw_keysyms_len); } - if (!handled) { + if (!handled || event->state == WLR_KEY_RELEASED) { wlr_seat_set_keyboard(wlr_seat, wlr_device); wlr_seat_keyboard_notify_key(wlr_seat, event->time_msec, event->keycode, event->state); From 8b4eb5d7d1846447b54ebf786c7dd6869a27670a Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Thu, 4 Jan 2018 07:54:14 -0500 Subject: [PATCH 12/12] cleanup bindings --- sway/input/keyboard.c | 162 +++++++++++++++++++++--------------------- 1 file changed, 81 insertions(+), 81 deletions(-) diff --git a/sway/input/keyboard.c b/sway/input/keyboard.c index 7b90dacf1..c2bb25780 100644 --- a/sway/input/keyboard.c +++ b/sway/input/keyboard.c @@ -7,6 +7,22 @@ #include "sway/commands.h" #include "log.h" +static bool keysym_is_modifier(xkb_keysym_t keysym) { + switch (keysym) { + case XKB_KEY_Shift_L: case XKB_KEY_Shift_R: + case XKB_KEY_Control_L: case XKB_KEY_Control_R: + case XKB_KEY_Caps_Lock: + case XKB_KEY_Shift_Lock: + case XKB_KEY_Meta_L: case XKB_KEY_Meta_R: + case XKB_KEY_Alt_L: case XKB_KEY_Alt_R: + case XKB_KEY_Super_L: case XKB_KEY_Super_R: + case XKB_KEY_Hyper_L: case XKB_KEY_Hyper_R: + return true; + default: + return false; + } +} + static size_t pressed_keysyms_length(xkb_keysym_t *pressed_keysyms) { size_t n = 0; for (size_t i = 0; i < SWAY_KEYBOARD_PRESSED_KEYSYMS_CAP; ++i) { @@ -27,6 +43,63 @@ static ssize_t pressed_keysyms_index(xkb_keysym_t *pressed_keysyms, return -1; } +static void pressed_keysyms_add(xkb_keysym_t *pressed_keysyms, + xkb_keysym_t keysym) { + ssize_t i = pressed_keysyms_index(pressed_keysyms, keysym); + if (i < 0) { + i = pressed_keysyms_index(pressed_keysyms, XKB_KEY_NoSymbol); + if (i >= 0) { + pressed_keysyms[i] = keysym; + } + } +} + +static void pressed_keysyms_remove(xkb_keysym_t *pressed_keysyms, + xkb_keysym_t keysym) { + ssize_t i = pressed_keysyms_index(pressed_keysyms, keysym); + if (i >= 0) { + pressed_keysyms[i] = XKB_KEY_NoSymbol; + } +} + +static void pressed_keysyms_update(xkb_keysym_t *pressed_keysyms, + const xkb_keysym_t *keysyms, size_t keysyms_len, + enum wlr_key_state state) { + for (size_t i = 0; i < keysyms_len; ++i) { + if (keysym_is_modifier(keysyms[i])) { + continue; + } + if (state == WLR_KEY_PRESSED) { + pressed_keysyms_add(pressed_keysyms, keysyms[i]); + } else { // WLR_KEY_RELEASED + pressed_keysyms_remove(pressed_keysyms, keysyms[i]); + } + } +} + +static bool binding_matches_key_state(struct sway_binding *binding, + enum wlr_key_state key_state) { + if (key_state == WLR_KEY_PRESSED && !binding->release) { + return true; + } + if (key_state == WLR_KEY_RELEASED && binding->release) { + return true; + } + + return false; +} + +static void binding_execute_command(struct sway_binding *binding) { + sway_log(L_DEBUG, "running command for binding: %s", + binding->command); + struct cmd_results *results = handle_command(binding->command); + if (results->status != CMD_SUCCESS) { + sway_log(L_DEBUG, "could not run command for binding: %s", + binding->command); + } + free_cmd_results(results); +} + /** * Execute a built-in, hardcoded compositor binding. These are triggered from a * single keysym. @@ -55,32 +128,21 @@ static bool keyboard_execute_compositor_binding(struct sway_keyboard *keyboard, return false; } -static bool binding_matches_keystate(struct sway_binding *binding, - enum wlr_key_state key_state) { - if (key_state == WLR_KEY_PRESSED && !binding->release) { - return true; - } - if (key_state == WLR_KEY_RELEASED && binding->release) { - return true; - } - - return false; -} - /** - * Execute keyboard bindings bound with `bindysm`. + * Execute keyboard bindings bound with `bindysm` for the given keyboard state. * * Returns true if the keysym was handled by a binding and false if the event * should be propagated to clients. */ static bool keyboard_execute_bindsym(struct sway_keyboard *keyboard, - xkb_keysym_t *pressed_keysyms, uint32_t modifiers, enum wlr_key_state key_state) { + xkb_keysym_t *pressed_keysyms, uint32_t modifiers, + enum wlr_key_state key_state) { // configured bindings int n = pressed_keysyms_length(pressed_keysyms); list_t *keysym_bindings = config->current_mode->keysym_bindings; for (int i = 0; i < keysym_bindings->length; ++i) { struct sway_binding *binding = keysym_bindings->items[i]; - if (!binding_matches_keystate(binding, key_state) || + if (!binding_matches_key_state(binding, key_state) || modifiers ^ binding->modifiers || n != binding->keys->length) { continue; @@ -98,14 +160,7 @@ static bool keyboard_execute_bindsym(struct sway_keyboard *keyboard, } if (match) { - sway_log(L_DEBUG, "running command for binding: %s", - binding->command); - struct cmd_results *results = handle_command(binding->command); - if (results->status != CMD_SUCCESS) { - sway_log(L_DEBUG, "could not run command for binding: %s", - binding->command); - } - free_cmd_results(results); + binding_execute_command(binding); return true; } } @@ -113,29 +168,13 @@ static bool keyboard_execute_bindsym(struct sway_keyboard *keyboard, return false; } -static bool keysym_is_modifier(xkb_keysym_t keysym) { - switch (keysym) { - case XKB_KEY_Shift_L: case XKB_KEY_Shift_R: - case XKB_KEY_Control_L: case XKB_KEY_Control_R: - case XKB_KEY_Caps_Lock: - case XKB_KEY_Shift_Lock: - case XKB_KEY_Meta_L: case XKB_KEY_Meta_R: - case XKB_KEY_Alt_L: case XKB_KEY_Alt_R: - case XKB_KEY_Super_L: case XKB_KEY_Super_R: - case XKB_KEY_Hyper_L: case XKB_KEY_Hyper_R: - return true; - default: - return false; - } -} - static bool binding_matches_keycodes(struct wlr_keyboard *keyboard, struct sway_binding *binding, struct wlr_event_keyboard_key *event) { assert(binding->bindcode); uint32_t keycode = event->keycode + 8; - if (!binding_matches_keystate(binding, event->state)) { + if (!binding_matches_key_state(binding, event->state)) { return false; } @@ -215,7 +254,7 @@ static bool binding_matches_keycodes(struct wlr_keyboard *keyboard, } /** - * Execute keyboard bindings bound with `bindcode`. + * Execute keyboard bindings bound with `bindcode` for the given keyboard state. * * Returns true if the keysym was handled by a binding and false if the event * should be propagated to clients. @@ -228,12 +267,7 @@ static bool keyboard_execute_bindcode(struct sway_keyboard *keyboard, for (int i = 0; i < keycode_bindings->length; ++i) { struct sway_binding *binding = keycode_bindings->items[i]; if (binding_matches_keycodes(wlr_keyboard, binding, event)) { - struct cmd_results *results = handle_command(binding->command); - if (results->status != CMD_SUCCESS) { - sway_log(L_DEBUG, "could not run command for binding: %s", - binding->command); - } - free_cmd_results(results); + binding_execute_command(binding); return true; } } @@ -286,40 +320,6 @@ static size_t keyboard_keysyms_raw(struct sway_keyboard *keyboard, keycode, layout_index, 0, keysyms); } -static void pressed_keysyms_add(xkb_keysym_t *pressed_keysyms, - xkb_keysym_t keysym) { - ssize_t i = pressed_keysyms_index(pressed_keysyms, keysym); - if (i < 0) { - i = pressed_keysyms_index(pressed_keysyms, XKB_KEY_NoSymbol); - if (i >= 0) { - pressed_keysyms[i] = keysym; - } - } -} - -static void pressed_keysyms_remove(xkb_keysym_t *pressed_keysyms, - xkb_keysym_t keysym) { - ssize_t i = pressed_keysyms_index(pressed_keysyms, keysym); - if (i >= 0) { - pressed_keysyms[i] = XKB_KEY_NoSymbol; - } -} - -static void pressed_keysyms_update(xkb_keysym_t *pressed_keysyms, - const xkb_keysym_t *keysyms, size_t keysyms_len, - enum wlr_key_state state) { - for (size_t i = 0; i < keysyms_len; ++i) { - if (keysym_is_modifier(keysyms[i])) { - continue; - } - if (state == WLR_KEY_PRESSED) { - pressed_keysyms_add(pressed_keysyms, keysyms[i]); - } else { // WLR_KEY_RELEASED - pressed_keysyms_remove(pressed_keysyms, keysyms[i]); - } - } -} - static void handle_keyboard_key(struct wl_listener *listener, void *data) { struct sway_keyboard *keyboard = wl_container_of(listener, keyboard, keyboard_key);