1 files changed, 457 insertions, 84 deletions

diff --git a/sway/input/seatop_default.c b/sway/input/seatop_default.c
index a583ed62..c56330fd 100644
--- a/sway/input/seatop_default.c
+++ b/sway/input/seatop_default.c
@@ -2,12 +2,17 @@
 #include <float.h>
 #include <libevdev/libevdev.h>
 #include <wlr/types/wlr_cursor.h>
+#include <wlr/types/wlr_subcompositor.h>
 #include <wlr/types/wlr_tablet_v2.h>
 #include <wlr/types/wlr_xcursor_manager.h>
+#include "gesture.h"
+#include "sway/desktop/transaction.h"
 #include "sway/input/cursor.h"
 #include "sway/input/seat.h"
 #include "sway/input/tablet.h"
+#include "sway/layers.h"
 #include "sway/output.h"
+#include "sway/scene_descriptor.h"
 #include "sway/tree/view.h"
 #include "sway/tree/workspace.h"
 #include "log.h"
@@ -19,6 +24,7 @@ struct seatop_default_event {
         struct sway_node *previous_node;
         uint32_t pressed_buttons[SWAY_CURSOR_PRESSED_BUTTONS_CAP];
         size_t pressed_button_count;
+        struct gesture_tracker gestures;
 };
 
 /*-----------------------------------------\
@@ -50,6 +56,9 @@ static bool edge_is_external(struct sway_container *cont, enum wlr_edges edge) {
         while (cont) {
                 if (container_parent_layout(cont) == layout) {
                         list_t *siblings = container_get_siblings(cont);
+                        if (!siblings) {
+                                return false;
+                        }
                         int index = list_find(siblings, cont);
                         if (index > 0 && (edge == WLR_EDGE_LEFT || edge == WLR_EDGE_TOP)) {
                                 return false;
@@ -59,7 +68,7 @@ static bool edge_is_external(struct sway_container *cont, enum wlr_edges edge) {
                                 return false;
                         }
                 }
-                cont = cont->parent;
+                cont = cont->pending.parent;
         }
         return true;
 }
@@ -69,25 +78,25 @@ static enum wlr_edges find_edge(struct sway_container *cont,
         if (!cont->view || (surface && cont->view->surface != surface)) {
                 return WLR_EDGE_NONE;
         }
-        if (cont->border == B_NONE || !cont->border_thickness ||
-                        cont->border == B_CSD) {
+        if (cont->pending.border == B_NONE || !cont->pending.border_thickness ||
+                        cont->pending.border == B_CSD) {
                 return WLR_EDGE_NONE;
         }
-        if (cont->fullscreen_mode) {
+        if (cont->pending.fullscreen_mode) {
                 return WLR_EDGE_NONE;
         }
 
         enum wlr_edges edge = 0;
-        if (cursor->cursor->x < cont->x + cont->border_thickness) {
+        if (cursor->cursor->x < cont->pending.x + cont->pending.border_thickness) {
                 edge |= WLR_EDGE_LEFT;
         }
-        if (cursor->cursor->y < cont->y + cont->border_thickness) {
+        if (cursor->cursor->y < cont->pending.y + cont->pending.border_thickness) {
                 edge |= WLR_EDGE_TOP;
         }
-        if (cursor->cursor->x >= cont->x + cont->width - cont->border_thickness) {
+        if (cursor->cursor->x >= cont->pending.x + cont->pending.width - cont->pending.border_thickness) {
                 edge |= WLR_EDGE_RIGHT;
         }
-        if (cursor->cursor->y >= cont->y + cont->height - cont->border_thickness) {
+        if (cursor->cursor->y >= cont->pending.y + cont->pending.height - cont->pending.border_thickness) {
                 edge |= WLR_EDGE_BOTTOM;
         }
 
@@ -225,13 +234,15 @@ static void handle_tablet_tool_tip(struct sway_seat *seat,
         struct sway_container *cont = node && node->type == N_CONTAINER ?
                 node->sway_container : NULL;
 
-        if (wlr_surface_is_layer_surface(surface)) {
+        struct wlr_layer_surface_v1 *layer;
+#if HAVE_XWAYLAND
+        struct wlr_xwayland_surface *xsurface;
+#endif
+        if ((layer = wlr_layer_surface_v1_try_from_wlr_surface(surface)) &&
+                        layer->current.keyboard_interactive) {
                 // Handle tapping a layer surface
-                struct wlr_layer_surface_v1 *layer =
-                                wlr_layer_surface_v1_from_wlr_surface(surface);
-                if (layer->current.keyboard_interactive) {
-                        seat_set_focus_layer(seat, layer);
-                }
+                seat_set_focus_layer(seat, layer);
+                transaction_commit_dirty();
         } else if (cont) {
                 bool is_floating_or_child = container_is_floating_or_child(cont);
                 bool is_fullscreen_or_child = container_is_fullscreen_or_child(cont);
@@ -249,26 +260,24 @@ static void handle_tablet_tool_tip(struct sway_seat *seat,
 
                 // Handle moving a tiling container
                 if (config->tiling_drag && mod_pressed && !is_floating_or_child &&
-                                cont->fullscreen_mode == FULLSCREEN_NONE) {
+                                cont->pending.fullscreen_mode == FULLSCREEN_NONE) {
                         seatop_begin_move_tiling(seat, cont);
                         return;
                 }
 
                 // Handle tapping on a container surface
                 seat_set_focus_container(seat, cont);
-                seatop_begin_down(seat, node->sway_container, time_msec, sx, sy);
+                seatop_begin_down(seat, node->sway_container, sx, sy);
         }
 #if HAVE_XWAYLAND
         // Handle tapping on an xwayland unmanaged view
-        else if (wlr_surface_is_xwayland_surface(surface)) {
-                struct wlr_xwayland_surface *xsurface =
-                                wlr_xwayland_surface_from_wlr_surface(surface);
-                if (xsurface->override_redirect &&
-                                wlr_xwayland_or_surface_wants_focus(xsurface)) {
-                        struct wlr_xwayland *xwayland = server.xwayland.wlr_xwayland;
-                        wlr_xwayland_set_seat(xwayland, seat->wlr_seat);
-                        seat_set_focus_surface(seat, xsurface->surface, false);
-                }
+        else if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(surface)) &&
+                        xsurface->override_redirect &&
+                        wlr_xwayland_or_surface_wants_focus(xsurface)) {
+                struct wlr_xwayland *xwayland = server.xwayland.wlr_xwayland;
+                wlr_xwayland_set_seat(xwayland, seat->wlr_seat);
+                seat_set_focus_surface(seat, xsurface->surface, false);
+                transaction_commit_dirty();
         }
 #endif
 
@@ -356,17 +365,21 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
         if (node && node->type == N_WORKSPACE) {
                 if (state == WLR_BUTTON_PRESSED) {
                         seat_set_focus(seat, node);
+                        transaction_commit_dirty();
                 }
                 seat_pointer_notify_button(seat, time_msec, button, state);
                 return;
         }
 
-        // Handle clicking a layer surface
-        if (surface && wlr_surface_is_layer_surface(surface)) {
-                struct wlr_layer_surface_v1 *layer =
-                        wlr_layer_surface_v1_from_wlr_surface(surface);
+        // Handle clicking a layer surface and its popups/subsurfaces
+        struct wlr_layer_surface_v1 *layer = NULL;
+        if ((layer = toplevel_layer_surface_from_surface(surface))) {
                 if (layer->current.keyboard_interactive) {
                         seat_set_focus_layer(seat, layer);
+                        transaction_commit_dirty();
+                }
+                if (state == WLR_BUTTON_PRESSED) {
+                        seatop_begin_down_on_surface(seat, surface, sx, sy);
                 }
                 seat_pointer_notify_button(seat, time_msec, button, state);
                 return;
@@ -381,7 +394,7 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
                 struct sway_container *cont_to_focus = cont;
                 enum sway_container_layout layout = container_parent_layout(cont);
                 if (layout == L_TABBED || layout == L_STACKED) {
-                        cont_to_focus = seat_get_focus_inactive_view(seat, &cont->parent->node);
+                        cont_to_focus = seat_get_focus_inactive_view(seat, &cont->pending.parent->node);
                 }
 
                 seat_set_focus_container(seat, cont_to_focus);
@@ -397,9 +410,9 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
                         BTN_LEFT : BTN_RIGHT;
                 if (button == btn_resize) {
                         edge = 0;
-                        edge |= cursor->cursor->x > cont->x + cont->width / 2 ?
+                        edge |= cursor->cursor->x > cont->pending.x + cont->pending.width / 2 ?
                                 WLR_EDGE_RIGHT : WLR_EDGE_LEFT;
-                        edge |= cursor->cursor->y > cont->y + cont->height / 2 ?
+                        edge |= cursor->cursor->y > cont->pending.y + cont->pending.height / 2 ?
                                 WLR_EDGE_BOTTOM : WLR_EDGE_TOP;
 
                         const char *image = NULL;
@@ -419,13 +432,31 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
                 }
         }
 
+        // Handle changing focus when clicking on a container
+        if (cont && state == WLR_BUTTON_PRESSED) {
+                // Default case: focus the container that was just clicked.
+                node = &cont->node;
+
+                // If the container is a tab/stacked container and the click happened
+                // on a tab, switch to the tab. If the tab contents were already
+                // focused, focus the tab container itself. If the tab container was
+                // already focused, cycle back to focusing the tab contents.
+                if (on_titlebar) {
+                        struct sway_container *focus = seat_get_focused_container(seat);
+                        if (focus == cont || !container_has_ancestor(focus, cont)) {
+                                node = seat_get_focus_inactive(seat, &cont->node);
+                        }
+                }
+
+                seat_set_focus(seat, node);
+                transaction_commit_dirty();
+        }
+
         // Handle beginning floating move
         if (cont && is_floating_or_child && !is_fullscreen_or_child &&
                         state == WLR_BUTTON_PRESSED) {
                 uint32_t btn_move = config->floating_mod_inverse ? BTN_RIGHT : BTN_LEFT;
                 if (button == btn_move && (mod_pressed || on_titlebar)) {
-                        seat_set_focus_container(seat,
-                                        seat_get_focus_inactive_view(seat, &cont->node));
                         seatop_begin_move_floating(seat, container_toplevel_ancestor(cont));
                         return;
                 }
@@ -436,6 +467,7 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
                         state == WLR_BUTTON_PRESSED) {
                 // Via border
                 if (button == BTN_LEFT && resize_edge != WLR_EDGE_NONE) {
+                        seat_set_focus_container(seat, cont);
                         seatop_begin_resize_floating(seat, cont, resize_edge);
                         return;
                 }
@@ -446,10 +478,11 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
                 if (mod_pressed && button == btn_resize) {
                         struct sway_container *floater = container_toplevel_ancestor(cont);
                         edge = 0;
-                        edge |= cursor->cursor->x > floater->x + floater->width / 2 ?
+                        edge |= cursor->cursor->x > floater->pending.x + floater->pending.width / 2 ?
                                 WLR_EDGE_RIGHT : WLR_EDGE_LEFT;
-                        edge |= cursor->cursor->y > floater->y + floater->height / 2 ?
+                        edge |= cursor->cursor->y > floater->pending.y + floater->pending.height / 2 ?
                                 WLR_EDGE_BOTTOM : WLR_EDGE_TOP;
+                        seat_set_focus_container(seat, floater);
                         seatop_begin_resize_floating(seat, floater, edge);
                         return;
                 }
@@ -458,52 +491,42 @@ static void handle_button(struct sway_seat *seat, uint32_t time_msec,
         // Handle moving a tiling container
         if (config->tiling_drag && (mod_pressed || on_titlebar) &&
                         state == WLR_BUTTON_PRESSED && !is_floating_or_child &&
-                        cont && cont->fullscreen_mode == FULLSCREEN_NONE) {
-                struct sway_container *focus = seat_get_focused_container(seat);
-                bool focused = focus == cont || container_has_ancestor(focus, cont);
-                if (on_titlebar && !focused) {
-                        node = seat_get_focus_inactive(seat, &cont->node);
-                        seat_set_focus(seat, node);
-                }
-
-                // If moving a container by it's title bar, use a threshold for the drag
+                        cont && cont->pending.fullscreen_mode == FULLSCREEN_NONE) {
+                // If moving a container by its title bar, use a threshold for the drag
                 if (!mod_pressed && config->tiling_drag_threshold > 0) {
                         seatop_begin_move_tiling_threshold(seat, cont);
                 } else {
                         seatop_begin_move_tiling(seat, cont);
                 }
+
                 return;
         }
 
         // Handle mousedown on a container surface
         if (surface && cont && state == WLR_BUTTON_PRESSED) {
-                seat_set_focus_container(seat, cont);
-                seatop_begin_down(seat, cont, time_msec, sx, sy);
+                seatop_begin_down(seat, cont, sx, sy);
                 seat_pointer_notify_button(seat, time_msec, button, WLR_BUTTON_PRESSED);
                 return;
         }
 
         // Handle clicking a container surface or decorations
         if (cont && state == WLR_BUTTON_PRESSED) {
-                node = seat_get_focus_inactive(seat, &cont->node);
-                seat_set_focus(seat, node);
                 seat_pointer_notify_button(seat, time_msec, button, state);
                 return;
         }
 
 #if HAVE_XWAYLAND
         // Handle clicking on xwayland unmanaged view
-        if (surface && wlr_surface_is_xwayland_surface(surface)) {
-                struct wlr_xwayland_surface *xsurface =
-                        wlr_xwayland_surface_from_wlr_surface(surface);
-                if (xsurface->override_redirect &&
-                                wlr_xwayland_or_surface_wants_focus(xsurface)) {
-                        struct wlr_xwayland *xwayland = server.xwayland.wlr_xwayland;
-                        wlr_xwayland_set_seat(xwayland, seat->wlr_seat);
-                        seat_set_focus_surface(seat, xsurface->surface, false);
-                        seat_pointer_notify_button(seat, time_msec, button, state);
-                        return;
-                }
+        struct wlr_xwayland_surface *xsurface;
+        if (surface &&
+                        (xsurface = wlr_xwayland_surface_try_from_wlr_surface(surface)) &&
+                        xsurface->override_redirect &&
+                        wlr_xwayland_or_surface_wants_focus(xsurface)) {
+                struct wlr_xwayland *xwayland = server.xwayland.wlr_xwayland;
+                wlr_xwayland_set_seat(xwayland, seat->wlr_seat);
+                seat_set_focus_surface(seat, xsurface->surface, false);
+                transaction_commit_dirty();
+                seat_pointer_notify_button(seat, time_msec, button, state);
         }
 #endif
 
@@ -526,10 +549,26 @@ static void check_focus_follows_mouse(struct sway_seat *seat,
                 if (wlr_output == NULL) {
                         return;
                 }
+
+                struct wlr_surface *surface = NULL;
+                double sx, sy;
+                node_at_coords(seat, seat->cursor->cursor->x, seat->cursor->cursor->y,
+                                &surface, &sx, &sy);
+
+                // Focus topmost layer surface
+                struct wlr_layer_surface_v1 *layer = NULL;
+                if ((layer = toplevel_layer_surface_from_surface(surface)) &&
+                                layer->current.keyboard_interactive) {
+                        seat_set_focus_layer(seat, layer);
+                        transaction_commit_dirty();
+                        return;
+                }
+
                 struct sway_output *hovered_output = wlr_output->data;
                 if (focus && hovered_output != node_get_output(focus)) {
                         struct sway_workspace *ws = output_get_active_workspace(hovered_output);
                         seat_set_focus(seat, &ws->node);
+                        transaction_commit_dirty();
                 }
                 return;
         }
@@ -541,6 +580,7 @@ static void check_focus_follows_mouse(struct sway_seat *seat,
                 struct sway_output *hovered_output = node_get_output(hovered_node);
                 if (hovered_output != focused_output) {
                         seat_set_focus(seat, seat_get_focus_inactive(seat, hovered_node));
+                        transaction_commit_dirty();
                 }
                 return;
         }
@@ -556,6 +596,7 @@ static void check_focus_follows_mouse(struct sway_seat *seat,
                 if (hovered_node != e->previous_node ||
                                 config->focus_follows_mouse == FOLLOWS_ALWAYS) {
                         seat_set_focus(seat, hovered_node);
+                        transaction_commit_dirty();
                 }
         }
 }
@@ -583,12 +624,7 @@ static void handle_pointer_motion(struct sway_seat *seat, uint32_t time_msec) {
                 wlr_seat_pointer_notify_clear_focus(seat->wlr_seat);
         }
 
-        struct sway_drag_icon *drag_icon;
-        wl_list_for_each(drag_icon, &root->drag_icons, link) {
-                if (drag_icon->seat == seat) {
-                        drag_icon_update_position(drag_icon);
-                }
-        }
+        drag_icons_update_position(seat);
 
         e->previous_node = node;
 }
@@ -618,21 +654,46 @@ static void handle_tablet_tool_motion(struct sway_seat *seat,
                 wlr_tablet_v2_tablet_tool_notify_proximity_out(tool->tablet_v2_tool);
         }
 
-        struct sway_drag_icon *drag_icon;
-        wl_list_for_each(drag_icon, &root->drag_icons, link) {
-                if (drag_icon->seat == seat) {
-                        drag_icon_update_position(drag_icon);
-                }
-        }
+        drag_icons_update_position(seat);
 
         e->previous_node = node;
 }
 
+static void handle_touch_down(struct sway_seat *seat,
+                struct wlr_touch_down_event *event, double lx, double ly) {
+        struct wlr_surface *surface = NULL;
+        struct wlr_seat *wlr_seat = seat->wlr_seat;
+        struct sway_cursor *cursor = seat->cursor;
+        double sx, sy;
+        node_at_coords(seat, seat->touch_x, seat->touch_y, &surface, &sx, &sy);
+
+        if (surface && wlr_surface_accepts_touch(wlr_seat, surface)) {
+                if (seat_is_input_allowed(seat, surface)) {
+                        cursor->simulating_pointer_from_touch = false;
+                        seatop_begin_touch_down(seat, surface, event, sx, sy, lx, ly);
+                }
+        } else if (!cursor->simulating_pointer_from_touch &&
+                        (!surface || seat_is_input_allowed(seat, surface))) {
+                // Fallback to cursor simulation.
+                // The pointer_touch_id state is needed, so drags are not aborted when over
+                // a surface supporting touch and multi touch events don't interfere.
+                cursor->simulating_pointer_from_touch = true;
+                cursor->pointer_touch_id = seat->touch_id;
+                double dx, dy;
+                dx = seat->touch_x - cursor->cursor->x;
+                dy = seat->touch_y - cursor->cursor->y;
+                pointer_motion(cursor, event->time_msec, &event->touch->base, dx, dy,
+                                dx, dy);
+                dispatch_cursor_button(cursor, &event->touch->base, event->time_msec,
+                                BTN_LEFT, WLR_BUTTON_PRESSED);
+        }
+}
+
 /*----------------------------------------\
  * Functions used by handle_pointer_axis  /
  *--------------------------------------*/
 
-static uint32_t wl_axis_to_button(struct wlr_event_pointer_axis *event) {
+static uint32_t wl_axis_to_button(struct wlr_pointer_axis_event *event) {
         switch (event->orientation) {
         case WLR_AXIS_ORIENTATION_VERTICAL:
                 return event->delta < 0 ? SWAY_SCROLL_UP : SWAY_SCROLL_DOWN;
@@ -645,9 +706,9 @@ static uint32_t wl_axis_to_button(struct wlr_event_pointer_axis *event) {
 }
 
 static void handle_pointer_axis(struct sway_seat *seat,
-                struct wlr_event_pointer_axis *event) {
+                struct wlr_pointer_axis_event *event) {
         struct sway_input_device *input_device =
-                event->device ? event->device->data : NULL;
+                event->pointer ? event->pointer->base.data : NULL;
         struct input_config *ic =
                 input_device ? input_device_get_config(input_device) : NULL;
         struct sway_cursor *cursor = seat->cursor;
@@ -664,7 +725,7 @@ static void handle_pointer_axis(struct sway_seat *seat,
         bool on_border = edge != WLR_EDGE_NONE;
         bool on_titlebar = cont && !on_border && !surface;
         bool on_titlebar_border = cont && on_border &&
-                cursor->cursor->y < cont->content_y;
+                cursor->cursor->y < cont->pending.content_y;
         bool on_contents = cont && !on_border && surface;
         bool on_workspace = node && node->type == N_WORKSPACE;
         float scroll_factor =
@@ -693,6 +754,7 @@ static void handle_pointer_axis(struct sway_seat *seat,
 
         // Scrolling on a tabbed or stacked title bar (handled as press event)
         if (!handled && (on_titlebar || on_titlebar_border)) {
+                struct sway_node *new_focus;
                 enum sway_container_layout layout = container_parent_layout(cont);
                 if (layout == L_TABBED || layout == L_STACKED) {
                         struct sway_node *tabcontainer = node_get_parent(node);
@@ -700,7 +762,7 @@ static void handle_pointer_axis(struct sway_seat *seat,
                                 seat_get_active_tiling_child(seat, tabcontainer);
                         list_t *siblings = container_get_siblings(cont);
                         int desired = list_find(siblings, active->sway_container) +
-                                round(scroll_factor * event->delta_discrete);
+                                roundf(scroll_factor * event->delta_discrete / WLR_POINTER_AXIS_DISCRETE_STEP);
                         if (desired < 0) {
                                 desired = 0;
                         } else if (desired >= siblings->length) {
@@ -709,13 +771,16 @@ static void handle_pointer_axis(struct sway_seat *seat,
 
                         struct sway_container *new_sibling_con = siblings->items[desired];
                         struct sway_node *new_sibling = &new_sibling_con->node;
-                        struct sway_node *new_focus =
-                                seat_get_focus_inactive(seat, new_sibling);
                         // Use the focused child of the tabbed/stacked container, not the
                         // container the user scrolled on.
-                        seat_set_focus(seat, new_focus);
-                        handled = true;
+                        new_focus = seat_get_focus_inactive(seat, new_sibling);
+                } else {
+                        new_focus = seat_get_focus_inactive(seat, &cont->node);
                 }
+
+                seat_set_focus(seat, new_focus);
+                transaction_commit_dirty();
+                handled = true;
         }
 
         // Handle mouse bindings - x11 mouse buttons 4-7 - release event
@@ -731,8 +796,307 @@ static void handle_pointer_axis(struct sway_seat *seat,
 
         if (!handled) {
                 wlr_seat_pointer_notify_axis(cursor->seat->wlr_seat, event->time_msec,
-                        event->orientation, scroll_factor * event->delta,
-                        round(scroll_factor * event->delta_discrete), event->source);
+                        event->orientation, scroll_factor * event->delta, 
+                        roundf(scroll_factor * event->delta_discrete), event->source,
+                        event->relative_direction);
+        }
+}
+
+/*------------------------------------\
+ * Functions used by gesture support  /
+ *----------------------------------*/
+
+/**
+ * Check gesture binding for a specific gesture type and finger count.
+ * Returns true if binding is present, false otherwise
+ */
+static bool gesture_binding_check(list_t *bindings, enum gesture_type type,
+                uint8_t fingers, struct sway_input_device *device) {
+        char *input =
+                device ? input_device_get_identifier(device->wlr_device) : strdup("*");
+
+        for (int i = 0; i < bindings->length; ++i) {
+                struct sway_gesture_binding *binding = bindings->items[i];
+
+                // Check type and finger count
+                if (!gesture_check(&binding->gesture, type, fingers)) {
+                        continue;
+                }
+
+                // Check that input matches
+                if (strcmp(binding->input, "*") != 0 &&
+                        strcmp(binding->input, input) != 0) {
+                        continue;
+                }
+
+                free(input);
+
+                return true;
+        }
+
+        free(input);
+
+        return false;
+}
+
+/**
+ * Return the gesture binding which matches gesture type, finger count
+ * and direction, otherwise return null.
+ */
+static struct sway_gesture_binding* gesture_binding_match(
+                list_t *bindings, struct gesture *gesture, const char *input) {
+        struct sway_gesture_binding *current = NULL;
+
+        // Find best matching binding
+        for (int i = 0; i < bindings->length; ++i) {
+                struct sway_gesture_binding *binding = bindings->items[i];
+                bool exact = binding->flags & BINDING_EXACT;
+
+                // Check gesture matching
+                if (!gesture_match(&binding->gesture, gesture, exact)) {
+                        continue;
+                }
+
+                // Check input matching
+                if (strcmp(binding->input, "*") != 0 &&
+                                strcmp(binding->input, input) != 0) {
+                        continue;
+                }
+
+                // If we already have a match ...
+                if (current) {
+                        // ... check if input matching is equivalent
+                        if (strcmp(current->input, binding->input) == 0) {
+
+                                // ... - do not override an exact binding
+                                if (!exact && current->flags & BINDING_EXACT) {
+                                        continue;
+                                }
+
+                                // ... - and ensure direction matching is better or equal
+                                if (gesture_compare(&current->gesture, &binding->gesture) > 0) {
+                                        continue;
+                                }
+                        } else if (strcmp(binding->input, "*") == 0) {
+                                // ... do not accept worse input match
+                                continue;
+                        }
+                }
+
+                // Accept newer or better match
+                current = binding;
+
+                // If exact binding and input is found, quit search
+                if (strcmp(current->input, input) == 0 &&
+                                gesture_compare(&current->gesture, gesture) == 0) {
+                        break;
+                }
+        } // for all gesture bindings
+
+        return current;
+}
+
+// Wrapper around gesture_tracker_end to use tracker with sway bindings
+static struct sway_gesture_binding* gesture_tracker_end_and_match(
+                struct gesture_tracker *tracker, struct sway_input_device* device) {
+        // Determine name of input that received gesture
+        char *input = device
+                ? input_device_get_identifier(device->wlr_device)
+                : strdup("*");
+
+        // Match tracking result to binding
+        struct gesture *gesture = gesture_tracker_end(tracker);
+        struct sway_gesture_binding *binding = gesture_binding_match(
+                        config->current_mode->gesture_bindings, gesture, input);
+        free(gesture);
+        free(input);
+
+        return binding;
+}
+
+// Small wrapper around seat_execute_command to work on gesture bindings
+static void gesture_binding_execute(struct sway_seat *seat,
+                struct sway_gesture_binding *binding) {
+        struct sway_binding *dummy_binding =
+                calloc(1, sizeof(struct sway_binding));
+        dummy_binding->type = BINDING_GESTURE;
+        dummy_binding->command = binding->command;
+
+        char *description = gesture_to_string(&binding->gesture);
+        sway_log(SWAY_DEBUG, "executing gesture binding: %s", description);
+        free(description);
+
+        seat_execute_command(seat, dummy_binding);
+
+        free(dummy_binding);
+}
+
+static void handle_hold_begin(struct sway_seat *seat,
+                struct wlr_pointer_hold_begin_event *event) {
+        // Start tracking gesture if there is a matching binding ...
+        struct sway_input_device *device =
+                event->pointer ? event->pointer->base.data : NULL;
+        list_t *bindings = config->current_mode->gesture_bindings;
+        if (gesture_binding_check(bindings, GESTURE_TYPE_HOLD, event->fingers, device)) {
+                struct seatop_default_event *seatop = seat->seatop_data;
+                gesture_tracker_begin(&seatop->gestures, GESTURE_TYPE_HOLD, event->fingers);
+        } else {
+                // ... otherwise forward to client
+                struct sway_cursor *cursor = seat->cursor;
+                wlr_pointer_gestures_v1_send_hold_begin(
+                        server.input->pointer_gestures, cursor->seat->wlr_seat,
+                        event->time_msec, event->fingers);
+        }
+}
+
+static void handle_hold_end(struct sway_seat *seat,
+                struct wlr_pointer_hold_end_event *event) {
+        // Ensure that gesture is being tracked and was not cancelled
+        struct seatop_default_event *seatop = seat->seatop_data;
+        if (!gesture_tracker_check(&seatop->gestures, GESTURE_TYPE_HOLD)) {
+                struct sway_cursor *cursor = seat->cursor;
+                wlr_pointer_gestures_v1_send_hold_end(
+                        server.input->pointer_gestures, cursor->seat->wlr_seat,
+                        event->time_msec, event->cancelled);
+                return;
+        }
+        if (event->cancelled) {
+                gesture_tracker_cancel(&seatop->gestures);
+                return;
+        }
+
+        // End gesture tracking and execute matched binding
+        struct sway_input_device *device =
+                event->pointer ? event->pointer->base.data : NULL;
+        struct sway_gesture_binding *binding = gesture_tracker_end_and_match(
+                &seatop->gestures, device);
+
+        if (binding) {
+                gesture_binding_execute(seat, binding);
+        }
+}
+
+static void handle_pinch_begin(struct sway_seat *seat,
+                struct wlr_pointer_pinch_begin_event *event) {
+        // Start tracking gesture if there is a matching binding ...
+        struct sway_input_device *device =
+                event->pointer ? event->pointer->base.data : NULL;
+        list_t *bindings = config->current_mode->gesture_bindings;
+        if (gesture_binding_check(bindings, GESTURE_TYPE_PINCH, event->fingers, device)) {
+                struct seatop_default_event *seatop = seat->seatop_data;
+                gesture_tracker_begin(&seatop->gestures, GESTURE_TYPE_PINCH, event->fingers);
+        } else {
+                // ... otherwise forward to client
+                struct sway_cursor *cursor = seat->cursor;
+                wlr_pointer_gestures_v1_send_pinch_begin(
+                        server.input->pointer_gestures, cursor->seat->wlr_seat,
+                        event->time_msec, event->fingers);
+        }
+}
+
+static void handle_pinch_update(struct sway_seat *seat,
+                struct wlr_pointer_pinch_update_event *event) {
+        // Update any ongoing tracking ...
+        struct seatop_default_event *seatop = seat->seatop_data;
+        if (gesture_tracker_check(&seatop->gestures, GESTURE_TYPE_PINCH)) {
+                gesture_tracker_update(&seatop->gestures, event->dx, event->dy,
+                        event->scale, event->rotation);
+        } else {
+                // ... otherwise forward to client
+                struct sway_cursor *cursor = seat->cursor;
+                wlr_pointer_gestures_v1_send_pinch_update(
+                        server.input->pointer_gestures,
+                        cursor->seat->wlr_seat,
+                        event->time_msec, event->dx, event->dy,
+                        event->scale, event->rotation);
+        }
+}
+
+static void handle_pinch_end(struct sway_seat *seat,
+                struct wlr_pointer_pinch_end_event *event) {
+        // Ensure that gesture is being tracked and was not cancelled
+        struct seatop_default_event *seatop = seat->seatop_data;
+        if (!gesture_tracker_check(&seatop->gestures, GESTURE_TYPE_PINCH)) {
+                struct sway_cursor *cursor = seat->cursor;
+                wlr_pointer_gestures_v1_send_pinch_end(
+                        server.input->pointer_gestures, cursor->seat->wlr_seat,
+                        event->time_msec, event->cancelled);
+                return;
+        }
+        if (event->cancelled) {
+                gesture_tracker_cancel(&seatop->gestures);
+                return;
+        }
+
+        // End gesture tracking and execute matched binding
+        struct sway_input_device *device =
+                event->pointer ? event->pointer->base.data : NULL;
+        struct sway_gesture_binding *binding = gesture_tracker_end_and_match(
+                &seatop->gestures, device);
+
+        if (binding) {
+                gesture_binding_execute(seat, binding);
+        }
+}
+
+static void handle_swipe_begin(struct sway_seat *seat,
+                struct wlr_pointer_swipe_begin_event *event) {
+        // Start tracking gesture if there is a matching binding ...
+        struct sway_input_device *device =
+                event->pointer ? event->pointer->base.data : NULL;
+        list_t *bindings = config->current_mode->gesture_bindings;
+        if (gesture_binding_check(bindings, GESTURE_TYPE_SWIPE, event->fingers, device)) {
+                struct seatop_default_event *seatop = seat->seatop_data;
+                gesture_tracker_begin(&seatop->gestures, GESTURE_TYPE_SWIPE, event->fingers);
+        } else {
+                // ... otherwise forward to client
+                struct sway_cursor *cursor = seat->cursor;
+                wlr_pointer_gestures_v1_send_swipe_begin(
+                        server.input->pointer_gestures, cursor->seat->wlr_seat,
+                        event->time_msec, event->fingers);
+        }
+}
+
+static void handle_swipe_update(struct sway_seat *seat,
+                struct wlr_pointer_swipe_update_event *event) {
+
+        // Update any ongoing tracking ...
+        struct seatop_default_event *seatop = seat->seatop_data;
+        if (gesture_tracker_check(&seatop->gestures, GESTURE_TYPE_SWIPE)) {
+                gesture_tracker_update(&seatop->gestures,
+                        event->dx, event->dy, NAN, NAN);
+        } else {
+                // ... otherwise forward to client
+                struct sway_cursor *cursor = seat->cursor;
+                wlr_pointer_gestures_v1_send_swipe_update(
+                        server.input->pointer_gestures, cursor->seat->wlr_seat,
+                        event->time_msec, event->dx, event->dy);
+        }
+}
+
+static void handle_swipe_end(struct sway_seat *seat,
+                struct wlr_pointer_swipe_end_event *event) {
+        // Ensure gesture is being tracked and was not cancelled
+        struct seatop_default_event *seatop = seat->seatop_data;
+        if (!gesture_tracker_check(&seatop->gestures, GESTURE_TYPE_SWIPE)) {
+                struct sway_cursor *cursor = seat->cursor;
+                wlr_pointer_gestures_v1_send_swipe_end(server.input->pointer_gestures,
+                        cursor->seat->wlr_seat, event->time_msec, event->cancelled);
+                return;
+        }
+        if (event->cancelled) {
+                gesture_tracker_cancel(&seatop->gestures);
+                return;
+        }
+
+        // End gesture tracking and execute matched binding
+        struct sway_input_device *device =
+                event->pointer ? event->pointer->base.data : NULL;
+        struct sway_gesture_binding *binding = gesture_tracker_end_and_match(
+                &seatop->gestures, device);
+
+        if (binding) {
+                gesture_binding_execute(seat, binding);
         }
 }
 
@@ -765,6 +1129,15 @@ static const struct sway_seatop_impl seatop_impl = {
         .pointer_axis = handle_pointer_axis,
         .tablet_tool_tip = handle_tablet_tool_tip,
         .tablet_tool_motion = handle_tablet_tool_motion,
+        .hold_begin = handle_hold_begin,
+        .hold_end = handle_hold_end,
+        .pinch_begin = handle_pinch_begin,
+        .pinch_update = handle_pinch_update,
+        .pinch_end = handle_pinch_end,
+        .swipe_begin = handle_swipe_begin,
+        .swipe_update = handle_swipe_update,
+        .swipe_end = handle_swipe_end,
+        .touch_down = handle_touch_down,
         .rebase = handle_rebase,
         .allow_set_cursor = true,
 };
@@ -775,8 +1148,8 @@ void seatop_begin_default(struct sway_seat *seat) {
         struct seatop_default_event *e =
                 calloc(1, sizeof(struct seatop_default_event));
         sway_assert(e, "Unable to allocate seatop_default_event");
+
         seat->seatop_impl = &seatop_impl;
         seat->seatop_data = e;
-
         seatop_rebase(seat, 0);
 }