From ba69f06695c24f98a05d138a53ba130108ebce6f Mon Sep 17 00:00:00 2001
From: Tony Crisci <tony@dubstepdish.com>
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 83ded720..7146623e 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 34afb6a0..b0078a46 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 00000000..62aa535a
--- /dev/null
+++ b/sway/commands/bind.c
@@ -0,0 +1,173 @@
+#ifdef __linux__
+#include <linux/input-event-codes.h>
+#elif __FreeBSD__
+#include <dev/evdev/input-event-codes.h>
+#endif
+#include <xkbcommon/xkbcommon.h>
+#include <xkbcommon/xkbcommon-names.h>
+#include <strings.h>
+#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 b591ae9e..312e0779 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 fee2ddd2..01d5ef36 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 <tony@dubstepdish.com>
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 d9251f4c..0a5857f0 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 724941d8..25def7ac 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 <tony@dubstepdish.com>
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 25def7ac..68a95bac 100644
--- a/sway/input/keyboard.c
+++ b/sway/input/keyboard.c
@@ -1,8 +1,52 @@
+#include <wlr/backend/multi.h>
+#include <wlr/backend/session.h>
 #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 <tony@dubstepdish.com>
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 68a95bac..326ee584 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 <tony@dubstepdish.com>
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 326ee584..8b43df82 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 <tony@dubstepdish.com>
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 8b43df82..032083e9 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 <tony@dubstepdish.com>
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 032083e9..2464db12 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 <tony@dubstepdish.com>
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 2464db12..eacb6ceb 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 <tony@dubstepdish.com>
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 62aa535a..99f54f46 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 eacb6ceb..6272dcce 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 <tony@dubstepdish.com>
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 99f54f46..ef9a4b7a 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->keys) {
-		for (int i = 0; i < binding->keys->length; i++) {
-			free(binding->keys->items[i]);
-		}
-		list_free(binding->keys);
+	if (!binding) {
+		return;
 	}
-	if (binding->command) {
-		free(binding->command);
+
+	if (binding->keys) {
+		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 6272dcce..3090d32f 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 <tony@dubstepdish.com>
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 0a5857f0..8ec3eb35 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 ef9a4b7a..79121404 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 3090d32f..7b90dacf 100644
--- a/sway/input/keyboard.c
+++ b/sway/input/keyboard.c
@@ -1,3 +1,4 @@
+#include <assert.h>
 #include <wlr/backend/multi.h>
 #include <wlr/backend/session.h>
 #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 <tony@dubstepdish.com>
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 7b90dacf..c2bb2578 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);