1 files changed, 273 insertions, 172 deletions

diff --git a/sway/input/seat.c b/sway/input/seat.c
index 2d714acd..0c5672bc 100644
--- a/sway/input/seat.c
+++ b/sway/input/seat.c
@@ -1,22 +1,23 @@
-#define _POSIX_C_SOURCE 200809L
 #include <assert.h>
 #include <linux/input-event-codes.h>
 #include <string.h>
 #include <strings.h>
 #include <time.h>
+#include <wlr/config.h>
 #include <wlr/types/wlr_cursor.h>
 #include <wlr/types/wlr_data_device.h>
-#include <wlr/types/wlr_idle.h>
+#include <wlr/types/wlr_idle_notify_v1.h>
 #include <wlr/types/wlr_keyboard_group.h>
 #include <wlr/types/wlr_output_layout.h>
 #include <wlr/types/wlr_primary_selection.h>
 #include <wlr/types/wlr_tablet_v2.h>
+#include <wlr/types/wlr_touch.h>
 #include <wlr/types/wlr_xcursor_manager.h>
 #include "config.h"
 #include "list.h"
 #include "log.h"
 #include "sway/config.h"
-#include "sway/desktop.h"
+#include "sway/scene_descriptor.h"
 #include "sway/input/cursor.h"
 #include "sway/input/input-manager.h"
 #include "sway/input/keyboard.h"
@@ -42,6 +43,7 @@ static void seat_device_destroy(struct sway_seat_device *seat_device) {
         sway_keyboard_destroy(seat_device->keyboard);
         sway_tablet_destroy(seat_device->tablet);
         sway_tablet_pad_destroy(seat_device->tablet_pad);
+        sway_switch_destroy(seat_device->switch_device);
         wlr_cursor_detach_input_device(seat_device->sway_seat->cursor->cursor,
                 seat_device->input_device->wlr_device);
         wl_list_remove(&seat_device->link);
@@ -51,10 +53,26 @@ static void seat_device_destroy(struct sway_seat_device *seat_device) {
 static void seat_node_destroy(struct sway_seat_node *seat_node) {
         wl_list_remove(&seat_node->destroy.link);
         wl_list_remove(&seat_node->link);
+
+        /*
+         * This is the only time we remove items from the focus stack without
+         * immediately re-adding them. If we just removed the last thing,
+         * mark that nothing has focus anymore.
+         */
+        if (wl_list_empty(&seat_node->seat->focus_stack)) {
+                seat_node->seat->has_focus = false;
+        }
+
         free(seat_node);
 }
 
 void seat_destroy(struct sway_seat *seat) {
+        wlr_seat_destroy(seat->wlr_seat);
+}
+
+static void handle_seat_destroy(struct wl_listener *listener, void *data) {
+        struct sway_seat *seat = wl_container_of(listener, seat, destroy);
+
         if (seat == config->handler_context.seat) {
                 config->handler_context.seat = input_manager_get_default_seat();
         }
@@ -75,10 +93,11 @@ void seat_destroy(struct sway_seat *seat) {
         wl_list_remove(&seat->request_set_selection.link);
         wl_list_remove(&seat->request_set_primary_selection.link);
         wl_list_remove(&seat->link);
-        wlr_seat_destroy(seat->wlr_seat);
+        wl_list_remove(&seat->destroy.link);
         for (int i = 0; i < seat->deferred_bindings->length; i++) {
                 free_sway_binding(seat->deferred_bindings->items[i]);
         }
+        wlr_scene_node_destroy(&seat->scene_tree->node);
         list_free(seat->deferred_bindings);
         free(seat->prev_workspace_name);
         free(seat);
@@ -86,21 +105,10 @@ void seat_destroy(struct sway_seat *seat) {
 
 void seat_idle_notify_activity(struct sway_seat *seat,
                 enum sway_input_idle_source source) {
-        uint32_t mask = seat->idle_inhibit_sources;
-        struct wlr_idle_timeout *timeout;
-        int ntimers = 0, nidle = 0;
-        wl_list_for_each(timeout, &server.idle->idle_timers, link) {
-                ++ntimers;
-                if (timeout->idle_state) {
-                        ++nidle;
-                }
-        }
-        if (nidle == ntimers) {
-                mask = seat->idle_wake_sources;
-        }
-        if ((source & mask) > 0) {
-                wlr_idle_notify_activity(server.idle, seat->wlr_seat);
+        if ((source & seat->idle_inhibit_sources) == 0) {
+                return;
         }
+        wlr_idle_notifier_v1_notify_activity(server.idle_notifier_v1, seat->wlr_seat);
 }
 
 /**
@@ -130,7 +138,7 @@ static struct sway_keyboard *sway_keyboard_for_wlr_keyboard(
                 if (input_device->wlr_device->type != WLR_INPUT_DEVICE_KEYBOARD) {
                         continue;
                 }
-                if (input_device->wlr_device->keyboard == wlr_keyboard) {
+                if (input_device->wlr_device == &wlr_keyboard->base) {
                         return seat_device->keyboard;
                 }
         }
@@ -138,7 +146,7 @@ static struct sway_keyboard *sway_keyboard_for_wlr_keyboard(
         wl_list_for_each(group, &seat->keyboard_groups, link) {
                 struct sway_input_device *input_device =
                         group->seat_device->input_device;
-                if (input_device->wlr_device->keyboard == wlr_keyboard) {
+                if (input_device->wlr_device == &wlr_keyboard->base) {
                         return group->seat_device->keyboard;
                 }
         }
@@ -162,11 +170,11 @@ static void seat_keyboard_notify_enter(struct sway_seat *seat,
                         state->pressed_keycodes, state->npressed, &keyboard->modifiers);
 }
 
-static void seat_tablet_pads_notify_enter(struct sway_seat *seat,
+static void seat_tablet_pads_set_focus(struct sway_seat *seat,
                 struct wlr_surface *surface) {
         struct sway_seat_device *seat_device;
         wl_list_for_each(seat_device, &seat->devices, link) {
-                sway_tablet_pad_notify_enter(seat_device->tablet_pad, surface);
+                sway_tablet_pad_set_focus(seat_device->tablet_pad, surface);
         }
 }
 
@@ -190,7 +198,7 @@ static void seat_send_focus(struct sway_node *node, struct sway_seat *seat) {
 #endif
 
                 seat_keyboard_notify_enter(seat, view->surface);
-                seat_tablet_pads_notify_enter(seat, view->surface);
+                seat_tablet_pads_set_focus(seat, view->surface);
                 sway_input_method_relay_set_focus(&seat->im_relay, view->surface);
 
                 struct wlr_pointer_constraint_v1 *constraint =
@@ -210,14 +218,13 @@ void seat_for_each_node(struct sway_seat *seat,
 
 struct sway_container *seat_get_focus_inactive_view(struct sway_seat *seat,
                 struct sway_node *ancestor) {
-        if (ancestor->type == N_CONTAINER && ancestor->sway_container->view) {
+        if (node_is_view(ancestor)) {
                 return ancestor->sway_container;
         }
         struct sway_seat_node *current;
         wl_list_for_each(current, &seat->focus_stack, link) {
                 struct sway_node *node = current->node;
-                if (node->type == N_CONTAINER && node->sway_container->view &&
-                                node_has_ancestor(node, ancestor)) {
+                if (node_is_view(node) && node_has_ancestor(node, ancestor)) {
                         return node->sway_container;
                 }
         }
@@ -236,7 +243,7 @@ static void handle_seat_node_destroy(struct wl_listener *listener, void *data) {
                 seat_node_destroy(seat_node);
                 // If an unmanaged or layer surface is focused when an output gets
                 // disabled and an empty workspace on the output was focused by the
-                // seat, the seat needs to refocus it's focus inactive to update the
+                // seat, the seat needs to refocus its focus inactive to update the
                 // value of seat->workspace.
                 if (seat->workspace == node->sway_workspace) {
                         struct sway_node *node = seat_get_focus_inactive(seat, &root->node);
@@ -352,25 +359,15 @@ static void handle_new_node(struct wl_listener *listener, void *data) {
         seat_node_from_node(seat, node);
 }
 
-static void drag_icon_damage_whole(struct sway_drag_icon *icon) {
-        if (!icon->wlr_drag_icon->mapped) {
-                return;
-        }
-        desktop_damage_surface(icon->wlr_drag_icon->surface, icon->x, icon->y, true);
-}
-
-void drag_icon_update_position(struct sway_drag_icon *icon) {
-        drag_icon_damage_whole(icon);
-
-        struct wlr_drag_icon *wlr_icon = icon->wlr_drag_icon;
-        struct sway_seat *seat = icon->seat;
+static void drag_icon_update_position(struct sway_seat *seat, struct wlr_scene_node *node) {
+        struct wlr_drag_icon *wlr_icon = scene_descriptor_try_get(node, SWAY_SCENE_DESC_DRAG_ICON);
         struct wlr_cursor *cursor = seat->cursor->cursor;
+
         switch (wlr_icon->drag->grab_type) {
         case WLR_DRAG_GRAB_KEYBOARD:
                 return;
         case WLR_DRAG_GRAB_KEYBOARD_POINTER:
-                icon->x = cursor->x;
-                icon->y = cursor->y;
+                wlr_scene_node_set_position(node, cursor->x, cursor->y);
                 break;
         case WLR_DRAG_GRAB_KEYBOARD_TOUCH:;
                 struct wlr_touch_point *point =
@@ -378,39 +375,15 @@ void drag_icon_update_position(struct sway_drag_icon *icon) {
                 if (point == NULL) {
                         return;
                 }
-                icon->x = seat->touch_x;
-                icon->y = seat->touch_y;
+                wlr_scene_node_set_position(node, seat->touch_x, seat->touch_y);
         }
-
-        drag_icon_damage_whole(icon);
 }
 
-static void drag_icon_handle_surface_commit(struct wl_listener *listener,
-                void *data) {
-        struct sway_drag_icon *icon =
-                wl_container_of(listener, icon, surface_commit);
-        drag_icon_update_position(icon);
-}
-
-static void drag_icon_handle_map(struct wl_listener *listener, void *data) {
-        struct sway_drag_icon *icon = wl_container_of(listener, icon, map);
-        drag_icon_damage_whole(icon);
-}
-
-static void drag_icon_handle_unmap(struct wl_listener *listener, void *data) {
-        struct sway_drag_icon *icon = wl_container_of(listener, icon, unmap);
-        drag_icon_damage_whole(icon);
-}
-
-static void drag_icon_handle_destroy(struct wl_listener *listener, void *data) {
-        struct sway_drag_icon *icon = wl_container_of(listener, icon, destroy);
-        icon->wlr_drag_icon->data = NULL;
-        wl_list_remove(&icon->link);
-        wl_list_remove(&icon->surface_commit.link);
-        wl_list_remove(&icon->unmap.link);
-        wl_list_remove(&icon->map.link);
-        wl_list_remove(&icon->destroy.link);
-        free(icon);
+void drag_icons_update_position(struct sway_seat *seat) {
+        struct wlr_scene_node *node;
+        wl_list_for_each(node, &seat->drag_icons->children, link) {
+                drag_icon_update_position(seat, node);
+        }
 }
 
 static void drag_handle_destroy(struct wl_listener *listener, void *data) {
@@ -482,27 +455,20 @@ static void handle_start_drag(struct wl_listener *listener, void *data) {
 
         struct wlr_drag_icon *wlr_drag_icon = wlr_drag->icon;
         if (wlr_drag_icon != NULL) {
-                struct sway_drag_icon *icon = calloc(1, sizeof(struct sway_drag_icon));
-                if (icon == NULL) {
-                        sway_log(SWAY_ERROR, "Allocation failed");
+                struct wlr_scene_tree *tree = wlr_scene_drag_icon_create(seat->drag_icons, wlr_drag_icon);
+                if (!tree) {
+                        sway_log(SWAY_ERROR, "Failed to allocate a drag icon scene tree");
                         return;
                 }
-                icon->seat = seat;
-                icon->wlr_drag_icon = wlr_drag_icon;
-                wlr_drag_icon->data = icon;
 
-                icon->surface_commit.notify = drag_icon_handle_surface_commit;
-                wl_signal_add(&wlr_drag_icon->surface->events.commit, &icon->surface_commit);
-                icon->unmap.notify = drag_icon_handle_unmap;
-                wl_signal_add(&wlr_drag_icon->events.unmap, &icon->unmap);
-                icon->map.notify = drag_icon_handle_map;
-                wl_signal_add(&wlr_drag_icon->events.map, &icon->map);
-                icon->destroy.notify = drag_icon_handle_destroy;
-                wl_signal_add(&wlr_drag_icon->events.destroy, &icon->destroy);
-
-                wl_list_insert(&root->drag_icons, &icon->link);
+                if (!scene_descriptor_assign(&tree->node, SWAY_SCENE_DESC_DRAG_ICON,
+                                wlr_drag_icon)) {
+                        sway_log(SWAY_ERROR, "Failed to allocate a drag icon scene descriptor");
+                        wlr_scene_node_destroy(&tree->node);
+                        return;
+                }
 
-                drag_icon_update_position(icon);
+                drag_icon_update_position(seat, &tree->node);
         }
         seatop_begin_default(seat);
 }
@@ -549,8 +515,18 @@ struct sway_seat *seat_create(const char *seat_name) {
                 return NULL;
         }
 
+        bool failed = false;
+        seat->scene_tree = alloc_scene_tree(root->layers.seat, &failed);
+        seat->drag_icons = alloc_scene_tree(seat->scene_tree, &failed);
+        if (failed) {
+                wlr_scene_node_destroy(&seat->scene_tree->node);
+                free(seat);
+                return NULL;
+        }
+
         seat->wlr_seat = wlr_seat_create(server.wl_display, seat_name);
         if (!sway_assert(seat->wlr_seat, "could not allocate seat")) {
+                wlr_scene_node_destroy(&seat->scene_tree->node);
                 free(seat);
                 return NULL;
         }
@@ -558,11 +534,15 @@ struct sway_seat *seat_create(const char *seat_name) {
 
         seat->cursor = sway_cursor_create(seat);
         if (!seat->cursor) {
+                wlr_scene_node_destroy(&seat->scene_tree->node);
                 wlr_seat_destroy(seat->wlr_seat);
                 free(seat);
                 return NULL;
         }
 
+        seat->destroy.notify = handle_seat_destroy;
+        wl_signal_add(&seat->wlr_seat->events.destroy, &seat->destroy);
+
         seat->idle_inhibit_sources = seat->idle_wake_sources =
                 IDLE_SOURCE_KEYBOARD |
                 IDLE_SOURCE_POINTER |
@@ -636,7 +616,7 @@ static void seat_update_capabilities(struct sway_seat *seat) {
                 case WLR_INPUT_DEVICE_TOUCH:
                         caps |= WL_SEAT_CAPABILITY_TOUCH;
                         break;
-                case WLR_INPUT_DEVICE_TABLET_TOOL:
+                case WLR_INPUT_DEVICE_TABLET:
                         caps |= WL_SEAT_CAPABILITY_POINTER;
                         break;
                 case WLR_INPUT_DEVICE_SWITCH:
@@ -654,7 +634,7 @@ static void seat_update_capabilities(struct sway_seat *seat) {
         } else {
                 wlr_seat_set_capabilities(seat->wlr_seat, caps);
                 if ((previous_caps & WL_SEAT_CAPABILITY_POINTER) == 0) {
-                        cursor_set_image(seat->cursor, "left_ptr", NULL);
+                        cursor_set_image(seat->cursor, "default", NULL);
                 }
         }
 }
@@ -694,19 +674,28 @@ static const char *get_builtin_output_name(void) {
 static bool is_touch_or_tablet_tool(struct sway_seat_device *seat_device) {
         switch (seat_device->input_device->wlr_device->type) {
         case WLR_INPUT_DEVICE_TOUCH:
-        case WLR_INPUT_DEVICE_TABLET_TOOL:
+        case WLR_INPUT_DEVICE_TABLET:
                 return true;
         default:
                 return false;
         }
 }
 
-static void seat_apply_input_config(struct sway_seat *seat,
+static void seat_apply_input_mapping(struct sway_seat *seat,
                 struct sway_seat_device *sway_device) {
         struct input_config *ic =
                 input_device_get_config(sway_device->input_device);
 
-        sway_log(SWAY_DEBUG, "Applying input config to %s",
+        switch (sway_device->input_device->wlr_device->type) {
+        case WLR_INPUT_DEVICE_POINTER:
+        case WLR_INPUT_DEVICE_TOUCH:
+        case WLR_INPUT_DEVICE_TABLET:
+                break;
+        default:
+                return; // these devices don't support mappings
+        }
+
+        sway_log(SWAY_DEBUG, "Applying input mapping to %s",
                 sway_device->input_device->identifier);
 
         const char *mapped_to_output = ic == NULL ? NULL : ic->mapped_to_output;
@@ -715,14 +704,26 @@ static void seat_apply_input_config(struct sway_seat *seat,
                 ic == NULL ? MAPPED_TO_DEFAULT : ic->mapped_to;
 
         switch (mapped_to) {
-        case MAPPED_TO_DEFAULT:
+        case MAPPED_TO_DEFAULT:;
                 /*
                  * If the wlroots backend provides an output name, use that.
                  *
-                 * Otherwise, try to map built-in touch and tablet tool devices to the
+                 * Otherwise, try to map built-in touch and pointer devices to the
                  * built-in output.
                  */
-                mapped_to_output = sway_device->input_device->wlr_device->output_name;
+                struct wlr_input_device *dev = sway_device->input_device->wlr_device;
+                switch (dev->type) {
+                case WLR_INPUT_DEVICE_POINTER:
+                        mapped_to_output = wlr_pointer_from_input_device(dev)->output_name;
+                        break;
+                case WLR_INPUT_DEVICE_TOUCH:
+                        mapped_to_output = wlr_touch_from_input_device(dev)->output_name;
+                        break;
+                default:
+                        mapped_to_output = NULL;
+                        break;
+                }
+#if WLR_HAS_LIBINPUT_BACKEND
                 if (mapped_to_output == NULL && is_touch_or_tablet_tool(sway_device) &&
                                 sway_libinput_device_is_builtin(sway_device->input_device)) {
                         mapped_to_output = get_builtin_output_name();
@@ -731,6 +732,10 @@ static void seat_apply_input_config(struct sway_seat *seat,
                                         mapped_to_output, sway_device->input_device->identifier);
                         }
                 }
+#else
+                (void)is_touch_or_tablet_tool;
+                (void)get_builtin_output_name;
+#endif
                 if (mapped_to_output == NULL) {
                         return;
                 }
@@ -774,12 +779,9 @@ static void seat_apply_input_config(struct sway_seat *seat,
 
 static void seat_configure_pointer(struct sway_seat *seat,
                 struct sway_seat_device *sway_device) {
-        if ((seat->wlr_seat->capabilities & WL_SEAT_CAPABILITY_POINTER) == 0) {
-                seat_configure_xcursor(seat);
-        }
+        seat_configure_xcursor(seat);
         wlr_cursor_attach_input_device(seat->cursor->cursor,
                 sway_device->input_device->wlr_device);
-        seat_apply_input_config(seat, sway_device);
         wl_event_source_timer_update(
                         seat->cursor->hide_source, cursor_get_timeout(seat->cursor));
 }
@@ -790,13 +792,22 @@ static void seat_configure_keyboard(struct sway_seat *seat,
                 sway_keyboard_create(seat, seat_device);
         }
         sway_keyboard_configure(seat_device->keyboard);
-        wlr_seat_set_keyboard(seat->wlr_seat,
-                        seat_device->input_device->wlr_device);
-        struct sway_node *focus = seat_get_focus(seat);
-        if (focus && node_is_view(focus)) {
-                // force notify reenter to pick up the new configuration
+
+        // We only need to update the current keyboard, as the rest will be updated
+        // as they are activated.
+        struct wlr_keyboard *wlr_keyboard =
+                wlr_keyboard_from_input_device(seat_device->input_device->wlr_device);
+        struct wlr_keyboard *current_keyboard = seat->wlr_seat->keyboard_state.keyboard;
+        if (wlr_keyboard != current_keyboard) {
+                return;
+        }
+
+        // force notify reenter to pick up the new configuration.  This reuses
+        // the current focused surface to avoid breaking input grabs.
+        struct wlr_surface *surface = seat->wlr_seat->keyboard_state.focused_surface;
+        if (surface) {
                 wlr_seat_keyboard_notify_clear_focus(seat->wlr_seat);
-                seat_keyboard_notify_enter(seat, focus->sway_container->view->surface);
+                seat_keyboard_notify_enter(seat, surface);
         }
 }
 
@@ -805,7 +816,6 @@ static void seat_configure_switch(struct sway_seat *seat,
         if (!seat_device->switch_device) {
                 sway_switch_create(seat, seat_device);
         }
-        seat_apply_input_config(seat, seat_device);
         sway_switch_configure(seat_device->switch_device);
 }
 
@@ -813,7 +823,6 @@ static void seat_configure_touch(struct sway_seat *seat,
                 struct sway_seat_device *sway_device) {
         wlr_cursor_attach_input_device(seat->cursor->cursor,
                 sway_device->input_device->wlr_device);
-        seat_apply_input_config(seat, sway_device);
 }
 
 static void seat_configure_tablet_tool(struct sway_seat *seat,
@@ -824,7 +833,6 @@ static void seat_configure_tablet_tool(struct sway_seat *seat,
         sway_configure_tablet(sway_device->tablet);
         wlr_cursor_attach_input_device(seat->cursor->cursor,
                 sway_device->input_device->wlr_device);
-        seat_apply_input_config(seat, sway_device);
 }
 
 static void seat_configure_tablet_pad(struct sway_seat *seat,
@@ -874,13 +882,25 @@ void seat_configure_device(struct sway_seat *seat,
                 case WLR_INPUT_DEVICE_TOUCH:
                         seat_configure_touch(seat, seat_device);
                         break;
-                case WLR_INPUT_DEVICE_TABLET_TOOL:
+                case WLR_INPUT_DEVICE_TABLET:
                         seat_configure_tablet_tool(seat, seat_device);
                         break;
                 case WLR_INPUT_DEVICE_TABLET_PAD:
                         seat_configure_tablet_pad(seat, seat_device);
                         break;
         }
+
+        seat_apply_input_mapping(seat, seat_device);
+}
+
+void seat_configure_device_mapping(struct sway_seat *seat,
+                struct sway_input_device *input_device) {
+        struct sway_seat_device *seat_device = seat_get_device(seat, input_device);
+        if (!seat_device) {
+                return;
+        }
+
+        seat_apply_input_mapping(seat, seat_device);
 }
 
 void seat_reset_device(struct sway_seat *seat,
@@ -901,7 +921,7 @@ void seat_reset_device(struct sway_seat *seat,
                 case WLR_INPUT_DEVICE_TOUCH:
                         seat_reset_input_config(seat, seat_device);
                         break;
-                case WLR_INPUT_DEVICE_TABLET_TOOL:
+                case WLR_INPUT_DEVICE_TABLET:
                         seat_reset_input_config(seat, seat_device);
                         break;
                 case WLR_INPUT_DEVICE_TABLET_PAD:
@@ -997,7 +1017,7 @@ void seat_configure_xcursor(struct sway_seat *seat) {
 
                         wlr_xcursor_manager_load(server.xwayland.xcursor_manager, 1);
                         struct wlr_xcursor *xcursor = wlr_xcursor_manager_get_xcursor(
-                                server.xwayland.xcursor_manager, "left_ptr", 1);
+                                server.xwayland.xcursor_manager, "default", 1);
                         if (xcursor != NULL) {
                                 struct wlr_xcursor_image *image = xcursor->images[0];
                                 wlr_xwayland_set_cursor(
@@ -1023,32 +1043,35 @@ void seat_configure_xcursor(struct sway_seat *seat) {
                         sway_log(SWAY_ERROR,
                                 "Cannot create XCursor manager for theme '%s'", cursor_theme);
                 }
-        }
 
-        for (int i = 0; i < root->outputs->length; ++i) {
-                struct sway_output *sway_output = root->outputs->items[i];
-                struct wlr_output *output = sway_output->wlr_output;
-                bool result =
-                        wlr_xcursor_manager_load(seat->cursor->xcursor_manager,
-                                output->scale);
-                if (!result) {
-                        sway_log(SWAY_ERROR,
-                                "Cannot load xcursor theme for output '%s' with scale %f",
-                                output->name, output->scale);
+
+                for (int i = 0; i < root->outputs->length; ++i) {
+                        struct sway_output *sway_output = root->outputs->items[i];
+                        struct wlr_output *output = sway_output->wlr_output;
+                        bool result =
+                                wlr_xcursor_manager_load(seat->cursor->xcursor_manager,
+                                        output->scale);
+                        if (!result) {
+                                sway_log(SWAY_ERROR,
+                                        "Cannot load xcursor theme for output '%s' with scale %f",
+                                        output->name, output->scale);
+                        }
                 }
-        }
 
-        // Reset the cursor so that we apply it to outputs that just appeared
-        cursor_set_image(seat->cursor, NULL, NULL);
-        cursor_set_image(seat->cursor, "left_ptr", NULL);
-        wlr_cursor_warp(seat->cursor->cursor, NULL, seat->cursor->cursor->x,
-                seat->cursor->cursor->y);
+                // Reset the cursor so that we apply it to outputs that just appeared
+                cursor_set_image(seat->cursor, NULL, NULL);
+                cursor_set_image(seat->cursor, "default", NULL);
+                wlr_cursor_warp(seat->cursor->cursor, NULL, seat->cursor->cursor->x,
+                        seat->cursor->cursor->y);
+        }
 }
 
 bool seat_is_input_allowed(struct sway_seat *seat,
                 struct wlr_surface *surface) {
-        struct wl_client *client = wl_resource_get_client(surface->resource);
-        return !seat->exclusive_client || seat->exclusive_client == client;
+        if (server.session_lock.lock) {
+                return sway_session_lock_has_surface(server.session_lock.lock, surface);
+        }
+        return true;
 }
 
 static void send_unfocus(struct sway_container *con, void *data) {
@@ -1107,15 +1130,7 @@ void seat_set_raw_focus(struct sway_seat *seat, struct sway_node *node) {
         }
 }
 
-void seat_set_focus(struct sway_seat *seat, struct sway_node *node) {
-        if (seat->focused_layer) {
-                struct wlr_layer_surface_v1 *layer = seat->focused_layer;
-                seat_set_focus_layer(seat, NULL);
-                seat_set_focus(seat, node);
-                seat_set_focus_layer(seat, layer);
-                return;
-        }
-
+static void seat_set_workspace_focus(struct sway_seat *seat, struct sway_node *node) {
         struct sway_node *last_focus = seat_get_focus(seat);
         if (last_focus == node) {
                 return;
@@ -1248,6 +1263,24 @@ void seat_set_focus(struct sway_seat *seat, struct sway_node *node) {
         }
 }
 
+void seat_set_focus(struct sway_seat *seat, struct sway_node *node) {
+        // Prevents the layer from losing focus if it has keyboard exclusivity
+        if (seat->has_exclusive_layer) {
+                struct wlr_layer_surface_v1 *layer = seat->focused_layer;
+                seat_set_focus_layer(seat, NULL);
+                seat_set_workspace_focus(seat, node);
+                seat_set_focus_layer(seat, layer);
+        } else if (seat->focused_layer) {
+                seat_set_focus_layer(seat, NULL);
+                seat_set_workspace_focus(seat, node);
+        } else {
+                seat_set_workspace_focus(seat, node);
+        }
+        if (server.session_lock.lock) {
+                seat_set_focus_surface(seat, server.session_lock.lock->focused, false);
+        }
+}
+
 void seat_set_focus_container(struct sway_seat *seat,
                 struct sway_container *con) {
         seat_set_focus(seat, con ? &con->node : NULL);
@@ -1273,7 +1306,7 @@ void seat_set_focus_surface(struct sway_seat *seat,
         }
 
         sway_input_method_relay_set_focus(&seat->im_relay, surface);
-        seat_tablet_pads_notify_enter(seat, surface);
+        seat_tablet_pads_set_focus(seat, surface);
 }
 
 void seat_set_focus_layer(struct sway_seat *seat,
@@ -1287,28 +1320,23 @@ void seat_set_focus_layer(struct sway_seat *seat,
                         seat_set_focus(seat, previous);
                 }
                 return;
-        } else if (!layer || seat->focused_layer == layer) {
+        } else if (!layer) {
                 return;
         }
-        assert(layer->mapped);
-        seat_set_focus_surface(seat, layer->surface, true);
-        if (layer->current.layer >= ZWLR_LAYER_SHELL_V1_LAYER_TOP) {
-                seat->focused_layer = layer;
+        assert(layer->surface->mapped);
+        if (layer->current.layer >= ZWLR_LAYER_SHELL_V1_LAYER_TOP &&
+                        layer->current.keyboard_interactive
+                        == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE) {
+                seat->has_exclusive_layer = true;
         }
-}
-
-void seat_set_exclusive_client(struct sway_seat *seat,
-                struct wl_client *client) {
-        if (!client) {
-                seat->exclusive_client = client;
-                // Triggers a refocus of the topmost surface layer if necessary
-                // TODO: Make layer surface focus per-output based on cursor position
-                for (int i = 0; i < root->outputs->length; ++i) {
-                        struct sway_output *output = root->outputs->items[i];
-                        arrange_layers(output);
-                }
+        if (seat->focused_layer == layer) {
                 return;
         }
+        seat_set_focus_surface(seat, layer->surface, true);
+        seat->focused_layer = layer;
+}
+
+void seat_unfocus_unless_client(struct sway_seat *seat, struct wl_client *client) {
         if (seat->focused_layer) {
                 if (wl_resource_get_client(seat->focused_layer->resource) != client) {
                         seat_set_focus_layer(seat, NULL);
@@ -1335,7 +1363,6 @@ void seat_set_exclusive_client(struct sway_seat *seat,
                                         now.tv_nsec / 1000, point->touch_id);
                 }
         }
-        seat->exclusive_client = client;
 }
 
 struct sway_node *seat_get_focus_inactive(struct sway_seat *seat,
@@ -1416,9 +1443,8 @@ struct sway_node *seat_get_focus(struct sway_seat *seat) {
         if (!seat->has_focus) {
                 return NULL;
         }
-        if (wl_list_empty(&seat->focus_stack)) {
-                return NULL;
-        }
+        sway_assert(!wl_list_empty(&seat->focus_stack),
+                        "focus_stack is empty, but has_focus is true");
         struct sway_seat_node *current =
                 wl_container_of(seat->focus_stack.next, current, link);
         return current->node;
@@ -1503,7 +1529,7 @@ struct seat_config *seat_get_config_by_name(const char *name) {
 }
 
 void seat_pointer_notify_button(struct sway_seat *seat, uint32_t time_msec,
-                uint32_t button, enum wlr_button_state state) {
+                uint32_t button, enum wl_pointer_button_state state) {
         seat->last_button_serial = wlr_seat_pointer_notify_button(seat->wlr_seat,
                         time_msec, button, state);
 }
@@ -1540,7 +1566,7 @@ void seatop_unref(struct sway_seat *seat, struct sway_container *con) {
 
 void seatop_button(struct sway_seat *seat, uint32_t time_msec,
                 struct wlr_input_device *device, uint32_t button,
-                enum wlr_button_state state) {
+                enum wl_pointer_button_state state) {
         if (seat->seatop_impl->button) {
                 seat->seatop_impl->button(seat, time_msec, device, button, state);
         }
@@ -1553,12 +1579,38 @@ void seatop_pointer_motion(struct sway_seat *seat, uint32_t time_msec) {
 }
 
 void seatop_pointer_axis(struct sway_seat *seat,
-                struct wlr_event_pointer_axis *event) {
+                struct wlr_pointer_axis_event *event) {
         if (seat->seatop_impl->pointer_axis) {
                 seat->seatop_impl->pointer_axis(seat, event);
         }
 }
 
+void seatop_touch_motion(struct sway_seat *seat, struct wlr_touch_motion_event *event,
+                double lx, double ly) {
+        if (seat->seatop_impl->touch_motion) {
+                seat->seatop_impl->touch_motion(seat, event, lx, ly);
+        }
+}
+
+void seatop_touch_up(struct sway_seat *seat, struct wlr_touch_up_event *event) {
+        if (seat->seatop_impl->touch_up) {
+                seat->seatop_impl->touch_up(seat, event);
+        }
+}
+
+void seatop_touch_down(struct sway_seat *seat, struct wlr_touch_down_event *event,
+                double lx, double ly) {
+        if (seat->seatop_impl->touch_down) {
+                seat->seatop_impl->touch_down(seat, event, lx, ly);
+        }
+}
+
+void seatop_touch_cancel(struct sway_seat *seat, struct wlr_touch_cancel_event *event) {
+        if (seat->seatop_impl->touch_cancel) {
+                seat->seatop_impl->touch_cancel(seat, event);
+        }
+}
+
 void seatop_tablet_tool_tip(struct sway_seat *seat,
                 struct sway_tablet_tool *tool, uint32_t time_msec,
                 enum wlr_tablet_tool_tip_state state) {
@@ -1576,6 +1628,62 @@ void seatop_tablet_tool_motion(struct sway_seat *seat,
         }
 }
 
+void seatop_hold_begin(struct sway_seat *seat,
+                struct wlr_pointer_hold_begin_event *event) {
+        if (seat->seatop_impl->hold_begin) {
+                seat->seatop_impl->hold_begin(seat, event);
+        }
+}
+
+void seatop_hold_end(struct sway_seat *seat,
+                struct wlr_pointer_hold_end_event *event) {
+        if (seat->seatop_impl->hold_end) {
+                seat->seatop_impl->hold_end(seat, event);
+        }
+}
+
+void seatop_pinch_begin(struct sway_seat *seat,
+                struct wlr_pointer_pinch_begin_event *event) {
+        if (seat->seatop_impl->pinch_begin) {
+                seat->seatop_impl->pinch_begin(seat, event);
+        }
+}
+
+void seatop_pinch_update(struct sway_seat *seat,
+                struct wlr_pointer_pinch_update_event *event) {
+        if (seat->seatop_impl->pinch_update) {
+                seat->seatop_impl->pinch_update(seat, event);
+        }
+}
+
+void seatop_pinch_end(struct sway_seat *seat,
+                struct wlr_pointer_pinch_end_event *event) {
+        if (seat->seatop_impl->pinch_end) {
+                seat->seatop_impl->pinch_end(seat, event);
+        }
+}
+
+void seatop_swipe_begin(struct sway_seat *seat,
+                struct wlr_pointer_swipe_begin_event *event) {
+        if (seat->seatop_impl->swipe_begin) {
+                seat->seatop_impl->swipe_begin(seat, event);
+        }
+}
+
+void seatop_swipe_update(struct sway_seat *seat,
+                struct wlr_pointer_swipe_update_event *event) {
+        if (seat->seatop_impl->swipe_update) {
+                seat->seatop_impl->swipe_update(seat, event);
+        }
+}
+
+void seatop_swipe_end(struct sway_seat *seat,
+                struct wlr_pointer_swipe_end_event *event) {
+        if (seat->seatop_impl->swipe_end) {
+                seat->seatop_impl->swipe_end(seat, event);
+        }
+}
+
 void seatop_rebase(struct sway_seat *seat, uint32_t time_msec) {
         if (seat->seatop_impl->rebase) {
                 seat->seatop_impl->rebase(seat, time_msec);
@@ -1591,13 +1699,6 @@ void seatop_end(struct sway_seat *seat) {
         seat->seatop_impl = NULL;
 }
 
-void seatop_render(struct sway_seat *seat, struct sway_output *output,
-                pixman_region32_t *damage) {
-        if (seat->seatop_impl->render) {
-                seat->seatop_impl->render(seat, output, damage);
-        }
-}
-
 bool seatop_allows_set_cursor(struct sway_seat *seat) {
         return seat->seatop_impl->allow_set_cursor;
 }