Workspace movement with touchpad gestures

common/gesture.c

@@ -90,6 +90,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 format_str(
+ "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 format_str("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 format_str("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:
@@ -100,6 +154,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;
@@ -313,6 +371,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

@@ -115,6 +115,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

@@ -51,6 +51,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
 };
 
 /**
@@ -501,6 +502,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/fx_util/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

@@ -15,6 +15,19 @@ struct decoration_data get_undecorated_decoration_data();
 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 decoration_data {
  float alpha;
  float saturation;
@@ -32,6 +45,7 @@ struct render_data {
  pixman_region32_t *damage;
  struct wlr_box *clip_box;
  struct decoration_data deco_data;
+ bool on_focused_workspace;
  struct sway_view *view;
 };
 
@@ -71,6 +85,8 @@ struct sway_output {
  struct wl_listener needs_frame;
  struct wl_listener request_state;
 
+ struct workspace_scroll workspace_scroll;
+
  struct {
  struct wl_signal disable;
  } events;
@@ -227,6 +243,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

@@ -70,11 +70,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);
+}