22 files changed, 423 insertions, 238 deletions

diff --git a/common/util.c b/common/util.c
index e8a88772..467aa4b5 100644
--- a/common/util.c
+++ b/common/util.c
@@ -123,6 +123,22 @@ uint32_t parse_color(const char *color) {
         return res;
 }
 
+bool parse_boolean(const char *boolean, bool current) {
+        if (strcasecmp(boolean, "1") == 0
+                        || strcasecmp(boolean, "yes") == 0
+                        || strcasecmp(boolean, "on") == 0
+                        || strcasecmp(boolean, "true") == 0
+                        || strcasecmp(boolean, "enable") == 0
+                        || strcasecmp(boolean, "enabled") == 0
+                        || strcasecmp(boolean, "active") == 0) {
+                return true;
+        } else if (strcasecmp(boolean, "toggle") == 0) {
+                return !current;
+        }
+        // All other values are false to match i3
+        return false;
+}
+
 char* resolve_path(const char* path) {
         struct stat sb;
         ssize_t r;
diff --git a/include/sway/config.h b/include/sway/config.h
index 9d2e1bf9..032f4196 100644
--- a/include/sway/config.h
+++ b/include/sway/config.h
@@ -21,14 +21,28 @@ struct sway_variable {
         char *value;
 };
 
+
+enum binding_input_type {
+        BINDING_KEYCODE,
+        BINDING_KEYSYM,
+        BINDING_MOUSE,
+};
+
+enum binding_flags {
+        BINDING_RELEASE=1,
+        BINDING_LOCKED=2, // keyboard only
+        BINDING_BORDER=4, // mouse only; trigger on container border
+        BINDING_CONTENTS=8, // mouse only; trigger on container contents
+        BINDING_TITLEBAR=16 // mouse only; trigger on container titlebar
+};
+
 /**
  * A key binding and an associated command.
  */
 struct sway_binding {
+        enum binding_input_type type;
         int order;
-        bool release;
-        bool locked;
-        bool bindcode;
+        uint32_t flags;
         list_t *keys; // sorted in ascending order
         uint32_t modifiers;
         char *command;
@@ -49,6 +63,7 @@ struct sway_mode {
         char *name;
         list_t *keysym_bindings;
         list_t *keycode_bindings;
+        list_t *mouse_bindings;
         bool pango;
 };
 
@@ -471,6 +486,8 @@ void free_sway_binding(struct sway_binding *sb);
 
 struct sway_binding *sway_binding_dup(struct sway_binding *sb);
 
+void seat_execute_command(struct sway_seat *seat, struct sway_binding *binding);
+
 void load_swaybars();
 
 void invoke_swaybar(struct bar_config *bar);
diff --git a/include/sway/input/cursor.h b/include/sway/input/cursor.h
index b0a3a7c5..7ec45120 100644
--- a/include/sway/input/cursor.h
+++ b/include/sway/input/cursor.h
@@ -3,6 +3,8 @@
 #include <stdint.h>
 #include "sway/input/seat.h"
 
+#define SWAY_CURSOR_PRESSED_BUTTONS_CAP 32
+
 struct sway_cursor {
         struct sway_seat *seat;
         struct wlr_cursor *cursor;
@@ -29,6 +31,10 @@ struct sway_cursor {
         uint32_t tool_buttons;
 
         struct wl_listener request_set_cursor;
+
+        // Mouse binding state
+        uint32_t pressed_buttons[SWAY_CURSOR_PRESSED_BUTTONS_CAP];
+        size_t pressed_button_count;
 };
 
 void sway_cursor_destroy(struct sway_cursor *cursor);
diff --git a/include/util.h b/include/util.h
index f68deae8..bda941ce 100644
--- a/include/util.h
+++ b/include/util.h
@@ -51,6 +51,14 @@ pid_t get_parent_pid(pid_t pid);
 uint32_t parse_color(const char *color);
 
 /**
+ * Given a string that represents a boolean, return the boolean value. This
+ * function also takes in the current boolean value to support toggling. If
+ * toggling is not desired, pass in true for current so that toggling values
+ * get parsed as not true.
+ */
+bool parse_boolean(const char *boolean, bool current);
+
+/**
  * Given a path string, recurseively resolves any symlinks to their targets
  * (which may be a file, directory) and returns the result.
  * argument is returned. Caller must free the returned buffer.
diff --git a/sway/commands/bind.c b/sway/commands/bind.c
index 83e9e432..133fd089 100644
--- a/sway/commands/bind.c
+++ b/sway/commands/bind.c
@@ -34,11 +34,14 @@ void free_sway_binding(struct sway_binding *binding) {
  */
 static bool binding_key_compare(struct sway_binding *binding_a,
                 struct sway_binding *binding_b) {
-        if (binding_a->release != binding_b->release) {
+        if (binding_a->type != binding_b->type) {
                 return false;
         }
 
-        if (binding_a->bindcode != binding_b->bindcode) {
+        uint32_t conflict_generating_flags = BINDING_RELEASE | BINDING_BORDER
+                        | BINDING_CONTENTS | BINDING_TITLEBAR;
+        if ((binding_a->flags & conflict_generating_flags) !=
+                        (binding_b->flags & conflict_generating_flags)) {
                 return false;
         }
 
@@ -69,6 +72,66 @@ static int key_qsort_cmp(const void *keyp_a, const void *keyp_b) {
         return (key_a < key_b) ? -1 : ((key_a > key_b) ? 1 : 0);
 }
 
+
+/**
+ * From a keycode, bindcode, or bindsym name and the most likely binding type,
+ * identify the appropriate numeric value corresponding to the key. Return NULL
+ * and set *key_val if successful, otherwise return a specific error. Change
+ * the value of *type if the initial type guess was incorrect and if this
+ * was the first identified key.
+ */
+static struct cmd_results *identify_key(const char* name, bool first_key,
+                uint32_t* key_val, enum binding_input_type* type) {
+        if (*type == BINDING_KEYCODE) {
+                // check for keycode
+                xkb_keycode_t keycode = strtol(name, NULL, 10);
+                if (!xkb_keycode_is_legal_ext(keycode)) {
+                        return cmd_results_new(CMD_INVALID, "bindcode",
+                                        "Invalid keycode '%s'", name);
+                }
+                *key_val = keycode;
+        } else {
+                // check for keysym
+                xkb_keysym_t keysym = xkb_keysym_from_name(name,
+                                XKB_KEYSYM_CASE_INSENSITIVE);
+
+                // Check for mouse binding
+                uint32_t button = 0;
+                if (strncasecmp(name, "button", strlen("button")) == 0 &&
+                                strlen(name) == strlen("button0")) {
+                        button = name[strlen("button")] - '1' + BTN_LEFT;
+                }
+
+                if (*type == BINDING_KEYSYM) {
+                        if (button) {
+                                if (first_key) {
+                                        *type = BINDING_MOUSE;
+                                        *key_val = button;
+                                } else {
+                                        return cmd_results_new(CMD_INVALID, "bindsym",
+                                                        "Mixed button '%s' into key sequence", name);
+                                }
+                        } else if (keysym) {
+                                *key_val = keysym;
+                        } else {
+                                return cmd_results_new(CMD_INVALID, "bindsym",
+                                                "Unknown key '%s'", name);
+                        }
+                } else {
+                        if (button) {
+                                *key_val = button;
+                        } else if (keysym) {
+                                return cmd_results_new(CMD_INVALID, "bindsym",
+                                                "Mixed keysym '%s' into button sequence", name);
+                        } else {
+                                return cmd_results_new(CMD_INVALID, "bindsym",
+                                                "Unknown button '%s'", name);
+                        }
+                }
+        }
+        return NULL;
+}
+
 static struct cmd_results *cmd_bindsym_or_bindcode(int argc, char **argv,
                 bool bindcode) {
         const char *bindtype = bindcode ? "bindcode" : "bindsym";
@@ -85,22 +148,34 @@ static struct cmd_results *cmd_bindsym_or_bindcode(int argc, char **argv,
         }
         binding->keys = create_list();
         binding->modifiers = 0;
-        binding->release = false;
-        binding->locked = false;
-        binding->bindcode = bindcode;
+        binding->flags = 0;
+        binding->type = bindcode ? BINDING_KEYCODE : BINDING_KEYSYM;
+
+        bool exclude_titlebar = false;
 
         // Handle --release and --locked
         while (argc > 0) {
                 if (strcmp("--release", argv[0]) == 0) {
-                        binding->release = true;
+                        binding->flags |= BINDING_RELEASE;
                 } else if (strcmp("--locked", argv[0]) == 0) {
-                        binding->locked = true;
+                        binding->flags |= BINDING_LOCKED;
+                } else if (strcmp("--whole-window", argv[0]) == 0) {
+                        binding->flags |= BINDING_BORDER | BINDING_CONTENTS | BINDING_TITLEBAR;
+                } else if (strcmp("--border", argv[0]) == 0) {
+                        binding->flags |= BINDING_BORDER;
+                } else if (strcmp("--exclude-titlebar", argv[0]) == 0) {
+                        exclude_titlebar = true;
                 } else {
                         break;
                 }
                 argv++;
                 argc--;
         }
+        if (binding->flags & (BINDING_BORDER | BINDING_CONTENTS | BINDING_TITLEBAR)
+                        || exclude_titlebar) {
+                binding->type = BINDING_MOUSE;
+        }
+
         if (argc < 2) {
                 free_sway_binding(binding);
                 return cmd_results_new(CMD_FAILURE, bindtype,
@@ -119,64 +194,47 @@ static struct cmd_results *cmd_bindsym_or_bindcode(int argc, char **argv,
                         continue;
                 }
 
-                xkb_keycode_t keycode;
-                xkb_keysym_t keysym;
-                if (bindcode) {
-                        // parse keycode
-                        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;
-                        }
-                } else {
-                        // Check for xkb key
-                         keysym = 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")) {
-                                keysym = ((char *)split->items[i])[strlen("button")] - '1' + BTN_LEFT;
-                        }
-                        if (!keysym) {
-                                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;
-                        }
+                // Identify the key and possibly change binding->type
+                uint32_t key_val = 0;
+                error = identify_key(split->items[i], binding->keys->length == 0,
+                                     &key_val, &binding->type);
+                if (error) {
+                        free_sway_binding(binding);
+                        list_free(split);
+                        return error;
                 }
+
                 uint32_t *key = calloc(1, sizeof(uint32_t));
                 if (!key) {
                         free_sway_binding(binding);
                         free_flat_list(split);
                         return cmd_results_new(CMD_FAILURE, bindtype,
-                                        "Unable to allocate binding");
+                                        "Unable to allocate binding key");
                 }
-
-                if (bindcode) {
-                        *key = (uint32_t)keycode;
-                } else {
-                        *key = (uint32_t)keysym;
-                }
-
+                *key = key_val;
                 list_add(binding->keys, key);
         }
         free_flat_list(split);
         binding->order = binding_order++;
 
+        // refine region of interest for mouse binding once we are certain
+        // that this is one
+        if (exclude_titlebar) {
+                binding->flags &= ~BINDING_TITLEBAR;
+        } else if (binding->type == BINDING_MOUSE) {
+                binding->flags |= BINDING_TITLEBAR;
+        }
+
         // sort ascending
         list_qsort(binding->keys, key_qsort_cmp);
 
         list_t *mode_bindings;
-        if (bindcode) {
+        if (binding->type == BINDING_KEYCODE) {
                 mode_bindings = config->current_mode->keycode_bindings;
-        } else {
+        } else if (binding->type == BINDING_KEYSYM) {
                 mode_bindings = config->current_mode->keysym_bindings;
+        } else {
+                mode_bindings = config->current_mode->mouse_bindings;
         }
 
         // overwrite the binding if it already exists
@@ -209,3 +267,19 @@ struct cmd_results *cmd_bindsym(int argc, char **argv) {
 struct cmd_results *cmd_bindcode(int argc, char **argv) {
         return cmd_bindsym_or_bindcode(argc, argv, true);
 }
+
+
+/**
+ * Execute the command associated to a binding
+ */
+void seat_execute_command(struct sway_seat *seat, struct sway_binding *binding) {
+        wlr_log(WLR_DEBUG, "running command for binding: %s",
+                binding->command);
+        config->handler_context.seat = seat;
+        struct cmd_results *results = execute_command(binding->command, NULL);
+        if (results->status != CMD_SUCCESS) {
+                wlr_log(WLR_DEBUG, "could not run command for binding: %s (%s)",
+                        binding->command, results->error);
+        }
+        free_cmd_results(results);
+}
diff --git a/sway/commands/focus_follows_mouse.c b/sway/commands/focus_follows_mouse.c
index 661e7852..0b0e334c 100644
--- a/sway/commands/focus_follows_mouse.c
+++ b/sway/commands/focus_follows_mouse.c
@@ -1,12 +1,14 @@
 #include <string.h>
 #include <strings.h>
 #include "sway/commands.h"
+#include "util.h"
 
 struct cmd_results *cmd_focus_follows_mouse(int argc, char **argv) {
         struct cmd_results *error = NULL;
         if ((error = checkarg(argc, "focus_follows_mouse", EXPECTED_EQUAL_TO, 1))) {
                 return error;
         }
-        config->focus_follows_mouse = !strcasecmp(argv[0], "yes");
+        config->focus_follows_mouse =
+                parse_boolean(argv[0], config->focus_follows_mouse);
         return cmd_results_new(CMD_SUCCESS, NULL, NULL);
 }
diff --git a/sway/commands/focus_wrapping.c b/sway/commands/focus_wrapping.c
index 0a9e0bf2..562ee4f9 100644
--- a/sway/commands/focus_wrapping.c
+++ b/sway/commands/focus_wrapping.c
@@ -1,6 +1,7 @@
 #include <strings.h>
 #include "sway/commands.h"
 #include "sway/config.h"
+#include "util.h"
 
 struct cmd_results *cmd_focus_wrapping(int argc, char **argv) {
         struct cmd_results *error = NULL;
@@ -8,15 +9,12 @@ struct cmd_results *cmd_focus_wrapping(int argc, char **argv) {
                 return error;
         }
 
-        if (strcasecmp(argv[0], "no") == 0) {
-                config->focus_wrapping = WRAP_NO;
-        } else if (strcasecmp(argv[0], "yes") == 0) {
-                config->focus_wrapping = WRAP_YES;
-        } else if (strcasecmp(argv[0], "force") == 0) {
+        if (strcasecmp(argv[0], "force") == 0) {
                 config->focus_wrapping = WRAP_FORCE;
+        } else if (parse_boolean(argv[0], config->focus_wrapping == WRAP_YES)) {
+                config->focus_wrapping = WRAP_YES;
         } else {
-                return cmd_results_new(CMD_INVALID, "focus_wrapping",
-                                "Expected 'focus_wrapping yes|no|force'");
+                config->focus_wrapping = WRAP_NO;
         }
 
         return cmd_results_new(CMD_SUCCESS, NULL, NULL);
diff --git a/sway/commands/force_focus_wrapping.c b/sway/commands/force_focus_wrapping.c
index bc1d067f..0892d9e9 100644
--- a/sway/commands/force_focus_wrapping.c
+++ b/sway/commands/force_focus_wrapping.c
@@ -1,6 +1,7 @@
 #include <strings.h>
 #include "sway/commands.h"
 #include "sway/config.h"
+#include "util.h"
 
 struct cmd_results *cmd_force_focus_wrapping(int argc, char **argv) {
         struct cmd_results *error =
@@ -9,13 +10,10 @@ struct cmd_results *cmd_force_focus_wrapping(int argc, char **argv) {
                 return error;
         }
 
-        if (strcasecmp(argv[0], "no") == 0) {
-                config->focus_wrapping = WRAP_YES;
-        } else if (strcasecmp(argv[0], "yes") == 0) {
+        if (parse_boolean(argv[0], config->focus_wrapping == WRAP_FORCE)) {
                 config->focus_wrapping = WRAP_FORCE;
         } else {
-                return cmd_results_new(CMD_INVALID, "force_focus_wrapping",
-                                "Expected 'force_focus_wrapping yes|no'");
+                config->focus_wrapping = WRAP_YES;
         }
 
         return cmd_results_new(CMD_SUCCESS, NULL, NULL);
diff --git a/sway/commands/fullscreen.c b/sway/commands/fullscreen.c
index 0b5beaa2..b423fd23 100644
--- a/sway/commands/fullscreen.c
+++ b/sway/commands/fullscreen.c
@@ -5,6 +5,7 @@
 #include "sway/tree/container.h"
 #include "sway/tree/view.h"
 #include "sway/tree/layout.h"
+#include "util.h"
 
 struct cmd_results *cmd_fullscreen(int argc, char **argv) {
         struct cmd_results *error = NULL;
@@ -18,17 +19,10 @@ struct cmd_results *cmd_fullscreen(int argc, char **argv) {
                                 "Only views can fullscreen");
         }
         struct sway_view *view = container->sway_view;
-        bool wants_fullscreen;
+        bool wants_fullscreen = !view->is_fullscreen;
 
-        if (argc == 0 || strcmp(argv[0], "toggle") == 0) {
-                wants_fullscreen = !view->is_fullscreen;
-        } else if (strcmp(argv[0], "enable") == 0) {
-                wants_fullscreen = true;
-        } else if (strcmp(argv[0], "disable") == 0) {
-                wants_fullscreen = false;
-        } else {
-                return cmd_results_new(CMD_INVALID, "fullscreen",
-                                "Expected 'fullscreen' or 'fullscreen <enable|disable|toggle>'");
+        if (argc) {
+                wants_fullscreen = parse_boolean(argv[0], view->is_fullscreen);
         }
 
         view_set_fullscreen(view, wants_fullscreen);
diff --git a/sway/commands/input/drag_lock.c b/sway/commands/input/drag_lock.c
index 9e32816f..f9ddeef2 100644
--- a/sway/commands/input/drag_lock.c
+++ b/sway/commands/input/drag_lock.c
@@ -3,6 +3,7 @@
 #include "sway/config.h"
 #include "sway/commands.h"
 #include "sway/input/input-manager.h"
+#include "util.h"
 
 struct cmd_results *input_cmd_drag_lock(int argc, char **argv) {
         struct cmd_results *error = NULL;
@@ -18,14 +19,10 @@ struct cmd_results *input_cmd_drag_lock(int argc, char **argv) {
         struct input_config *new_config =
                 new_input_config(current_input_config->identifier);
 
-        if (strcasecmp(argv[0], "enabled") == 0) {
+        if (parse_boolean(argv[0], true)) {
                 new_config->drag_lock = LIBINPUT_CONFIG_DRAG_LOCK_ENABLED;
-        } else if (strcasecmp(argv[0], "disabled") == 0) {
-                new_config->drag_lock = LIBINPUT_CONFIG_DRAG_LOCK_DISABLED;
         } else {
-                free_input_config(new_config);
-                return cmd_results_new(CMD_INVALID, "drag_lock",
-                        "Expected 'drag_lock <enabled|disabled>'");
+                new_config->drag_lock = LIBINPUT_CONFIG_DRAG_LOCK_DISABLED;
         }
 
         apply_input_config(new_config);
diff --git a/sway/commands/input/dwt.c b/sway/commands/input/dwt.c
index 73937507..15134268 100644
--- a/sway/commands/input/dwt.c
+++ b/sway/commands/input/dwt.c
@@ -3,6 +3,7 @@
 #include "sway/config.h"
 #include "sway/commands.h"
 #include "sway/input/input-manager.h"
+#include "util.h"
 
 struct cmd_results *input_cmd_dwt(int argc, char **argv) {
         struct cmd_results *error = NULL;
@@ -17,14 +18,10 @@ struct cmd_results *input_cmd_dwt(int argc, char **argv) {
         struct input_config *new_config =
                 new_input_config(current_input_config->identifier);
 
-        if (strcasecmp(argv[0], "enabled") == 0) {
+        if (parse_boolean(argv[0], true)) {
                 new_config->dwt = LIBINPUT_CONFIG_DWT_ENABLED;
-        } else if (strcasecmp(argv[0], "disabled") == 0) {
-                new_config->dwt = LIBINPUT_CONFIG_DWT_DISABLED;
         } else {
-                free_input_config(new_config);
-                return cmd_results_new(CMD_INVALID, "dwt",
-                        "Expected 'dwt <enabled|disabled>'");
+                new_config->dwt = LIBINPUT_CONFIG_DWT_DISABLED;
         }
 
         apply_input_config(new_config);
diff --git a/sway/commands/input/left_handed.c b/sway/commands/input/left_handed.c
index 769ce98c..e770043a 100644
--- a/sway/commands/input/left_handed.c
+++ b/sway/commands/input/left_handed.c
@@ -3,6 +3,7 @@
 #include "sway/config.h"
 #include "sway/commands.h"
 #include "sway/input/input-manager.h"
+#include "util.h"
 
 struct cmd_results *input_cmd_left_handed(int argc, char **argv) {
         struct cmd_results *error = NULL;
@@ -18,15 +19,7 @@ struct cmd_results *input_cmd_left_handed(int argc, char **argv) {
         struct input_config *new_config =
                 new_input_config(current_input_config->identifier);
 
-        if (strcasecmp(argv[0], "enabled") == 0) {
-                new_config->left_handed = 1;
-        } else if (strcasecmp(argv[0], "disabled") == 0) {
-                new_config->left_handed = 0;
-        } else {
-                free_input_config(new_config);
-                return cmd_results_new(CMD_INVALID, "left_handed",
-                        "Expected 'left_handed <enabled|disabled>'");
-        }
+        new_config->left_handed = parse_boolean(argv[0], true);
 
         apply_input_config(new_config);
         return cmd_results_new(CMD_SUCCESS, NULL, NULL);
diff --git a/sway/commands/input/middle_emulation.c b/sway/commands/input/middle_emulation.c
index 7ca01629..414d4d2b 100644
--- a/sway/commands/input/middle_emulation.c
+++ b/sway/commands/input/middle_emulation.c
@@ -3,6 +3,7 @@
 #include "sway/config.h"
 #include "sway/commands.h"
 #include "sway/input/input-manager.h"
+#include "util.h"
 
 struct cmd_results *input_cmd_middle_emulation(int argc, char **argv) {
         struct cmd_results *error = NULL;
@@ -18,15 +19,11 @@ struct cmd_results *input_cmd_middle_emulation(int argc, char **argv) {
         struct input_config *new_config =
                 new_input_config(current_input_config->identifier);
 
-        if (strcasecmp(argv[0], "enabled") == 0) {
+        if (parse_boolean(argv[0], true)) {
                 new_config->middle_emulation = LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED;
-        } else if (strcasecmp(argv[0], "disabled") == 0) {
+        } else {
                 new_config->middle_emulation =
                         LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED;
-        } else {
-                free_input_config(new_config);
-                return cmd_results_new(CMD_INVALID, "middle_emulation",
-                        "Expected 'middle_emulation <enabled|disabled>'");
         }
 
         apply_input_config(new_config);
diff --git a/sway/commands/input/natural_scroll.c b/sway/commands/input/natural_scroll.c
index 55236790..77c3ff00 100644
--- a/sway/commands/input/natural_scroll.c
+++ b/sway/commands/input/natural_scroll.c
@@ -3,6 +3,7 @@
 #include "sway/config.h"
 #include "sway/commands.h"
 #include "sway/input/input-manager.h"
+#include "util.h"
 
 struct cmd_results *input_cmd_natural_scroll(int argc, char **argv) {
         struct cmd_results *error = NULL;
@@ -18,15 +19,7 @@ struct cmd_results *input_cmd_natural_scroll(int argc, char **argv) {
         struct input_config *new_config =
                 new_input_config(current_input_config->identifier);
 
-        if (strcasecmp(argv[0], "enabled") == 0) {
-                new_config->natural_scroll = 1;
-        } else if (strcasecmp(argv[0], "disabled") == 0) {
-                new_config->natural_scroll = 0;
-        } else {
-                free_input_config(new_config);
-                return cmd_results_new(CMD_INVALID, "natural_scroll",
-                        "Expected 'natural_scroll <enabled|disabled>'");
-        }
+        new_config->natural_scroll = parse_boolean(argv[0], true);
 
         apply_input_config(new_config);
         return cmd_results_new(CMD_SUCCESS, NULL, NULL);
diff --git a/sway/commands/input/tap.c b/sway/commands/input/tap.c
index a8d1a10c..ac3b8237 100644
--- a/sway/commands/input/tap.c
+++ b/sway/commands/input/tap.c
@@ -4,6 +4,7 @@
 #include "sway/commands.h"
 #include "sway/input/input-manager.h"
 #include "log.h"
+#include "util.h"
 
 struct cmd_results *input_cmd_tap(int argc, char **argv) {
         struct cmd_results *error = NULL;
@@ -18,14 +19,10 @@ struct cmd_results *input_cmd_tap(int argc, char **argv) {
         struct input_config *new_config =
                 new_input_config(current_input_config->identifier);
 
-        if (strcasecmp(argv[0], "enabled") == 0) {
+        if (parse_boolean(argv[0], true)) {
                 new_config->tap = LIBINPUT_CONFIG_TAP_ENABLED;
-        } else if (strcasecmp(argv[0], "disabled") == 0) {
-                new_config->tap = LIBINPUT_CONFIG_TAP_DISABLED;
         } else {
-                free_input_config(new_config);
-                return cmd_results_new(CMD_INVALID, "tap",
-                        "Expected 'tap <enabled|disabled>'");
+                new_config->tap = LIBINPUT_CONFIG_TAP_DISABLED;
         }
 
         wlr_log(WLR_DEBUG, "apply-tap for device: %s",
diff --git a/sway/commands/output/dpms.c b/sway/commands/output/dpms.c
index 0959ea6b..3492061e 100644
--- a/sway/commands/output/dpms.c
+++ b/sway/commands/output/dpms.c
@@ -1,5 +1,6 @@
 #include "sway/commands.h"
 #include "sway/config.h"
+#include "util.h"
 
 struct cmd_results *output_cmd_dpms(int argc, char **argv) {
         if (!config->handler_context.output_config) {
@@ -9,13 +10,10 @@ struct cmd_results *output_cmd_dpms(int argc, char **argv) {
                 return cmd_results_new(CMD_INVALID, "output", "Missing dpms argument.");
         }
 
-        if (strcmp(*argv, "on") == 0) {
+        if (parse_boolean(argv[0], true)) {
                 config->handler_context.output_config->dpms_state = DPMS_ON;
-        } else if (strcmp(*argv, "off") == 0) {
-                config->handler_context.output_config->dpms_state = DPMS_OFF;
         } else {
-                return cmd_results_new(CMD_INVALID, "output",
-                                "Invalid dpms state, valid states are on/off.");
+                config->handler_context.output_config->dpms_state = DPMS_OFF;
         }
 
         config->handler_context.leftovers.argc = argc - 1;
diff --git a/sway/commands/show_marks.c b/sway/commands/show_marks.c
index c7fdc538..434a0e27 100644
--- a/sway/commands/show_marks.c
+++ b/sway/commands/show_marks.c
@@ -7,6 +7,7 @@
 #include "list.h"
 #include "log.h"
 #include "stringop.h"
+#include "util.h"
 
 static void rebuild_marks_iterator(struct sway_container *con, void *data) {
         if (con->type == C_VIEW) {
@@ -20,14 +21,7 @@ struct cmd_results *cmd_show_marks(int argc, char **argv) {
                 return error;
         }
 
-        if (strcmp(*argv, "yes") == 0) {
-                config->show_marks = true;
-        } else if (strcmp(*argv, "no") == 0) {
-                config->show_marks = false;
-        } else {
-                return cmd_results_new(CMD_INVALID, "show_marks",
-                                "Expected 'show_marks <yes|no>'");
-        }
+        config->show_marks = parse_boolean(argv[0], config->show_marks);
 
         if (config->show_marks) {
                 container_for_each_descendant_dfs(&root_container,
diff --git a/sway/commands/urgent.c b/sway/commands/urgent.c
index d199858a..51c497c4 100644
--- a/sway/commands/urgent.c
+++ b/sway/commands/urgent.c
@@ -5,6 +5,7 @@
 #include "sway/tree/container.h"
 #include "sway/tree/view.h"
 #include "sway/tree/layout.h"
+#include "util.h"
 
 struct cmd_results *cmd_urgent(int argc, char **argv) {
         struct cmd_results *error = NULL;
@@ -19,17 +20,12 @@ struct cmd_results *cmd_urgent(int argc, char **argv) {
         }
         struct sway_view *view = container->sway_view;
 
-        if (strcmp(argv[0], "enable") == 0) {
-                view_set_urgent(view, true);
-        } else if (strcmp(argv[0], "disable") == 0) {
-                view_set_urgent(view, false);
-        } else if (strcmp(argv[0], "allow") == 0) {
+        if (strcmp(argv[0], "allow") == 0) {
                 view->allow_request_urgent = true;
         } else if (strcmp(argv[0], "deny") == 0) {
                 view->allow_request_urgent = false;
         } else {
-                return cmd_results_new(CMD_INVALID, "urgent",
-                                "Expected 'urgent <enable|disable|allow|deny>'");
+                view_set_urgent(view, parse_boolean(argv[0], view_is_urgent(view)));
         }
 
         return cmd_results_new(CMD_SUCCESS, NULL, NULL);
diff --git a/sway/config.c b/sway/config.c
index 5f6dd7ad..90dfb9a9 100644
--- a/sway/config.c
+++ b/sway/config.c
@@ -56,6 +56,12 @@ static void free_mode(struct sway_mode *mode) {
                 }
                 list_free(mode->keycode_bindings);
         }
+        if (mode->mouse_bindings) {
+                for (i = 0; i < mode->mouse_bindings->length; i++) {
+                        free_sway_binding(mode->mouse_bindings->items[i]);
+                }
+                list_free(mode->mouse_bindings);
+        }
         free(mode);
 }
 
@@ -170,6 +176,7 @@ static void config_defaults(struct sway_config *config) {
         strcpy(config->current_mode->name, "default");
         if (!(config->current_mode->keysym_bindings = create_list())) goto cleanup;
         if (!(config->current_mode->keycode_bindings = create_list())) goto cleanup;
+        if (!(config->current_mode->mouse_bindings = create_list())) goto cleanup;
         list_add(config->modes, config->current_mode);
 
         config->floating_mod = 0;
diff --git a/sway/input/cursor.c b/sway/input/cursor.c
index 65d04cac..27597640 100644
--- a/sway/input/cursor.c
+++ b/sway/input/cursor.c
@@ -460,6 +460,12 @@ static void dispatch_cursor_button_floating(struct sway_cursor *cursor,
         bool resizing_via_mod = button == BTN_RIGHT && mod_pressed;
         if ((resizing_via_border || resizing_via_mod) &&
                         state == WLR_BUTTON_PRESSED) {
+                if (edge == WLR_EDGE_NONE) {
+                        edge |= cursor->cursor->x > cont->x + cont->width / 2 ?
+                                WLR_EDGE_RIGHT : WLR_EDGE_LEFT;
+                        edge |= cursor->cursor->y > cont->y + cont->height / 2 ?
+                                WLR_EDGE_BOTTOM : WLR_EDGE_TOP;
+                }
                 seat_begin_resize(seat, cont, button, edge);
                 return;
         }
@@ -469,6 +475,83 @@ static void dispatch_cursor_button_floating(struct sway_cursor *cursor,
         seat_pointer_notify_button(seat, time_msec, button, state);
 }
 
+/**
+ * Remove a button (and duplicates) to the sorted list of currently pressed buttons
+ */
+static void state_erase_button(struct sway_cursor *cursor, uint32_t button) {
+        size_t j = 0;
+        for (size_t i = 0; i < cursor->pressed_button_count; ++i) {
+                if (i > j) {
+                        cursor->pressed_buttons[j] = cursor->pressed_buttons[i];
+                }
+                if (cursor->pressed_buttons[i] != button) {
+                        ++j;
+                }
+        }
+        while (cursor->pressed_button_count > j) {
+                --cursor->pressed_button_count;
+                cursor->pressed_buttons[cursor->pressed_button_count] = 0;
+        }
+}
+
+/**
+ * Add a button to the sorted list of currently pressed buttons, if there
+ * is space.
+ */
+static void state_add_button(struct sway_cursor *cursor, uint32_t button) {
+        if (cursor->pressed_button_count >= SWAY_CURSOR_PRESSED_BUTTONS_CAP) {
+                return;
+        }
+        size_t i = 0;
+        while (i < cursor->pressed_button_count && cursor->pressed_buttons[i] < button) {
+                ++i;
+        }
+        size_t j = cursor->pressed_button_count;
+        while (j > i) {
+                cursor->pressed_buttons[j] = cursor->pressed_buttons[j - 1];
+                --j;
+        }
+        cursor->pressed_buttons[i] = button;
+        cursor->pressed_button_count++;
+}
+
+/**
+ * Return the mouse binding which matches modifier, click location, release,
+ * and pressed button state, otherwise return null.
+ */
+static struct sway_binding* get_active_mouse_binding(const struct sway_cursor *cursor,
+                list_t *bindings, uint32_t modifiers, bool release, bool on_titlebar,
+                                     bool on_border, bool on_content) {
+        uint32_t click_region = (on_titlebar ? BINDING_TITLEBAR : 0) |
+                        (on_border ? BINDING_BORDER : 0) |
+                        (on_content ? BINDING_CONTENTS : 0);
+
+        for (int i = 0; i < bindings->length; ++i) {
+                struct sway_binding *binding = bindings->items[i];
+                if (modifiers ^ binding->modifiers ||
+                                cursor->pressed_button_count != (size_t)binding->keys->length ||
+                                release != (binding->flags & BINDING_RELEASE) ||
+                                !(click_region & binding->flags)) {
+                        continue;
+                }
+
+                bool match = true;
+                for (size_t j = 0; j < cursor->pressed_button_count; j++) {
+                        uint32_t key = *(uint32_t *)binding->keys->items[j];
+                        if (key != cursor->pressed_buttons[j]) {
+                                match = false;
+                                break;
+                        }
+                }
+                if (!match) {
+                        continue;
+                }
+
+                return binding;
+        }
+        return NULL;
+}
+
 void dispatch_cursor_button(struct sway_cursor *cursor,
                 uint32_t time_msec, uint32_t button, enum wlr_button_state state) {
         if (cursor->seat->operation != OP_NONE &&
@@ -485,6 +568,31 @@ void dispatch_cursor_button(struct sway_cursor *cursor,
         double sx, sy;
         struct sway_container *cont = container_at_coords(cursor->seat,
                         cursor->cursor->x, cursor->cursor->y, &surface, &sx, &sy);
+
+        // Handle mouse bindings
+        bool on_border = cont && (find_resize_edge(cont, cursor) != WLR_EDGE_NONE);
+        bool on_contents = !on_border && surface;
+        bool on_titlebar = !on_border && !surface;
+        struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(cursor->seat->wlr_seat);
+        uint32_t modifiers = keyboard ? wlr_keyboard_get_modifiers(keyboard) : 0;
+
+        struct sway_binding *binding = NULL;
+        if (state == WLR_BUTTON_PRESSED) {
+                state_add_button(cursor, button);
+                binding = get_active_mouse_binding(cursor,
+                        config->current_mode->mouse_bindings, modifiers, false,
+                        on_titlebar, on_border, on_contents);
+        } else {
+                binding = get_active_mouse_binding(cursor,
+                        config->current_mode->mouse_bindings, modifiers, true,
+                        on_titlebar, on_border, on_contents);
+                state_erase_button(cursor, button);
+        }
+        if (binding) {
+                seat_execute_command(cursor->seat, binding);
+                // TODO: do we want to pass on the event?
+        }
+
         if (surface && wlr_surface_is_layer_surface(surface)) {
                 struct wlr_layer_surface *layer =
                         wlr_layer_surface_from_wlr_surface(surface);
diff --git a/sway/input/keyboard.c b/sway/input/keyboard.c
index ede38519..49241db8 100644
--- a/sway/input/keyboard.c
+++ b/sway/input/keyboard.c
@@ -3,11 +3,11 @@
 #include <wlr/backend/multi.h>
 #include <wlr/backend/session.h>
 #include <wlr/types/wlr_idle.h>
+#include "sway/commands.h"
 #include "sway/desktop/transaction.h"
-#include "sway/input/seat.h"
-#include "sway/input/keyboard.h"
 #include "sway/input/input-manager.h"
-#include "sway/commands.h"
+#include "sway/input/keyboard.h"
+#include "sway/input/seat.h"
 #include "log.h"
 
 /**
@@ -88,11 +88,13 @@ static void get_active_binding(const struct sway_shortcut_state *state,
                 uint32_t modifiers, bool release, bool locked) {
         for (int i = 0; i < bindings->length; ++i) {
                 struct sway_binding *binding = bindings->items[i];
+                bool binding_locked = binding->flags & BINDING_LOCKED;
+                bool binding_release = binding->flags & BINDING_RELEASE;
 
                 if (modifiers ^ binding->modifiers ||
                                 state->npressed != (size_t)binding->keys->length ||
-                                locked > binding->locked ||
-                                release != binding->release) {
+                                release != binding_release ||
+                                locked > binding_locked) {
                         continue;
                 }
 
@@ -119,23 +121,6 @@ static void get_active_binding(const struct sway_shortcut_state *state,
 }
 
 /**
- * Execute the command associated to a binding
- */
-static void keyboard_execute_command(struct sway_keyboard *keyboard,
-                struct sway_binding *binding) {
-        wlr_log(WLR_DEBUG, "running command for binding: %s",
-                binding->command);
-        config->handler_context.seat = keyboard->seat_device->sway_seat;
-        struct cmd_results *results = execute_command(binding->command, NULL);
-        transaction_commit_dirty();
-        if (results->status != CMD_SUCCESS) {
-                wlr_log(WLR_DEBUG, "could not run command for binding: %s (%s)",
-                        binding->command, results->error);
-        }
-        free_cmd_results(results);
-}
-
-/**
  * Execute a built-in, hardcoded compositor binding. These are triggered from a
  * single keysym.
  *
@@ -211,12 +196,13 @@ static size_t keyboard_keysyms_raw(struct sway_keyboard *keyboard,
 static void handle_keyboard_key(struct wl_listener *listener, void *data) {
         struct sway_keyboard *keyboard =
                 wl_container_of(listener, keyboard, keyboard_key);
-        struct wlr_seat *wlr_seat = keyboard->seat_device->sway_seat->wlr_seat;
+        struct sway_seat* seat = keyboard->seat_device->sway_seat;
+        struct wlr_seat *wlr_seat = seat->wlr_seat;
         struct wlr_input_device *wlr_device =
                 keyboard->seat_device->input_device->wlr_device;
-        wlr_idle_notify_activity(keyboard->seat_device->sway_seat->input->server->idle, wlr_seat);
+        wlr_idle_notify_activity(seat->input->server->idle, wlr_seat);
         struct wlr_event_keyboard_key *event = data;
-        bool input_inhibited = keyboard->seat_device->sway_seat->exclusive_client != NULL;
+        bool input_inhibited = seat->exclusive_client != NULL;
 
         // Identify new keycode, raw keysym(s), and translated keysym(s)
         xkb_keycode_t keycode = event->keycode + 8;
@@ -266,7 +252,7 @@ static void handle_keyboard_key(struct wl_listener *listener, void *data) {
         // 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);
+                seat_execute_command(seat, keyboard->held_binding);
                 handled = true;
         }
         if (binding_released != keyboard->held_binding) {
@@ -290,7 +276,7 @@ static void handle_keyboard_key(struct wl_listener *listener, void *data) {
                                 raw_modifiers, false, input_inhibited);
 
                 if (binding_pressed) {
-                        keyboard_execute_command(keyboard, binding_pressed);
+                        seat_execute_command(seat, binding_pressed);
                         handled = true;
                 }
         }
@@ -312,6 +298,8 @@ static void handle_keyboard_key(struct wl_listener *listener, void *data) {
                 wlr_seat_keyboard_notify_key(wlr_seat, event->time_msec,
                                 event->keycode, event->state);
         }
+
+        transaction_commit_dirty();
 }
 
 static void handle_keyboard_modifiers(struct wl_listener *listener,
diff --git a/sway/tree/workspace.c b/sway/tree/workspace.c
index b1082e4f..62974cd7 100644
--- a/sway/tree/workspace.c
+++ b/sway/tree/workspace.c
@@ -108,96 +108,103 @@ static bool workspace_valid_on_output(const char *output_name,
         return true;
 }
 
-char *workspace_next_name(const char *output_name) {
-        wlr_log(WLR_DEBUG, "Workspace: Generating new workspace name for output %s",
-                        output_name);
-        // Scan all workspace bindings to find the next available workspace name,
-        // if none are found/available then default to a number
-        struct sway_mode *mode = config->current_mode;
-
-        // TODO: iterate over keycode bindings too
-        int order = INT_MAX;
-        char *target = NULL;
-        for (int i = 0; i < mode->keysym_bindings->length; ++i) {
-                struct sway_binding *binding = mode->keysym_bindings->items[i];
-                char *cmdlist = strdup(binding->command);
-                char *dup = cmdlist;
-                char *name = NULL;
-
-                // workspace n
-                char *cmd = argsep(&cmdlist, " ");
-                if (cmdlist) {
-                        name = argsep(&cmdlist, ",;");
+static void workspace_name_from_binding(const struct sway_binding * binding,
+                const char* output_name, int *min_order, char **earliest_name) {
+        char *cmdlist = strdup(binding->command);
+        char *dup = cmdlist;
+        char *name = NULL;
+
+        // workspace n
+        char *cmd = argsep(&cmdlist, " ");
+        if (cmdlist) {
+                name = argsep(&cmdlist, ",;");
+        }
+
+        if (strcmp("workspace", cmd) == 0 && name) {
+                char *_target = strdup(name);
+                _target = do_var_replacement(_target);
+                strip_quotes(_target);
+                while (isspace(*_target)) {
+                        memmove(_target, _target+1, strlen(_target+1));
                 }
+                wlr_log(WLR_DEBUG, "Got valid workspace command for target: '%s'",
+                                _target);
 
-                if (strcmp("workspace", cmd) == 0 && name) {
-                        char *_target = strdup(name);
-                        _target = do_var_replacement(_target);
-                        strip_quotes(_target);
-                        while (isspace(*_target)) {
-                                memmove(_target, _target+1, strlen(_target+1));
-                        }
-                        wlr_log(WLR_DEBUG, "Got valid workspace command for target: '%s'",
-                                        _target);
-
-                        // Make sure that the command references an actual workspace
-                        // not a command about workspaces
-                        if (strcmp(_target, "next") == 0 ||
+                // Make sure that the command references an actual workspace
+                // not a command about workspaces
+                if (strcmp(_target, "next") == 0 ||
                                 strcmp(_target, "prev") == 0 ||
                                 strcmp(_target, "next_on_output") == 0 ||
                                 strcmp(_target, "prev_on_output") == 0 ||
                                 strcmp(_target, "number") == 0 ||
                                 strcmp(_target, "back_and_forth") == 0 ||
-                                strcmp(_target, "current") == 0)
-                        {
-                                free(_target);
-                                free(dup);
-                                continue;
-                        }
-
-                        // If the command is workspace number <name>, isolate the name
-                        if (strncmp(_target, "number ", strlen("number ")) == 0) {
-                                size_t length = strlen(_target) - strlen("number ") + 1;
-                                char *temp = malloc(length);
-                                strncpy(temp, _target + strlen("number "), length - 1);
-                                temp[length - 1] = '\0';
-                                free(_target);
-                                _target = temp;
-                                wlr_log(WLR_DEBUG, "Isolated name from workspace number: '%s'", _target);
-
-                                // Make sure the workspace number doesn't already exist
-                                if (workspace_by_number(_target)) {
-                                        free(_target);
-                                        free(dup);
-                                        continue;
-                                }
-                        }
+                                strcmp(_target, "current") == 0) {
+                        free(_target);
+                        free(dup);
+                        return;
+                }
 
-                        // Make sure that the workspace doesn't already exist
-                        if (workspace_by_name(_target)) {
+                // If the command is workspace number <name>, isolate the name
+                if (strncmp(_target, "number ", strlen("number ")) == 0) {
+                        size_t length = strlen(_target) - strlen("number ") + 1;
+                        char *temp = malloc(length);
+                        strncpy(temp, _target + strlen("number "), length - 1);
+                        temp[length - 1] = '\0';
+                        free(_target);
+                        _target = temp;
+                        wlr_log(WLR_DEBUG, "Isolated name from workspace number: '%s'", _target);
+
+                        // Make sure the workspace number doesn't already exist
+                        if (workspace_by_number(_target)) {
                                 free(_target);
                                 free(dup);
-                                continue;
+                                return;
                         }
+                }
 
-                        // make sure that the workspace can appear on the given
-                        // output
-                        if (!workspace_valid_on_output(output_name, _target)) {
-                                free(_target);
-                                free(dup);
-                                continue;
-                        }
+                // Make sure that the workspace doesn't already exist
+                if (workspace_by_name(_target)) {
+                        free(_target);
+                        free(dup);
+                        return;
+                }
 
-                        if (binding->order < order) {
-                                order = binding->order;
-                                free(target);
-                                target = _target;
-                                wlr_log(WLR_DEBUG, "Workspace: Found free name %s", _target);
-                        } else {
-                                free(_target);
-                        }
+                // make sure that the workspace can appear on the given
+                // output
+                if (!workspace_valid_on_output(output_name, _target)) {
+                        free(_target);
+                        free(dup);
+                        return;
                 }
-                free(dup);
+
+                if (binding->order < *min_order) {
+                        *min_order = binding->order;
+                        free(*earliest_name);
+                        *earliest_name = _target;
+                        wlr_log(WLR_DEBUG, "Workspace: Found free name %s", _target);
+                } else {
+                        free(_target);
+                }
+        }
+        free(dup);
+}
+
+char *workspace_next_name(const char *output_name) {
+        wlr_log(WLR_DEBUG, "Workspace: Generating new workspace name for output %s",
+                        output_name);
+        // Scan all workspace bindings to find the next available workspace name,
+        // if none are found/available then default to a number
+        struct sway_mode *mode = config->current_mode;
+
+        int order = INT_MAX;
+        char *target = NULL;
+        for (int i = 0; i < mode->keysym_bindings->length; ++i) {
+                workspace_name_from_binding(mode->keysym_bindings->items[i],
+                                output_name, &order, &target);
+        }
+        for (int i = 0; i < mode->keycode_bindings->length; ++i) {
+                workspace_name_from_binding(mode->keycode_bindings->items[i],
+                                output_name, &order, &target);
         }
         if (target != NULL) {
                 return target;