input config

17 files changed, 490 insertions, 26 deletions

diff --git a/include/sway/commands.h b/include/sway/commands.h
index b1f0423d..138e3c29 100644
--- a/include/sway/commands.h
+++ b/include/sway/commands.h
@@ -1,6 +1,8 @@
 #ifndef _SWAY_COMMANDS_H
 #define _SWAY_COMMANDS_H
 
+#include "config.h"
+
 /**
  * Indicates the result of a command's execution.
  */
@@ -39,6 +41,8 @@ enum expected_args {
         EXPECTED_EQUAL_TO
 };
 
+void input_cmd_apply(struct input_config *input);
+
 struct cmd_results *checkarg(int argc, const char *name,
                 enum expected_args type, int val);
 
diff --git a/include/sway/input/input-manager.h b/include/sway/input/input-manager.h
index 9548c170..78bc161f 100644
--- a/include/sway/input/input-manager.h
+++ b/include/sway/input/input-manager.h
@@ -5,6 +5,8 @@
 #include "sway/config.h"
 #include "list.h"
 
+extern struct input_config *current_input_config;
+
 struct sway_input_manager {
         struct wl_listener input_add;
         struct wl_listener input_remove;
diff --git a/sway/commands.c b/sway/commands.c
index 05a66a7f..7710c6ab 100644
--- a/sway/commands.c
+++ b/sway/commands.c
@@ -9,6 +9,7 @@
 #include "sway/commands.h"
 #include "sway/config.h"
 #include "sway/security.h"
+#include "sway/input/input-manager.h"
 #include "stringop.h"
 #include "log.h"
 
@@ -56,6 +57,44 @@ struct cmd_results *checkarg(int argc, const char *name, enum expected_args type
         return error;
 }
 
+void input_cmd_apply(struct input_config *input) {
+        int i;
+        i = list_seq_find(config->input_configs, input_identifier_cmp, input->identifier);
+        if (i >= 0) {
+                // merge existing config
+                struct input_config *ic = config->input_configs->items[i];
+                merge_input_config(ic, input);
+                free_input_config(input);
+                input = ic;
+        } else {
+                list_add(config->input_configs, input);
+        }
+
+        current_input_config = input;
+
+        if (input->identifier) {
+                // Try to find the input device and apply configuration now. If
+                // this is during startup then there will be no container and config
+                // will be applied during normal "new input" event from wlc.
+                /* TODO WLR
+                struct libinput_device *device = NULL;
+                for (int i = 0; i < input_devices->length; ++i) {
+                        device = input_devices->items[i];
+                        char* dev_identifier = libinput_dev_unique_id(device);
+                        if (!dev_identifier) {
+                                break;
+                        }
+                        int match = dev_identifier && strcmp(dev_identifier, input->identifier) == 0;
+                        free(dev_identifier);
+                        if (match) {
+                                apply_input_config(input, device);
+                                break;
+                        }
+                }
+                */
+        }
+}
+
 /**
  * Check and add color to buffer.
  *
@@ -96,6 +135,7 @@ static struct cmd_handler handlers[] = {
         { "exec_always", cmd_exec_always },
         { "exit", cmd_exit },
         { "include", cmd_include },
+        { "input", cmd_input },
 };
 
 static int handler_compare(const void *_a, const void *_b) {
@@ -104,37 +144,35 @@ static int handler_compare(const void *_a, const void *_b) {
         return strcasecmp(a->command, b->command);
 }
 
+static struct cmd_handler input_handlers[] = {
+        { "accel_profile", input_cmd_accel_profile },
+        { "click_method", input_cmd_click_method },
+        { "drag_lock", input_cmd_drag_lock },
+        { "dwt", input_cmd_dwt },
+        { "events", input_cmd_events },
+        { "left_handed", input_cmd_left_handed },
+        { "middle_emulation", input_cmd_middle_emulation },
+        { "natural_scroll", input_cmd_natural_scroll },
+        { "pointer_accel", input_cmd_pointer_accel },
+        { "scroll_method", input_cmd_scroll_method },
+        { "tap", input_cmd_tap },
+};
+
 static struct cmd_handler *find_handler(char *line, enum cmd_status block) {
         struct cmd_handler d = { .command=line };
         struct cmd_handler *res = NULL;
         sway_log(L_DEBUG, "find_handler(%s) %d", line, block == CMD_BLOCK_INPUT);
-        /* TODO
-        if (block == CMD_BLOCK_BAR) {
-                res = bsearch(&d, bar_handlers,
-                        sizeof(bar_handlers) / sizeof(struct cmd_handler),
-                        sizeof(struct cmd_handler), handler_compare);
-        } else if (block == CMD_BLOCK_BAR_COLORS){
-                res = bsearch(&d, bar_colors_handlers,
-                        sizeof(bar_colors_handlers) / sizeof(struct cmd_handler),
-                        sizeof(struct cmd_handler), handler_compare);
-        } else if (block == CMD_BLOCK_INPUT) {
+
+        if (block == CMD_BLOCK_INPUT) {
                 res = bsearch(&d, input_handlers,
-                        sizeof(input_handlers) / sizeof(struct cmd_handler),
-                        sizeof(struct cmd_handler), handler_compare);
-        } else if (block == CMD_BLOCK_IPC) {
-                res = bsearch(&d, ipc_handlers,
-                        sizeof(ipc_handlers) / sizeof(struct cmd_handler),
-                        sizeof(struct cmd_handler), handler_compare);
-        } else if (block == CMD_BLOCK_IPC_EVENTS) {
-                res = bsearch(&d, ipc_event_handlers,
-                        sizeof(ipc_event_handlers) / sizeof(struct cmd_handler),
-                        sizeof(struct cmd_handler), handler_compare);
+                                sizeof(input_handlers) / sizeof(struct cmd_handler),
+                                sizeof(struct cmd_handler), handler_compare);
         } else {
-        */
                 res = bsearch(&d, handlers,
-                        sizeof(handlers) / sizeof(struct cmd_handler),
-                        sizeof(struct cmd_handler), handler_compare);
-        //}
+                                sizeof(handlers) / sizeof(struct cmd_handler),
+                                sizeof(struct cmd_handler), handler_compare);
+        }
+
         return res;
 }
 
@@ -238,8 +276,8 @@ struct cmd_results *config_command(char *exec, enum cmd_status block) {
                 argv[i] = do_var_replacement(argv[i]);
                 unescape_string(argv[i]);
         }
-        /* Strip quotes for first argument.
-         * TODO This part needs to be handled much better */
+        // Strip quotes for first argument.
+        // TODO This part needs to be handled much better
         if (argc>1 && (*argv[1] == '\"' || *argv[1] == '\'')) {
                 strip_quotes(argv[1]);
         }
diff --git a/sway/commands/input.c b/sway/commands/input.c
new file mode 100644
index 00000000..5ca9c2e6
--- /dev/null
+++ b/sway/commands/input.c
@@ -0,0 +1,55 @@
+#include <string.h>
+#include <strings.h>
+#include "sway/commands.h"
+#include "sway/input/input-manager.h"
+#include "log.h"
+
+struct cmd_results *cmd_input(int argc, char **argv) {
+        struct cmd_results *error = NULL;
+        if ((error = checkarg(argc, "input", EXPECTED_AT_LEAST, 2))) {
+                return error;
+        }
+
+        if (config->reading && strcmp("{", argv[1]) == 0) {
+                current_input_config = new_input_config(argv[0]);
+                sway_log(L_DEBUG, "entering input block: %s", current_input_config->identifier);
+                return cmd_results_new(CMD_BLOCK_INPUT, NULL, NULL);
+        }
+
+        if (argc > 2) {
+                int argc_new = argc-2;
+                char **argv_new = argv+2;
+
+                struct cmd_results *res;
+                current_input_config = new_input_config(argv[0]);
+                if (strcasecmp("accel_profile", argv[1]) == 0) {
+                        res = input_cmd_accel_profile(argc_new, argv_new);
+                } else if (strcasecmp("click_method", argv[1]) == 0) {
+                        res = input_cmd_click_method(argc_new, argv_new);
+                } else if (strcasecmp("drag_lock", argv[1]) == 0) {
+                        res = input_cmd_drag_lock(argc_new, argv_new);
+                } else if (strcasecmp("dwt", argv[1]) == 0) {
+                        res = input_cmd_dwt(argc_new, argv_new);
+                } else if (strcasecmp("events", argv[1]) == 0) {
+                        res = input_cmd_events(argc_new, argv_new);
+                } else if (strcasecmp("left_handed", argv[1]) == 0) {
+                        res = input_cmd_left_handed(argc_new, argv_new);
+                } else if (strcasecmp("middle_emulation", argv[1]) == 0) {
+                        res = input_cmd_middle_emulation(argc_new, argv_new);
+                } else if (strcasecmp("natural_scroll", argv[1]) == 0) {
+                        res = input_cmd_natural_scroll(argc_new, argv_new);
+                } else if (strcasecmp("pointer_accel", argv[1]) == 0) {
+                        res = input_cmd_pointer_accel(argc_new, argv_new);
+                } else if (strcasecmp("scroll_method", argv[1]) == 0) {
+                        res = input_cmd_scroll_method(argc_new, argv_new);
+                } else if (strcasecmp("tap", argv[1]) == 0) {
+                        res = input_cmd_tap(argc_new, argv_new);
+                } else {
+                        res = cmd_results_new(CMD_INVALID, "input <device>", "Unknown command %s", argv[1]);
+                }
+                current_input_config = NULL;
+                return res;
+        }
+
+        return cmd_results_new(CMD_BLOCK_INPUT, NULL, NULL);
+}
diff --git a/sway/commands/input/accel_profile.c b/sway/commands/input/accel_profile.c
new file mode 100644
index 00000000..13ded431
--- /dev/null
+++ b/sway/commands/input/accel_profile.c
@@ -0,0 +1,27 @@
+#include <string.h>
+#include <strings.h>
+#include "sway/commands.h"
+#include "sway/input/input-manager.h"
+
+struct cmd_results *input_cmd_accel_profile(int argc, char **argv) {
+        struct cmd_results *error = NULL;
+        if ((error = checkarg(argc, "accel_profile", EXPECTED_AT_LEAST, 1))) {
+                return error;
+        }
+        if (!current_input_config) {
+                return cmd_results_new(CMD_FAILURE, "accel_profile", "No input device defined.");
+        }
+        struct input_config *new_config = new_input_config(current_input_config->identifier);
+
+        if (strcasecmp(argv[0], "adaptive") == 0) {
+                new_config->accel_profile = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE;
+        } else if (strcasecmp(argv[0], "flat") == 0) {
+                new_config->accel_profile = LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT;
+        } else {
+                return cmd_results_new(CMD_INVALID, "accel_profile",
+                                "Expected 'accel_profile <adaptive|flat>'");
+        }
+
+        input_cmd_apply(new_config);
+        return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+}
diff --git a/sway/commands/input/click_method.c b/sway/commands/input/click_method.c
new file mode 100644
index 00000000..40f075ce
--- /dev/null
+++ b/sway/commands/input/click_method.c
@@ -0,0 +1,30 @@
+#include <string.h>
+#include <strings.h>
+#include "sway/commands.h"
+#include "sway/input/input-manager.h"
+#include "log.h"
+
+struct cmd_results *input_cmd_click_method(int argc, char **argv) {
+        sway_log(L_DEBUG, "click_method for device:  %d %s", current_input_config==NULL, current_input_config->identifier);
+        struct cmd_results *error = NULL;
+        if ((error = checkarg(argc, "click_method", EXPECTED_AT_LEAST, 1))) {
+                return error;
+        }
+        if (!current_input_config) {
+                return cmd_results_new(CMD_FAILURE, "click_method", "No input device defined.");
+        }
+        struct input_config *new_config = new_input_config(current_input_config->identifier);
+
+        if (strcasecmp(argv[0], "none") == 0) {
+                new_config->click_method = LIBINPUT_CONFIG_CLICK_METHOD_NONE;
+        } else if (strcasecmp(argv[0], "button_areas") == 0) {
+                new_config->click_method = LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS;
+        } else if (strcasecmp(argv[0], "clickfinger") == 0) {
+                new_config->click_method = LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER;
+        } else {
+                return cmd_results_new(CMD_INVALID, "click_method", "Expected 'click_method <none|button_areas|clickfinger'");
+        }
+
+        input_cmd_apply(new_config);
+        return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+}
diff --git a/sway/commands/input/drag_lock.c b/sway/commands/input/drag_lock.c
new file mode 100644
index 00000000..11e7fbea
--- /dev/null
+++ b/sway/commands/input/drag_lock.c
@@ -0,0 +1,26 @@
+#include <string.h>
+#include <strings.h>
+#include "sway/commands.h"
+#include "sway/input/input-manager.h"
+
+struct cmd_results *input_cmd_drag_lock(int argc, char **argv) {
+        struct cmd_results *error = NULL;
+        if ((error = checkarg(argc, "drag_lock", EXPECTED_AT_LEAST, 1))) {
+                return error;
+        }
+        if (!current_input_config) {
+                return cmd_results_new(CMD_FAILURE, "drag_lock", "No input device defined.");
+        }
+        struct input_config *new_config = new_input_config(current_input_config->identifier);
+
+        if (strcasecmp(argv[0], "enabled") == 0) {
+                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 {
+                return cmd_results_new(CMD_INVALID, "drag_lock", "Expected 'drag_lock <enabled|disabled>'");
+        }
+
+        input_cmd_apply(new_config);
+        return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+}
diff --git a/sway/commands/input/dwt.c b/sway/commands/input/dwt.c
new file mode 100644
index 00000000..f3cbf252
--- /dev/null
+++ b/sway/commands/input/dwt.c
@@ -0,0 +1,26 @@
+#include <string.h>
+#include <strings.h>
+#include "sway/commands.h"
+#include "sway/input/input-manager.h"
+
+struct cmd_results *input_cmd_dwt(int argc, char **argv) {
+        struct cmd_results *error = NULL;
+        if ((error = checkarg(argc, "dwt", EXPECTED_AT_LEAST, 1))) {
+                return error;
+        }
+        if (!current_input_config) {
+                return cmd_results_new(CMD_FAILURE, "dwt", "No input device defined.");
+        }
+        struct input_config *new_config = new_input_config(current_input_config->identifier);
+
+        if (strcasecmp(argv[0], "enabled") == 0) {
+                new_config->dwt = LIBINPUT_CONFIG_DWT_ENABLED;
+        } else if (strcasecmp(argv[0], "disabled") == 0) {
+                new_config->dwt = LIBINPUT_CONFIG_DWT_DISABLED;
+        } else {
+                return cmd_results_new(CMD_INVALID, "dwt", "Expected 'dwt <enabled|disabled>'");
+        }
+
+        input_cmd_apply(new_config);
+        return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+}
diff --git a/sway/commands/input/events.c b/sway/commands/input/events.c
new file mode 100644
index 00000000..4b2fdff5
--- /dev/null
+++ b/sway/commands/input/events.c
@@ -0,0 +1,30 @@
+#include <string.h>
+#include <strings.h>
+#include "sway/commands.h"
+#include "sway/input/input-manager.h"
+#include "log.h"
+
+struct cmd_results *input_cmd_events(int argc, char **argv) {
+        sway_log(L_DEBUG, "events for device: %s", current_input_config->identifier);
+        struct cmd_results *error = NULL;
+        if ((error = checkarg(argc, "events", EXPECTED_AT_LEAST, 1))) {
+                return error;
+        }
+        if (!current_input_config) {
+                return cmd_results_new(CMD_FAILURE, "events", "No input device defined.");
+        }
+        struct input_config *new_config = new_input_config(current_input_config->identifier);
+
+        if (strcasecmp(argv[0], "enabled") == 0) {
+                new_config->send_events = LIBINPUT_CONFIG_SEND_EVENTS_ENABLED;
+        } else if (strcasecmp(argv[0], "disabled") == 0) {
+                new_config->send_events = LIBINPUT_CONFIG_SEND_EVENTS_DISABLED;
+        } else if (strcasecmp(argv[0], "disabled_on_external_mouse") == 0) {
+                new_config->send_events = LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE;
+        } else {
+                return cmd_results_new(CMD_INVALID, "events", "Expected 'events <enabled|disabled|disabled_on_external_mouse>'");
+        }
+
+        input_cmd_apply(new_config);
+        return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+}
diff --git a/sway/commands/input/left_handed.c b/sway/commands/input/left_handed.c
new file mode 100644
index 00000000..715df2a1
--- /dev/null
+++ b/sway/commands/input/left_handed.c
@@ -0,0 +1,26 @@
+#include <string.h>
+#include <strings.h>
+#include "sway/commands.h"
+#include "sway/input/input-manager.h"
+
+struct cmd_results *input_cmd_left_handed(int argc, char **argv) {
+        struct cmd_results *error = NULL;
+        if ((error = checkarg(argc, "left_handed", EXPECTED_AT_LEAST, 1))) {
+                return error;
+        }
+        if (!current_input_config) {
+                return cmd_results_new(CMD_FAILURE, "left_handed", "No input device defined.");
+        }
+        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 {
+                return cmd_results_new(CMD_INVALID, "left_handed", "Expected 'left_handed <enabled|disabled>'");
+        }
+
+        input_cmd_apply(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
new file mode 100644
index 00000000..d31ce950
--- /dev/null
+++ b/sway/commands/input/middle_emulation.c
@@ -0,0 +1,26 @@
+#include <string.h>
+#include <strings.h>
+#include "sway/commands.h"
+#include "sway/input/input-manager.h"
+
+struct cmd_results *input_cmd_middle_emulation(int argc, char **argv) {
+        struct cmd_results *error = NULL;
+        if ((error = checkarg(argc, "middle_emulation", EXPECTED_AT_LEAST, 1))) {
+                return error;
+        }
+        if (!current_input_config) {
+                return cmd_results_new(CMD_FAILURE, "middle_emulation", "No input device defined.");
+        }
+        struct input_config *new_config = new_input_config(current_input_config->identifier);
+
+        if (strcasecmp(argv[0], "enabled") == 0) {
+                new_config->middle_emulation = LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED;
+        } else if (strcasecmp(argv[0], "disabled") == 0) {
+                new_config->middle_emulation = LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED;
+        } else {
+                return cmd_results_new(CMD_INVALID, "middle_emulation", "Expected 'middle_emulation <enabled|disabled>'");
+        }
+
+        input_cmd_apply(new_config);
+        return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+}
diff --git a/sway/commands/input/natural_scroll.c b/sway/commands/input/natural_scroll.c
new file mode 100644
index 00000000..9d1dc506
--- /dev/null
+++ b/sway/commands/input/natural_scroll.c
@@ -0,0 +1,26 @@
+#include <string.h>
+#include <strings.h>
+#include "sway/commands.h"
+#include "sway/input/input-manager.h"
+
+struct cmd_results *input_cmd_natural_scroll(int argc, char **argv) {
+        struct cmd_results *error = NULL;
+        if ((error = checkarg(argc, "natural_scroll", EXPECTED_AT_LEAST, 1))) {
+                return error;
+        }
+        if (!current_input_config) {
+                return cmd_results_new(CMD_FAILURE, "natural_scoll", "No input device defined.");
+        }
+        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 {
+                return cmd_results_new(CMD_INVALID, "natural_scroll", "Expected 'natural_scroll <enabled|disabled>'");
+        }
+
+        input_cmd_apply(new_config);
+        return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+}
diff --git a/sway/commands/input/pointer_accel.c b/sway/commands/input/pointer_accel.c
new file mode 100644
index 00000000..87fb5cff
--- /dev/null
+++ b/sway/commands/input/pointer_accel.c
@@ -0,0 +1,24 @@
+#include <stdlib.h>
+#include <string.h>
+#include "sway/commands.h"
+#include "sway/input/input-manager.h"
+
+struct cmd_results *input_cmd_pointer_accel(int argc, char **argv) {
+        struct cmd_results *error = NULL;
+        if ((error = checkarg(argc, "pointer_accel", EXPECTED_AT_LEAST, 1))) {
+                return error;
+        }
+        if (!current_input_config) {
+                return cmd_results_new(CMD_FAILURE, "pointer_accel", "No input device defined.");
+        }
+        struct input_config *new_config = new_input_config(current_input_config->identifier);
+
+        float pointer_accel = atof(argv[0]);
+        if (pointer_accel < -1 || pointer_accel > 1) {
+                return cmd_results_new(CMD_INVALID, "pointer_accel", "Input out of range [-1, 1]");
+        }
+        new_config->pointer_accel = pointer_accel;
+
+        input_cmd_apply(new_config);
+        return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+}
diff --git a/sway/commands/input/scroll_method.c b/sway/commands/input/scroll_method.c
new file mode 100644
index 00000000..98873938
--- /dev/null
+++ b/sway/commands/input/scroll_method.c
@@ -0,0 +1,30 @@
+#include <string.h>
+#include <strings.h>
+#include "sway/commands.h"
+#include "sway/input/input-manager.h"
+
+struct cmd_results *input_cmd_scroll_method(int argc, char **argv) {
+        struct cmd_results *error = NULL;
+        if ((error = checkarg(argc, "scroll_method", EXPECTED_AT_LEAST, 1))) {
+                return error;
+        }
+        if (!current_input_config) {
+                return cmd_results_new(CMD_FAILURE, "scroll_method", "No input device defined.");
+        }
+        struct input_config *new_config = new_input_config(current_input_config->identifier);
+
+        if (strcasecmp(argv[0], "none") == 0) {
+                new_config->scroll_method = LIBINPUT_CONFIG_SCROLL_NO_SCROLL;
+        } else if (strcasecmp(argv[0], "two_finger") == 0) {
+                new_config->scroll_method = LIBINPUT_CONFIG_SCROLL_2FG;
+        } else if (strcasecmp(argv[0], "edge") == 0) {
+                new_config->scroll_method = LIBINPUT_CONFIG_SCROLL_EDGE;
+        } else if (strcasecmp(argv[0], "on_button_down") == 0) {
+                new_config->scroll_method = LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN;
+        } else {
+                return cmd_results_new(CMD_INVALID, "scroll_method", "Expected 'scroll_method <none|two_finger|edge|on_button_down>'");
+        }
+
+        input_cmd_apply(new_config);
+        return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+}
diff --git a/sway/commands/input/tap.c b/sway/commands/input/tap.c
new file mode 100644
index 00000000..1109466f
--- /dev/null
+++ b/sway/commands/input/tap.c
@@ -0,0 +1,29 @@
+#include <string.h>
+#include <strings.h>
+#include "sway/commands.h"
+#include "sway/input/input-manager.h"
+#include "log.h"
+
+struct cmd_results *input_cmd_tap(int argc, char **argv) {
+        sway_log(L_DEBUG, "tap for device: %s", current_input_config->identifier);
+        struct cmd_results *error = NULL;
+        if ((error = checkarg(argc, "tap", EXPECTED_AT_LEAST, 1))) {
+                return error;
+        }
+        if (!current_input_config) {
+                return cmd_results_new(CMD_FAILURE, "tap", "No input device defined.");
+        }
+        struct input_config *new_config = new_input_config(current_input_config->identifier);
+
+        if (strcasecmp(argv[0], "enabled") == 0) {
+                new_config->tap = LIBINPUT_CONFIG_TAP_ENABLED;
+        } else if (strcasecmp(argv[0], "disabled") == 0) {
+                new_config->tap = LIBINPUT_CONFIG_TAP_DISABLED;
+        } else {
+                return cmd_results_new(CMD_INVALID, "tap", "Expected 'tap <enabled|disabled>'");
+        }
+
+        sway_log(L_DEBUG, "apply-tap for device: %s", current_input_config->identifier);
+        input_cmd_apply(new_config);
+        return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+}
diff --git a/sway/config.c b/sway/config.c
index 61131845..ec8e89b4 100644
--- a/sway/config.c
+++ b/sway/config.c
@@ -226,6 +226,59 @@ static int qstrcmp(const void* a, const void* b) {
         return strcmp(*((char**) a), *((char**) b));
 }
 
+void merge_input_config(struct input_config *dst, struct input_config *src) {
+        if (src->identifier) {
+                if (dst->identifier) {
+                        free(dst->identifier);
+                }
+                dst->identifier = strdup(src->identifier);
+        }
+        if (src->accel_profile != INT_MIN) {
+                dst->accel_profile = src->accel_profile;
+        }
+        if (src->click_method != INT_MIN) {
+                dst->click_method = src->click_method;
+        }
+        if (src->drag_lock != INT_MIN) {
+                dst->drag_lock = src->drag_lock;
+        }
+        if (src->dwt != INT_MIN) {
+                dst->dwt = src->dwt;
+        }
+        if (src->middle_emulation != INT_MIN) {
+                dst->middle_emulation = src->middle_emulation;
+        }
+        if (src->natural_scroll != INT_MIN) {
+                dst->natural_scroll = src->natural_scroll;
+        }
+        if (src->pointer_accel != FLT_MIN) {
+                dst->pointer_accel = src->pointer_accel;
+        }
+        if (src->scroll_method != INT_MIN) {
+                dst->scroll_method = src->scroll_method;
+        }
+        if (src->send_events != INT_MIN) {
+                dst->send_events = src->send_events;
+        }
+        if (src->tap != INT_MIN) {
+                dst->tap = src->tap;
+        }
+}
+
+void free_input_config(struct input_config *ic) {
+        if (!ic) {
+                return;
+        }
+        free(ic->identifier);
+        free(ic);
+}
+
+int input_identifier_cmp(const void *item, const void *data) {
+        const struct input_config *ic = item;
+        const char *identifier = data;
+        return strcmp(ic->identifier, identifier);
+}
+
 bool load_main_config(const char *file, bool is_active) {
         char *path;
         if (file != NULL) {
diff --git a/sway/meson.build b/sway/meson.build
index 79201f3a..aa3dd2a7 100644
--- a/sway/meson.build
+++ b/sway/meson.build
@@ -10,6 +10,18 @@ sway_sources = files(
         'commands/exec.c',
         'commands/exec_always.c',
         'commands/include.c',
+        'commands/input.c',
+        'commands/input/accel_profile.c',
+        'commands/input/click_method.c',
+        'commands/input/drag_lock.c',
+        'commands/input/dwt.c',
+        'commands/input/events.c',
+        'commands/input/left_handed.c',
+        'commands/input/middle_emulation.c',
+        'commands/input/natural_scroll.c',
+        'commands/input/pointer_accel.c',
+        'commands/input/scroll_method.c',
+        'commands/input/tap.c',
         'config.c',
         'ipc-json.c',
         'ipc-server.c',