input config

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);
 

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;

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);
 	} else {
-	*/
 		res = bsearch(&d, handlers,
 				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]);
 	}

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);
+}

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);
+}

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);
+}

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);
+}

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);
+}

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);
+}

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);
+}

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);
+}

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);
+}

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);
+}

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);
+}

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);
+}

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) {

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',