Workspace movement with touchpad gestures

common/gesture.c

@@ -107,6 +107,60 @@ char *gesture_parse(const char *input, struct gesture *output) {
 	return NULL;
 }
 
+// Similar to gesture_parse but with fewer checks to match the different
+// workspace_gesture syntax
+char *workspace_gesture_parse(const char *input, struct gesture *output) {
+	// Clear output in case of failure
+	output->type = GESTURE_TYPE_NONE;
+	output->fingers = GESTURE_FINGERS_ANY;
+	output->directions = GESTURE_DIRECTION_NONE;
+
+	// Split input type, fingers and directions
+	list_t *split = split_string(input, ":");
+	if (split->length < 1 || split->length > 2) {
+		return strformat(
+				"expected [:<fingers>][:direction], got %s",
+				input);
+	}
+
+	// Parse optional arguments
+	if (split->length > 1) {
+		char *next = split->items[0];
+
+		// Try to parse as finger count (1-9)
+		if (strlen(next) == 1 && '1' <= next[0] && next[0] <= '9') {
+			output->fingers = atoi(next);
+
+			// Move to next if available
+			next = split->length == 2 ? split->items[1] : NULL;
+		} else if (split->length == 2) {
+			// Fail here if argument can only be finger count
+			return strformat("expected 1-9, got %s", next);
+		}
+
+		// If there is an argument left, try to parse as direction
+		if (next) {
+			list_t *directions = split_string(next, "+");
+
+			for (int i = 0; i < directions->length; ++i) {
+				const char *item = directions->items[i];
+				if (strcmp(item, "horizontal") == 0) {
+					output->type = GESTURE_TYPE_WORKSPACE_SWIPE_HORIZONTAL;
+				} else if (strcmp(item, "vertical") == 0) {
+					output->type = GESTURE_TYPE_WORKSPACE_SWIPE_VERTICAL;
+				} else {
+					return strformat("expected direction, got %s", item);
+				}
+			}
+			list_free_items_and_destroy(directions);
+		}
+	} // if optional args
+
+	list_free_items_and_destroy(split);
+
+	return NULL;
+}
+
 const char *gesture_type_string(enum gesture_type type) {
 	switch (type) {
 	case GESTURE_TYPE_NONE:
@@ -117,6 +171,10 @@ const char *gesture_type_string(enum gesture_type type) {
 		return "pinch";
 	case GESTURE_TYPE_SWIPE:
 		return "swipe";
+	case GESTURE_TYPE_WORKSPACE_SWIPE_HORIZONTAL:
+		return "workspace_swipe_horizontal";
+	case GESTURE_TYPE_WORKSPACE_SWIPE_VERTICAL:
+		return "workspace_swipe_vertical";
 	}
 
 	return NULL;
@@ -330,6 +388,8 @@ struct gesture *gesture_tracker_end(struct gesture_tracker *tracker) {
 		}
 	// Gesture without any direction
 	case GESTURE_TYPE_HOLD:
+	case GESTURE_TYPE_WORKSPACE_SWIPE_HORIZONTAL:
+	case GESTURE_TYPE_WORKSPACE_SWIPE_VERTICAL:
 		break;
 	// Not tracking any gesture
 	case GESTURE_TYPE_NONE:

include/gesture.h

@@ -12,6 +12,8 @@ enum gesture_type {
 	GESTURE_TYPE_HOLD,
 	GESTURE_TYPE_PINCH,
 	GESTURE_TYPE_SWIPE,
+	GESTURE_TYPE_WORKSPACE_SWIPE_HORIZONTAL,
+	GESTURE_TYPE_WORKSPACE_SWIPE_VERTICAL,
 };
 
 // Turns single type enum value to constant string representation.
@@ -57,6 +59,13 @@ struct gesture {
  */
 char *gesture_parse(const char *input, struct gesture *output);
 
+/**
+ * Parses workspace gesture from [:<fingers>][:<directions>] string.
+ *
+ * Return NULL on success, otherwise error message string
+ */
+char *workspace_gesture_parse(const char *input, struct gesture *output);
+
 // Turns gesture into string representation
 char *gesture_to_string(struct gesture *gesture);
 

include/sway/commands.h

@@ -114,6 +114,7 @@ sway_cmd cmd_bindcode;
 sway_cmd cmd_bindgesture;
 sway_cmd cmd_bindswitch;
 sway_cmd cmd_bindsym;
+sway_cmd cmd_bindworkspacegesture;
 sway_cmd cmd_blur;
 sway_cmd cmd_blur_brightness;
 sway_cmd cmd_blur_contrast;
@@ -223,11 +224,15 @@ sway_cmd cmd_unbindcode;
 sway_cmd cmd_unbindswitch;
 sway_cmd cmd_unbindgesture;
 sway_cmd cmd_unbindsym;
+sway_cmd cmd_unbindworkspacegesture;
 sway_cmd cmd_unmark;
 sway_cmd cmd_urgent;
 sway_cmd cmd_workspace;
 sway_cmd cmd_workspace_layout;
 sway_cmd cmd_ws_auto_back_and_forth;
+sway_cmd cmd_ws_gesture_spring_size;
+sway_cmd cmd_ws_gesture_threshold;
+sway_cmd cmd_ws_gesture_wrap_around;
 sway_cmd cmd_xwayland;
 
 sway_cmd bar_cmd_bindcode;

include/sway/config.h

@@ -49,6 +49,7 @@ enum binding_flags {
 	BINDING_INHIBITED = 1 << 7, // keyboard only: ignore shortcut inhibitor
 	BINDING_NOREPEAT = 1 << 8, // keyboard only; do not trigger when repeating a held key
 	BINDING_EXACT = 1 << 9, // gesture only; only trigger on exact match
+	BINDING_INVERTED = 1 << 10, // workspace gesture only; gesture is inverted
 };
 
 /**
@@ -506,6 +507,10 @@ struct sway_config {
 	bool titlebar_separator;
 	bool scratchpad_minimize;
 
+	int workspace_gesture_spring_size;
+	bool workspace_gesture_wrap_around;
+	float workspace_gesture_threshold;
+
 	list_t *layer_criteria;
 
 	char *swaynag_command;

include/sway/desktop/fx_renderer/animation_utils.h

@@ -0,0 +1,10 @@
+#ifndef ANIMATION_UTILS_H
+#define ANIMATION_UTILS_H
+
+double lerp (double a, double b, double t);
+
+double ease_out_cubic (double t);
+
+// TODO: Add more easing functions in the future like ease_in and ease_in_out, etc...
+
+#endif

include/sway/output.h

@@ -13,10 +13,24 @@
 struct sway_server;
 struct sway_container;
 
+enum swipe_gesture_direction {
+	SWIPE_GESTURE_DIRECTION_NONE,
+	SWIPE_GESTURE_DIRECTION_HORIZONTAL,
+	SWIPE_GESTURE_DIRECTION_VERTICAL,
+};
+
+struct workspace_scroll {
+	double percent;
+	double avg_velocity;
+	int num_updates;
+	enum swipe_gesture_direction direction;
+};
+
 struct render_data {
 	pixman_region32_t *damage;
 	struct wlr_box *clip_box;
 	struct decoration_data deco_data;
+	bool on_focused_workspace;
 };
 
 struct sway_output_state {
@@ -58,6 +72,8 @@ struct sway_output {
 	struct wl_listener frame;
 	struct wl_listener needs_frame;
 
+	struct workspace_scroll workspace_scroll;
+
 	struct {
 		struct wl_signal disable;
 	} events;
@@ -200,6 +216,20 @@ void handle_output_manager_test(struct wl_listener *listener, void *data);
 void handle_output_power_manager_set_mode(struct wl_listener *listener,
 	void *data);
 
+struct workspace_scroll workspace_scroll_get_default();
+
+bool workspace_scroll_equal(struct workspace_scroll *a, struct workspace_scroll *b);
+
+void workspace_scroll_begin(struct sway_seat *seat,
+		enum swipe_gesture_direction direction);
+
+void workspace_scroll_update(struct sway_seat *seat, struct gesture_tracker *tracker,
+		struct wlr_pointer_swipe_update_event *event, int invert);
+
+void workspace_scroll_end(struct sway_seat *seat);
+
+void workspace_scroll_reset(struct sway_seat *seat, struct sway_workspace *ws);
+
 struct sway_output_non_desktop *output_non_desktop_create(struct wlr_output *wlr_output);
 
 #endif

include/sway/tree/workspace.h

@@ -69,11 +69,13 @@ struct sway_workspace *workspace_by_number(const char* name);
 
 struct sway_workspace *workspace_by_name(const char*);
 
-struct sway_workspace *workspace_output_next(struct sway_workspace *current);
+struct sway_workspace *workspace_output_next(struct sway_workspace *current,
+		bool should_wrap);
 
 struct sway_workspace *workspace_next(struct sway_workspace *current);
 
-struct sway_workspace *workspace_output_prev(struct sway_workspace *current);
+struct sway_workspace *workspace_output_prev(struct sway_workspace *current,
+		bool should_wrap);
 
 struct sway_workspace *workspace_prev(struct sway_workspace *current);
 

sway/commands.c

@@ -49,6 +49,7 @@ static const struct cmd_handler handlers[] = {
 	{ "bindgesture", cmd_bindgesture },
 	{ "bindswitch", cmd_bindswitch },
 	{ "bindsym", cmd_bindsym },
+	{ "bindworkspacegesture", cmd_bindworkspacegesture },
 	{ "blur", cmd_blur },
     { "blur_brightness", cmd_blur_brightness },
 	{ "blur_contrast", cmd_blur_contrast },
@@ -118,8 +119,12 @@ static const struct cmd_handler handlers[] = {
 	{ "unbindgesture", cmd_unbindgesture },
 	{ "unbindswitch", cmd_unbindswitch },
 	{ "unbindsym", cmd_unbindsym },
+	{ "unbindworkspacegesture", cmd_unbindworkspacegesture },
 	{ "workspace", cmd_workspace },
 	{ "workspace_auto_back_and_forth", cmd_ws_auto_back_and_forth },
+	{ "workspace_gesture_spring_size", cmd_ws_gesture_spring_size },
+	{ "workspace_gesture_threshold", cmd_ws_gesture_threshold },
+	{ "workspace_gesture_wrap_around", cmd_ws_gesture_wrap_around },
 };
 
 /* Config-time only commands. Keep alphabetized */

sway/commands/gesture.c

@@ -164,3 +164,76 @@ struct cmd_results *cmd_bindgesture(int argc, char **argv) {
 struct cmd_results *cmd_unbindgesture(int argc, char **argv) {
 	return cmd_bind_or_unbind_gesture(argc, argv, true);
 }
+
+/**
+ * Parse and execute bindgesture or unbindgesture command.
+ */
+static struct cmd_results *cmd_bind_or_unbind_workspacegesture(int argc,
+		char **argv, bool unbind) {
+	int minargs = 1;
+	char *bindtype = "bindgesture";
+	if (unbind) {
+		bindtype = "unbindgesture";
+	}
+
+	struct cmd_results *error = NULL;
+	if ((error = checkarg(argc, bindtype, EXPECTED_AT_LEAST, minargs))) {
+		return error;
+	}
+	struct sway_gesture_binding *binding = calloc(1, sizeof(struct sway_gesture_binding));
+	if (!binding) {
+		return cmd_results_new(CMD_FAILURE, "Unable to allocate binding");
+	}
+	binding->input = strdup("*");
+
+	bool warn = true;
+
+	// Handle flags
+	binding->flags |= BINDING_EXACT;
+	while (argc > 0) {
+		if (strcmp("--inverted", argv[0]) == 0) {
+			binding->flags |= BINDING_INVERTED;
+		} else if (strcmp("--no-warn", argv[0]) == 0) {
+			warn = false;
+		} else if (strncmp("--input-device=", argv[0],
+					strlen("--input-device=")) == 0) {
+			free(binding->input);
+			binding->input = strdup(argv[0] + strlen("--input-device="));
+		} else {
+			break;
+		}
+		argv++;
+		argc--;
+	}
+
+	if (argc < minargs) {
+		free(binding);
+		return cmd_results_new(CMD_FAILURE,
+				"Invalid %s command (expected at least %d "
+				"non-option arguments, got %d)", bindtype, minargs, argc);
+	}
+
+	char* errmsg = NULL;
+	if ((errmsg = workspace_gesture_parse(argv[0], &binding->gesture))) {
+		free(binding);
+		struct cmd_results *final = cmd_results_new(CMD_FAILURE,
+				"Invalid %s command (%s)",
+				bindtype, errmsg);
+		free(errmsg);
+		return final;
+	}
+
+	if (unbind) {
+		return gesture_binding_remove(binding, argv[0]);
+	}
+	binding->command = NULL;
+	return gesture_binding_add(binding, argv[0], warn);
+}
+
+struct cmd_results *cmd_bindworkspacegesture(int argc, char **argv) {
+	return cmd_bind_or_unbind_workspacegesture(argc, argv, false);
+}
+
+struct cmd_results *cmd_unbindworkspacegesture(int argc, char **argv) {
+	return cmd_bind_or_unbind_workspacegesture(argc, argv, true);
+}

sway/commands/workspace.c

@@ -6,10 +6,12 @@
 #include "sway/commands.h"
 #include "sway/config.h"
 #include "sway/input/seat.h"
+#include "sway/output.h"
 #include "sway/tree/workspace.h"
 #include "list.h"
 #include "log.h"
 #include "stringop.h"
+#include "util.h"
 
 static struct workspace_config *workspace_config_find_or_create(char *ws_name) {
 	struct workspace_config *wsc = workspace_find_config(ws_name);

sway/commands/workspace_gesture.c

@@ -0,0 +1,49 @@
+#define _POSIX_C_SOURCE 200809L
+#include "sway/commands.h"
+#include "sway/config.h"
+#include "util.h"
+
+struct cmd_results *cmd_ws_gesture_spring_size(int argc, char **argv) {
+	struct cmd_results *error = NULL;
+	if ((error = checkarg(argc, "workspace_gesture_spring_size", EXPECTED_EQUAL_TO, 1))) {
+		return error;
+	}
+
+	char *inv;
+	int value = strtol(argv[0], &inv, 10);
+	if (*inv != '\0' || value < 0 || value > 250) {
+		return cmd_results_new(CMD_FAILURE, "Invalid size specified");
+	}
+
+	config->workspace_gesture_spring_size = value;
+
+	return cmd_results_new(CMD_SUCCESS, NULL);
+}
+
+struct cmd_results *cmd_ws_gesture_wrap_around(int argc, char **argv) {
+	struct cmd_results *error = NULL;
+	if ((error = checkarg(argc, "workspace_gesture_wrap_around", EXPECTED_EQUAL_TO, 1))) {
+		return error;
+	}
+
+	config->workspace_gesture_wrap_around = parse_boolean(argv[0], true);
+
+	return cmd_results_new(CMD_SUCCESS, NULL);
+}
+
+struct cmd_results *cmd_ws_gesture_threshold(int argc, char **argv) {
+	struct cmd_results *error = NULL;
+	if ((error = checkarg(argc, "workspace_gesture_threshold", EXPECTED_EQUAL_TO, 1))) {
+		return error;
+	}
+
+	char *err;
+	float val = strtof(argv[0], &err);
+	if (*err || val < 0.1f || val > 0.9f) {
+		return cmd_results_new(CMD_INVALID, "workspace_gesture_threshold float invalid. "
+				"Should be between 0.1 and 0.9");
+	}
+	config->workspace_gesture_threshold = val;
+
+	return cmd_results_new(CMD_SUCCESS, NULL);
+}