1 files changed, 179 insertions, 46 deletions

diff --git a/sway/input/seat.c b/sway/input/seat.c
index 1f5865ee..b21e1b86 100644
--- a/sway/input/seat.c
+++ b/sway/input/seat.c
@@ -11,6 +11,7 @@
 #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"
@@ -20,6 +21,7 @@
 #include "sway/input/cursor.h"
 #include "sway/input/input-manager.h"
 #include "sway/input/keyboard.h"
+#include "sway/input/libinput.h"
 #include "sway/input/seat.h"
 #include "sway/input/switch.h"
 #include "sway/input/tablet.h"
@@ -41,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);
@@ -50,6 +53,16 @@ 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);
 }
 
@@ -129,7 +142,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;
                 }
         }
@@ -137,7 +150,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;
                 }
         }
@@ -199,6 +212,15 @@ static void seat_send_focus(struct sway_node *node, struct sway_seat *seat) {
         }
 }
 
+void sway_force_focus(struct wlr_surface *surface) {
+        struct sway_seat *seat;
+        wl_list_for_each(seat, &server.input->seats, link) {
+                seat_keyboard_notify_enter(seat, surface);
+                seat_tablet_pads_notify_enter(seat, surface);
+                sway_input_method_relay_set_focus(&seat->im_relay, surface);
+        }
+}
+
 void seat_for_each_node(struct sway_seat *seat,
                 void (*f)(struct sway_node *node, void *data), void *data) {
         struct sway_seat_node *current = NULL;
@@ -209,14 +231,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;
                 }
         }
@@ -235,7 +256,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);
@@ -309,8 +330,8 @@ static void handle_seat_node_destroy(struct wl_listener *listener, void *data) {
                 // Setting focus_inactive
                 focus = seat_get_focus_inactive(seat, &root->node);
                 seat_set_raw_focus(seat, next_focus);
-                if (focus->type == N_CONTAINER && focus->sway_container->workspace) {
-                        seat_set_raw_focus(seat, &focus->sway_container->workspace->node);
+                if (focus->type == N_CONTAINER && focus->sway_container->pending.workspace) {
+                        seat_set_raw_focus(seat, &focus->sway_container->pending.workspace->node);
                 }
                 seat_set_raw_focus(seat, focus);
         }
@@ -368,8 +389,8 @@ void drag_icon_update_position(struct sway_drag_icon *icon) {
         case WLR_DRAG_GRAB_KEYBOARD:
                 return;
         case WLR_DRAG_GRAB_KEYBOARD_POINTER:
-                icon->x = cursor->x;
-                icon->y = cursor->y;
+                icon->x = cursor->x + wlr_icon->surface->sx;
+                icon->y = cursor->y + wlr_icon->surface->sy;
                 break;
         case WLR_DRAG_GRAB_KEYBOARD_TOUCH:;
                 struct wlr_touch_point *point =
@@ -377,8 +398,8 @@ void drag_icon_update_position(struct sway_drag_icon *icon) {
                 if (point == NULL) {
                         return;
                 }
-                icon->x = seat->touch_x;
-                icon->y = seat->touch_y;
+                icon->x = seat->touch_x + wlr_icon->surface->sx;
+                icon->y = seat->touch_y + wlr_icon->surface->sy;
         }
 
         drag_icon_damage_whole(icon);
@@ -666,6 +687,40 @@ static void seat_reset_input_config(struct sway_seat *seat,
                 sway_device->input_device->wlr_device, NULL);
 }
 
+static bool has_prefix(const char *str, const char *prefix) {
+        return strncmp(str, prefix, strlen(prefix)) == 0;
+}
+
+/**
+ * Get the name of the built-in output, if any. Returns NULL if there isn't
+ * exactly one built-in output.
+ */
+static const char *get_builtin_output_name(void) {
+        const char *match = NULL;
+        for (int i = 0; i < root->outputs->length; ++i) {
+                struct sway_output *output = root->outputs->items[i];
+                const char *name = output->wlr_output->name;
+                if (has_prefix(name, "eDP-") || has_prefix(name, "LVDS-") ||
+                                has_prefix(name, "DSI-")) {
+                        if (match != NULL) {
+                                return NULL;
+                        }
+                        match = name;
+                }
+        }
+        return match;
+}
+
+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:
+                return true;
+        default:
+                return false;
+        }
+}
+
 static void seat_apply_input_config(struct sway_seat *seat,
                 struct sway_seat_device *sway_device) {
         struct input_config *ic =
@@ -680,8 +735,33 @@ 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:
-                mapped_to_output = sway_device->input_device->wlr_device->output_name;
+        case MAPPED_TO_DEFAULT:;
+                /*
+                 * If the wlroots backend provides an output name, use that.
+                 *
+                 * Otherwise, try to map built-in touch and pointer devices to the
+                 * built-in output.
+                 */
+                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 (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();
+                        if (mapped_to_output) {
+                                sway_log(SWAY_DEBUG, "Auto-detected output '%s' for device '%s'",
+                                        mapped_to_output, sway_device->input_device->identifier);
+                        }
+                }
                 if (mapped_to_output == NULL) {
                         return;
                 }
@@ -742,12 +822,14 @@ static void seat_configure_keyboard(struct sway_seat *seat,
         }
         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
+                wlr_keyboard_from_input_device(seat_device->input_device->wlr_device));
+
+        // 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);
         }
 }
 
@@ -999,7 +1081,8 @@ void seat_configure_xcursor(struct sway_seat *seat) {
 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;
+        return seat->exclusive_client == client ||
+                (seat->exclusive_client == NULL && !server.session_lock.locked);
 }
 
 static void send_unfocus(struct sway_container *con, void *data) {
@@ -1086,29 +1169,23 @@ void seat_set_focus(struct sway_seat *seat, struct sway_node *node) {
         }
 
         struct sway_workspace *new_workspace = node->type == N_WORKSPACE ?
-                node->sway_workspace : node->sway_container->workspace;
+                node->sway_workspace : node->sway_container->pending.workspace;
         struct sway_container *container = node->type == N_CONTAINER ?
                 node->sway_container : NULL;
 
-        // Deny setting focus to a view which is hidden by a fullscreen container
-        if (new_workspace && new_workspace->fullscreen && container &&
-                        !container_is_fullscreen_or_child(container)) {
-                // Unless it's a transient container
-                if (!container_is_transient_for(container, new_workspace->fullscreen)) {
-                        return;
-                }
+        // Deny setting focus to a view which is hidden by a fullscreen container or global
+        if (container && container_obstructing_fullscreen_container(container)) {
+                return;
         }
+
         // Deny setting focus to a workspace node when using fullscreen global
         if (root->fullscreen_global && !container && new_workspace) {
                 return;
         }
-        // Deny setting focus to a view which is hidden by a fullscreen global
-        if (root->fullscreen_global && container != root->fullscreen_global &&
-                                !container_has_ancestor(container, root->fullscreen_global)) {
-                // Unless it's a transient container
-                if (!container_is_transient_for(container, root->fullscreen_global)) {
-                        return;
-                }
+
+        // Deny setting focus when an input grab or lockscreen is active
+        if (container && container->view && !seat_is_input_allowed(seat, container->view->surface)) {
+                return;
         }
 
         struct sway_output *new_output =
@@ -1135,10 +1212,10 @@ void seat_set_focus(struct sway_seat *seat, struct sway_node *node) {
         // Put the container parents on the focus stack, then the workspace, then
         // the focused container.
         if (container) {
-                struct sway_container *parent = container->parent;
+                struct sway_container *parent = container->pending.parent;
                 while (parent) {
                         seat_set_raw_focus(seat, &parent->node);
-                        parent = parent->parent;
+                        parent = parent->pending.parent;
                 }
         }
         if (new_workspace) {
@@ -1234,6 +1311,7 @@ void seat_set_focus_surface(struct sway_seat *seat,
                 wlr_seat_keyboard_notify_clear_focus(seat->wlr_seat);
         }
 
+        sway_input_method_relay_set_focus(&seat->im_relay, surface);
         seat_tablet_pads_notify_enter(seat, surface);
 }
 
@@ -1326,7 +1404,7 @@ struct sway_container *seat_get_focus_inactive_tiling(struct sway_seat *seat,
                 struct sway_node *node = current->node;
                 if (node->type == N_CONTAINER &&
                                 !container_is_floating_or_child(node->sway_container) &&
-                                node->sway_container->workspace == workspace) {
+                                node->sway_container->pending.workspace == workspace) {
                         return node->sway_container;
                 }
         }
@@ -1343,7 +1421,7 @@ struct sway_container *seat_get_focus_inactive_floating(struct sway_seat *seat,
                 struct sway_node *node = current->node;
                 if (node->type == N_CONTAINER &&
                                 container_is_floating_or_child(node->sway_container) &&
-                                node->sway_container->workspace == workspace) {
+                                node->sway_container->pending.workspace == workspace) {
                         return node->sway_container;
                 }
         }
@@ -1377,9 +1455,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;
@@ -1391,7 +1468,7 @@ struct sway_workspace *seat_get_focused_workspace(struct sway_seat *seat) {
                 return NULL;
         }
         if (focus->type == N_CONTAINER) {
-                return focus->sway_container->workspace;
+                return focus->sway_container->pending.workspace;
         }
         if (focus->type == N_WORKSPACE) {
                 return focus->sway_workspace;
@@ -1404,8 +1481,8 @@ struct sway_workspace *seat_get_last_known_workspace(struct sway_seat *seat) {
         wl_list_for_each(current, &seat->focus_stack, link) {
                 struct sway_node *node = current->node;
                 if (node->type == N_CONTAINER &&
-                                node->sway_container->workspace) {
-                        return node->sway_container->workspace;
+                                node->sway_container->pending.workspace) {
+                        return node->sway_container->pending.workspace;
                 } else if (node->type == N_WORKSPACE) {
                         return node->sway_workspace;
                 }
@@ -1514,7 +1591,7 @@ 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);
         }
@@ -1537,6 +1614,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);