From b23cd827cf934ef7f631b7c448e7afa4147c1936 Mon Sep 17 00:00:00 2001 From: frsfnrrg Date: Tue, 12 Jun 2018 10:37:47 -0400 Subject: [PATCH 1/5] Sort binding key lists Sort the list comprising the set of keys for the binding in ascending order. (Keyboard shortcuts depend only on the set of simultaneously pressed keys, not their order, so this change should have no external effect.) This simplifies comparisons between bindings. --- include/sway/config.h | 2 +- sway/commands/bind.c | 25 ++++++++++++++----------- 2 files changed, 15 insertions(+), 12 deletions(-) diff --git a/include/sway/config.h b/include/sway/config.h index 81e9c382..e75b0664 100644 --- a/include/sway/config.h +++ b/include/sway/config.h @@ -30,7 +30,7 @@ struct sway_binding { bool release; bool locked; bool bindcode; - list_t *keys; + list_t *keys; // sorted in ascending order uint32_t modifiers; char *command; }; diff --git a/sway/commands/bind.c b/sway/commands/bind.c index d0e3e22f..821f9cd1 100644 --- a/sway/commands/bind.c +++ b/sway/commands/bind.c @@ -32,7 +32,7 @@ void free_sway_binding(struct sway_binding *binding) { * 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, +static bool binding_key_compare(struct sway_binding *binding_a, struct sway_binding *binding_b) { if (binding_a->release != binding_b->release) { return false; @@ -50,18 +50,12 @@ bool binding_key_compare(struct sway_binding *binding_a, return false; } + // Keys are sorted 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) { + uint32_t key_a = *(uint32_t *)binding_a->keys->items[i]; + uint32_t key_b = *(uint32_t *)binding_b->keys->items[i]; + if (key_a != key_b) { return false; } } @@ -69,6 +63,12 @@ bool binding_key_compare(struct sway_binding *binding_a, return true; } +static int key_qsort_cmp(const void *keyp_a, const void *keyp_b) { + uint32_t key_a = **(uint32_t **)keyp_a; + uint32_t key_b = **(uint32_t **)keyp_b; + return (key_a < key_b) ? -1 : ((key_a > key_b) ? 1 : 0); +} + static struct cmd_results *cmd_bindsym_or_bindcode(int argc, char **argv, bool bindcode) { const char *bindtype = bindcode ? "bindcode" : "bindsym"; @@ -169,6 +169,9 @@ static struct cmd_results *cmd_bindsym_or_bindcode(int argc, char **argv, free_flat_list(split); binding->order = binding_order++; + // sort ascending + list_qsort(binding->keys, key_qsort_cmp); + list_t *mode_bindings; if (bindcode) { mode_bindings = config->current_mode->keycode_bindings; From ca061ba8bf94e1d09e1d912871841212778044ed Mon Sep 17 00:00:00 2001 From: frsfnrrg Date: Tue, 12 Jun 2018 11:07:11 -0400 Subject: [PATCH 2/5] Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages. --- include/sway/input/keyboard.h | 5 +- sway/input/keyboard.c | 206 ++++++++++++++++++---------------- 2 files changed, 115 insertions(+), 96 deletions(-) diff --git a/include/sway/input/keyboard.h b/include/sway/input/keyboard.h index e99a54b1..6713398e 100644 --- a/include/sway/input/keyboard.h +++ b/include/sway/input/keyboard.h @@ -21,7 +21,9 @@ struct sway_shortcut_state { * including duplicates when a keycode generates multiple key ids. */ uint32_t pressed_keycodes[SWAY_KEYBOARD_PRESSED_KEYS_CAP]; - int last_key_index; + uint32_t last_keycode; + uint32_t last_raw_modifiers; + size_t npressed; }; struct sway_keyboard { @@ -36,7 +38,6 @@ struct sway_keyboard { struct sway_shortcut_state state_keysyms_raw; struct sway_shortcut_state state_keycodes; struct sway_binding *held_binding; - uint32_t last_modifiers; }; struct sway_keyboard *sway_keyboard_create(struct sway_seat *seat, diff --git a/sway/input/keyboard.c b/sway/input/keyboard.c index d90655f2..9e093828 100644 --- a/sway/input/keyboard.c +++ b/sway/input/keyboard.c @@ -9,86 +9,112 @@ #include "sway/commands.h" #include "log.h" +/** + * Remove all key ids associated to a keycode from the list of pressed keys + */ +static void state_erase_key(struct sway_shortcut_state *state, + uint32_t keycode) { + size_t j = 0; + for (size_t i = 0; i < state->npressed; ++i) { + if (i > j) { + state->pressed_keys[j] = state->pressed_keys[i]; + state->pressed_keycodes[j] = state->pressed_keycodes[i]; + } + if (state->pressed_keycodes[i] != keycode) { + ++j; + } + } + while(state->npressed > j) { + --state->npressed; + state->pressed_keys[state->npressed] = 0; + state->pressed_keycodes[state->npressed] = 0; + } +} + +/** + * Add a key id (with associated keycode) to the list of pressed keys, + * if the list is not full. + */ +static void state_add_key(struct sway_shortcut_state *state, + uint32_t keycode, uint32_t key_id) { + if (state->npressed >= SWAY_KEYBOARD_PRESSED_KEYS_CAP) { + return; + } + size_t i = 0; + while (i < state->npressed && state->pressed_keys[i] < key_id) { + ++i; + } + size_t j = state->npressed; + while (j > i) { + state->pressed_keys[j] = state->pressed_keys[j - 1]; + state->pressed_keycodes[j] = state->pressed_keycodes[j - 1]; + --j; + } + state->pressed_keys[i] = key_id; + state->pressed_keycodes[i] = keycode; + state->npressed++; +} + /** * Update the shortcut model state in response to new input */ static void update_shortcut_state(struct sway_shortcut_state *state, struct wlr_event_keyboard_key *event, uint32_t new_key, - bool last_key_was_a_modifier) { + uint32_t raw_modifiers) { + bool last_key_was_a_modifier = raw_modifiers != state->last_raw_modifiers; + state->last_raw_modifiers = raw_modifiers; + if (event->state == WLR_KEY_PRESSED) { - if (last_key_was_a_modifier && state->last_key_index >= 0) { + if (last_key_was_a_modifier && state->last_keycode) { // Last pressed key before this one was a modifier - state->pressed_keycodes[state->last_key_index] = 0; - state->pressed_keys[state->last_key_index] = 0; - state->last_key_index = -1; + state_erase_key(state, state->last_keycode); } // Add current key to set; there may be duplicates - for (size_t i = 0; i < SWAY_KEYBOARD_PRESSED_KEYS_CAP; ++i) { - if (!state->pressed_keys[i]) { - state->pressed_keys[i] = new_key; - state->pressed_keycodes[i] = event->keycode; - state->last_key_index = i; - break; - } - } + state_add_key(state, event->keycode, new_key); + state->last_keycode = event->keycode; } else { - for (size_t i = 0; i < SWAY_KEYBOARD_PRESSED_KEYS_CAP; ++i) { - // The same keycode may match multiple keysyms. - if (state->pressed_keycodes[i] == event->keycode) { - state->pressed_keys[i] = 0; - state->pressed_keycodes[i] = 0; - } - } + state_erase_key(state, event->keycode); } } /** - * - * Returns a binding which matches the shortcut model state (ignoring the - * `release` flag). + * If one exists, finds a binding which matches the shortcut model state, + * current modifiers, release state, and locked state. */ -static struct sway_binding *get_active_binding( - struct sway_shortcut_state *state, list_t *bindings, - uint32_t modifiers, bool locked) { - int npressed_keys = 0; - for (size_t i = 0; i < SWAY_KEYBOARD_PRESSED_KEYS_CAP; ++i) { - if (state->pressed_keys[i]) { - ++npressed_keys; - } - } +static void get_active_binding(const struct sway_shortcut_state *state, + list_t *bindings, struct sway_binding **current_binding, + uint32_t modifiers, bool release, bool locked) { for (int i = 0; i < bindings->length; ++i) { struct sway_binding *binding = bindings->items[i]; if (modifiers ^ binding->modifiers || - npressed_keys != binding->keys->length || - locked > binding->locked) { + state->npressed != (size_t)binding->keys->length || + locked > binding->locked || + release != binding->release) { continue; } bool match = true; - for (int j = 0; j < binding->keys->length; ++j) { + for (size_t j = 0; j < state->npressed; j++) { uint32_t key = *(uint32_t *)binding->keys->items[j]; - - bool key_found = false; - for (int k = 0; k < SWAY_KEYBOARD_PRESSED_KEYS_CAP; ++k) { - if (state->pressed_keys[k] == key) { - key_found = true; - break; - } - } - if (!key_found) { + if (key != state->pressed_keys[j]) { match = false; break; } } + if (!match) { + continue; + } - if (match) { - return binding; + if (*current_binding && *current_binding != binding) { + wlr_log(L_DEBUG, "encountered duplicate bindings %d and %d", + (*current_binding)->order, binding->order); + } else { + *current_binding = binding; } + return; } - - return NULL; } /** @@ -204,69 +230,65 @@ static void handle_keyboard_key(struct wl_listener *listener, void *data) { size_t raw_keysyms_len = keyboard_keysyms_raw(keyboard, keycode, &raw_keysyms, &raw_modifiers); - struct wlr_input_device *device = - keyboard->seat_device->input_device->wlr_device; - uint32_t code_modifiers = wlr_keyboard_get_modifiers(device->keyboard); - - bool last_key_was_a_modifier = code_modifiers != keyboard->last_modifiers; - keyboard->last_modifiers = code_modifiers; + uint32_t code_modifiers = wlr_keyboard_get_modifiers(wlr_device->keyboard); // Update shortcut model state update_shortcut_state(&keyboard->state_keycodes, event, - (uint32_t)keycode, last_key_was_a_modifier); + (uint32_t)keycode, code_modifiers); for (size_t i = 0; i < translated_keysyms_len; ++i) { update_shortcut_state(&keyboard->state_keysyms_translated, event, (uint32_t)translated_keysyms[i], - last_key_was_a_modifier && i == 0); + code_modifiers); } for (size_t i = 0; i < raw_keysyms_len; ++i) { update_shortcut_state(&keyboard->state_keysyms_raw, event, (uint32_t)raw_keysyms[i], - last_key_was_a_modifier && i == 0); + code_modifiers); } - // identify which binding should be executed. - struct sway_binding *binding = get_active_binding( - &keyboard->state_keycodes, - config->current_mode->keycode_bindings, - code_modifiers, input_inhibited); - struct sway_binding *translated_binding = get_active_binding( - &keyboard->state_keysyms_translated, - config->current_mode->keysym_bindings, - translated_modifiers, input_inhibited); - if (translated_binding && !binding) { - binding = translated_binding; - } else if (binding && translated_binding && binding != translated_binding) { - wlr_log(L_DEBUG, "encountered duplicate bindings %d and %d", - binding->order, translated_binding->order); - } - struct sway_binding *raw_binding = get_active_binding( - &keyboard->state_keysyms_raw, - config->current_mode->keysym_bindings, - raw_modifiers, input_inhibited); - if (raw_binding && !binding) { - binding = raw_binding; - } else if (binding && raw_binding && binding != raw_binding) { - wlr_log(L_DEBUG, "encountered duplicate bindings %d and %d", - binding->order, raw_binding->order); - } bool handled = false; - // Execute the identified binding if need be. - if (keyboard->held_binding && binding != keyboard->held_binding && + // Identify active release binding + struct sway_binding *binding_released = NULL; + get_active_binding(&keyboard->state_keycodes, + config->current_mode->keycode_bindings, &binding_released, + code_modifiers, true, input_inhibited); + get_active_binding(&keyboard->state_keysyms_translated, + config->current_mode->keysym_bindings, &binding_released, + translated_modifiers, true, input_inhibited); + get_active_binding(&keyboard->state_keysyms_raw, + config->current_mode->keysym_bindings, &binding_released, + raw_modifiers, true, input_inhibited); + + // Execute stored release binding once no longer active + if (keyboard->held_binding && binding_released != keyboard->held_binding && event->state == WLR_KEY_RELEASED) { keyboard_execute_command(keyboard, keyboard->held_binding); handled = true; } - if (binding != keyboard->held_binding) { + if (binding_released != keyboard->held_binding) { keyboard->held_binding = NULL; } - if (binding && event->state == WLR_KEY_PRESSED) { - if (binding->release) { - keyboard->held_binding = binding; - } else { - keyboard_execute_command(keyboard, binding); + if (binding_released && event->state == WLR_KEY_PRESSED) { + keyboard->held_binding = binding_released; + } + + // Identify and execute active pressed binding + if (event->state == WLR_KEY_PRESSED) { + struct sway_binding *binding_pressed = NULL; + get_active_binding(&keyboard->state_keycodes, + config->current_mode->keycode_bindings, &binding_pressed, + code_modifiers, false, input_inhibited); + get_active_binding(&keyboard->state_keysyms_translated, + config->current_mode->keysym_bindings, &binding_pressed, + translated_modifiers, false, input_inhibited); + get_active_binding(&keyboard->state_keysyms_raw, + config->current_mode->keysym_bindings, &binding_pressed, + raw_modifiers, false, input_inhibited); + + if (binding_pressed) { + keyboard_execute_command(keyboard, binding_pressed); handled = true; } } @@ -315,10 +337,6 @@ struct sway_keyboard *sway_keyboard_create(struct sway_seat *seat, wl_list_init(&keyboard->keyboard_key.link); wl_list_init(&keyboard->keyboard_modifiers.link); - keyboard->state_keycodes.last_key_index = -1; - keyboard->state_keysyms_raw.last_key_index = -1; - keyboard->state_keysyms_translated.last_key_index = -1; - return keyboard; } From 088cae45c8467b0c7a06301d9aec18f2aab55a1d Mon Sep 17 00:00:00 2001 From: emersion Date: Wed, 13 Jun 2018 19:47:43 +0100 Subject: [PATCH 3/5] Update for swaywm/wlroots#1060 --- sway/desktop/output.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/sway/desktop/output.c b/sway/desktop/output.c index 29666c00..d4115be8 100644 --- a/sway/desktop/output.c +++ b/sway/desktop/output.c @@ -240,7 +240,8 @@ static void render_surface_iterator(struct wlr_surface *surface, int sx, int sy, pixman_region32_t *output_damage = data->damage; float alpha = data->alpha; - if (!wlr_surface_has_buffer(surface)) { + struct wlr_texture *texture = wlr_surface_get_texture(surface); + if (texture == NULL) { return; } @@ -259,8 +260,7 @@ static void render_surface_iterator(struct wlr_surface *surface, int sx, int sy, wlr_matrix_project_box(matrix, &box, transform, rotation, wlr_output->transform_matrix); - render_texture(wlr_output, output_damage, surface->texture, &box, matrix, - alpha); + render_texture(wlr_output, output_damage, texture, &box, matrix, alpha); } static void render_layer(struct sway_output *output, From 7ed81cfd36dc92202e72d044fa2000736671d938 Mon Sep 17 00:00:00 2001 From: "Alex Xu (Hello71)" Date: Sun, 17 Jun 2018 13:57:40 -0400 Subject: [PATCH 4/5] swayidle: fix stack overflow on sleep --- swayidle/main.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/swayidle/main.c b/swayidle/main.c index d83ab98d..7666578f 100644 --- a/swayidle/main.c +++ b/swayidle/main.c @@ -127,7 +127,8 @@ void acquire_sleep_lock() { static int prepare_for_sleep(sd_bus_message *msg, void *userdata, sd_bus_error *ret_error) { - bool going_down = true; + /* "b" apparently reads into an int, not a bool */ + int going_down = 1; int ret = sd_bus_message_read(msg, "b", &going_down); if (ret < 0) { wlr_log(L_ERROR, "Failed to parse D-Bus response for Inhibit: %s", From 54a5ee2747c3eae35e4fec400d1efc6ee7509a38 Mon Sep 17 00:00:00 2001 From: vilhalmer Date: Sun, 17 Jun 2018 17:34:12 -0400 Subject: [PATCH 5/5] Set pool_buffers busy when handing them out --- client/pool-buffer.c | 1 + 1 file changed, 1 insertion(+) diff --git a/client/pool-buffer.c b/client/pool-buffer.c index 52438303..fa468c0d 100644 --- a/client/pool-buffer.c +++ b/client/pool-buffer.c @@ -144,5 +144,6 @@ struct pool_buffer *get_next_buffer(struct wl_shm *shm, return NULL; } } + buffer->busy = true; return buffer; }