rename and simplification

1 files changed, 1275 insertions, 0 deletions

diff --git a/src/platform/wayland/pointer.c b/src/platform/wayland/pointer.c
new file mode 100644
index 0000000..90b7ecc
--- /dev/null
+++ b/src/platform/wayland/pointer.c
@@ -0,0 +1,1275 @@
+#include "internal.h"
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define SCROLL_PX_PER_LINE 10.0
+
+struct tablet_tool {
+    struct tablet_tool *next;
+    struct seat *seat;
+    struct zwp_tablet_tool_v2 *proxy;
+    struct wp_cursor_shape_device_v1 *shape_dev;
+    uint32_t proximity_serial;
+    bool eraser;
+};
+
+struct tablet_device {
+    struct tablet_device *next;
+    struct zwp_tablet_v2 *proxy;
+};
+
+struct tablet_pad {
+    struct tablet_pad *next;
+    struct zwp_tablet_pad_v2 *proxy;
+};
+
+static inline int device_px_round(double v)
+{
+    return (int)lrint(v);
+}
+
+static struct yasl_vector2i device_from_fixed(const struct wayland_surface *w,
+                                              wl_fixed_t x, wl_fixed_t y)
+{
+    return (struct yasl_vector2i){
+        .x = device_px_round(wl_fixed_to_double(x) * w->scale_factor),
+        .y = device_px_round(wl_fixed_to_double(y) * w->scale_factor),
+    };
+}
+
+static inline int motion_button(uint64_t buttons)
+{
+    static const uint8_t motion_btn_lut[256] = {
+        [0] = 3,
+        [1] = 0, [2] = 1, [3] = 0, [4] = 2, [5] = 0, [6] = 1, [7] = 0,
+        [8] = 3, [9] = 0, [10] = 1, [11] = 0, [12] = 2, [13] = 0, [14] = 1, [15] = 0,
+        [16] = 4, [17] = 0, [18] = 1, [19] = 0, [20] = 2, [21] = 0, [22] = 1, [23] = 0,
+        [24] = 3, [25] = 0, [26] = 1, [27] = 0, [28] = 2, [29] = 0, [30] = 1, [31] = 0,
+        [32] = 5, [33] = 0, [34] = 1, [35] = 0, [36] = 2, [37] = 0, [38] = 1, [39] = 0,
+        [40] = 3, [41] = 0, [42] = 1, [43] = 0, [44] = 2, [45] = 0, [46] = 1, [47] = 0,
+        [48] = 4, [49] = 0, [50] = 1, [51] = 0, [52] = 2, [53] = 0, [54] = 1, [55] = 0,
+        [56] = 3, [57] = 0, [58] = 1, [59] = 0, [60] = 2, [61] = 0, [62] = 1, [63] = 0,
+        [64] = 6, [65] = 0, [66] = 1, [67] = 0, [68] = 2, [69] = 0, [70] = 1, [71] = 0,
+        [72] = 3, [73] = 0, [74] = 1, [75] = 0, [76] = 2, [77] = 0, [78] = 1, [79] = 0,
+        [80] = 4, [81] = 0, [82] = 1, [83] = 0, [84] = 2, [85] = 0, [86] = 1, [87] = 0,
+        [88] = 3, [89] = 0, [90] = 1, [91] = 0, [92] = 2, [93] = 0, [94] = 1, [95] = 0,
+        [96] = 5, [97] = 0, [98] = 1, [99] = 0, [100] = 2, [101] = 0, [102] = 1, [103] = 0,
+        [104] = 3, [105] = 0, [106] = 1, [107] = 0, [108] = 2, [109] = 0, [110] = 1, [111] = 0,
+        [112] = 4, [113] = 0, [114] = 1, [115] = 0, [116] = 2, [117] = 0, [118] = 1, [119] = 0,
+        [120] = 3, [121] = 0, [122] = 1, [123] = 0, [124] = 2, [125] = 0, [126] = 1, [127] = 0,
+        [128] = 7, [129] = 0, [130] = 1, [131] = 0, [132] = 2, [133] = 0, [134] = 1, [135] = 0,
+        [136] = 3, [137] = 0, [138] = 1, [139] = 0, [140] = 2, [141] = 0, [142] = 1, [143] = 0,
+        [144] = 4, [145] = 0, [146] = 1, [147] = 0, [148] = 2, [149] = 0, [150] = 1, [151] = 0,
+        [152] = 3, [153] = 0, [154] = 1, [155] = 0, [156] = 2, [157] = 0, [158] = 1, [159] = 0,
+        [160] = 5, [161] = 0, [162] = 1, [163] = 0, [164] = 2, [165] = 0, [166] = 1, [167] = 0,
+        [168] = 3, [169] = 0, [170] = 1, [171] = 0, [172] = 2, [173] = 0, [174] = 1, [175] = 0,
+        [176] = 4, [177] = 0, [178] = 1, [179] = 0, [180] = 2, [181] = 0, [182] = 1, [183] = 0,
+        [184] = 3, [185] = 0, [186] = 1, [187] = 0, [188] = 2, [189] = 0, [190] = 1, [191] = 0,
+        [192] = 6, [193] = 0, [194] = 1, [195] = 0, [196] = 2, [197] = 0, [198] = 1, [199] = 0,
+        [200] = 3, [201] = 0, [202] = 1, [203] = 0, [204] = 2, [205] = 0, [206] = 1, [207] = 0,
+        [208] = 4, [209] = 0, [210] = 1, [211] = 0, [212] = 2, [213] = 0, [214] = 1, [215] = 0,
+        [216] = 3, [217] = 0, [218] = 1, [219] = 0, [220] = 2, [221] = 0, [222] = 1, [223] = 0,
+        [224] = 5, [225] = 0, [226] = 1, [227] = 0, [228] = 2, [229] = 0, [230] = 1, [231] = 0,
+        [232] = 3, [233] = 0, [234] = 1, [235] = 0, [236] = 2, [237] = 0, [238] = 1, [239] = 0,
+        [240] = 4, [241] = 0, [242] = 1, [243] = 0, [244] = 2, [245] = 0, [246] = 1, [247] = 0,
+        [248] = 3, [249] = 0, [250] = 1, [251] = 0, [252] = 2, [253] = 0, [254] = 1, [255] = 0,
+    };
+    return motion_btn_lut[(uint8_t)buttons];
+}
+
+void seat_note_input(struct seat *s, uint32_t serial)
+{
+    s->input_serial = serial;
+    s->conn->active_seat = s;
+}
+
+struct seat *conn_active_seat(const struct wayland_display *c)
+{
+    return c->active_seat ? c->active_seat : c->seats;
+}
+
+static void push_mouse(struct seat *s, struct wayland_surface *w, struct yasl_mouse_event ev)
+{
+    ev.mods = (unsigned)seat_modifiers(s);
+    struct yasl_input_event input_ev = {
+        .kind = YASL_INPUT_MOUSE,
+        .surface = &w->base,
+        .mouse = ev,
+    };
+    input_queue_push(&surface_root(w)->input, &input_ev);
+}
+
+static void report_mouse(struct seat *s, struct wayland_surface *w, struct yasl_vector2i pos,
+                         int button, enum yasl_pointer_kind kind)
+{
+    push_mouse(s, w, (struct yasl_mouse_event){
+        .pos = pos, .button = button, .kind = kind,
+    });
+}
+
+static void report_wheel(struct seat *s, struct wayland_surface *w,
+                         struct yasl_vector2i pos, double x, double y)
+{
+    if ((x == 0 && y == 0) || !isfinite(x) || !isfinite(y)) return;
+    push_mouse(s, w, (struct yasl_mouse_event){
+        .pos = pos, .kind = YASL_PTR_SCROLL, .scroll = {x, y},
+    });
+}
+
+static bool cursor_theme_for(struct wayland_display *c, int scale)
+{
+    if (c->cursor_theme && c->cursor_theme_scale == scale)
+        return true;
+    struct wl_cursor_theme *theme = wl_cursor_theme_load(c->cursor_theme_name,
+            c->cursor_size * scale, c->shm);
+    if (!theme)
+        return c->cursor_theme != NULL;
+    if (c->cursor_theme)
+        wl_cursor_theme_destroy(c->cursor_theme);
+    c->cursor_theme = theme;
+    c->cursor_theme_scale = scale;
+    return true;
+}
+
+static bool seat_cursor_surface(struct seat *s)
+{
+    struct wayland_display *c = s->conn;
+    if (s->cursor_surface)
+        return true;
+    s->cursor_surface = wl_compositor_create_surface(c->compositor);
+    if (!s->cursor_surface)
+        return false;
+    if (c->viewporter)
+        s->cursor_viewport = wp_viewporter_get_viewport(c->viewporter, s->cursor_surface);
+    return true;
+}
+
+static void set_cursor_theme_fallback(struct seat *s, struct wayland_surface *w,
+                                      enum yasl_cursor shape)
+{
+    struct wayland_display *c = s->conn;
+    int scale = (int)((w->scale_120 + YASL_SCALE_UNIT - 1) / YASL_SCALE_UNIT);
+    if (scale < 1) scale = 1;
+    if (!seat_cursor_surface(s) || !cursor_theme_for(c, scale)) return;
+    static const char *names[][2] = {
+        {"default", "left_ptr"},
+        {"text", "xterm"},
+        {"pointer", "hand2"},
+        {"crosshair", "crosshair"},
+        {"move", "move"},
+        {"nwse-resize", "nw-resize"},
+        {"nesw-resize", "ne-resize"},
+        {"ew-resize", "ew-resize"},
+        {"ns-resize", "ns-resize"},
+    };
+    int idx = (unsigned)shape < YASL_CURSOR_HIDDEN ? (int)shape : 0;
+    struct wl_cursor *cursor = wl_cursor_theme_get_cursor(c->cursor_theme, names[idx][0]);
+    if (!cursor) cursor = wl_cursor_theme_get_cursor(c->cursor_theme, names[idx][1]);
+    if (!cursor || !cursor->image_count) return;
+    struct wl_cursor_image *img = cursor->images[0];
+    struct wl_buffer *buffer = wl_cursor_image_get_buffer(img);
+    if (!buffer) return;
+
+    int theme_scale = c->cursor_theme_scale;
+    if (s->cursor_viewport) {
+        wp_viewport_set_destination(s->cursor_viewport,
+                logical_px_ceil((int)img->width, (uint32_t)theme_scale * YASL_SCALE_UNIT),
+                logical_px_ceil((int)img->height, (uint32_t)theme_scale * YASL_SCALE_UNIT));
+    } else {
+        if (img->width % (uint32_t)theme_scale || img->height % (uint32_t)theme_scale)
+            theme_scale = 1;
+        wl_surface_set_buffer_scale(s->cursor_surface, theme_scale);
+    }
+    int shown = s->cursor_viewport ? c->cursor_theme_scale : theme_scale;
+    wl_pointer_set_cursor(s->pointer, s->pointer_serial, s->cursor_surface,
+            (int32_t)img->hotspot_x / shown, (int32_t)img->hotspot_y / shown);
+    wl_surface_attach(s->cursor_surface, buffer, 0, 0);
+    wl_surface_damage_buffer(s->cursor_surface, 0, 0,
+            (int32_t)img->width, (int32_t)img->height);
+    wl_surface_commit(s->cursor_surface);
+}
+
+static uint32_t cursor_shape_of(enum yasl_cursor shape)
+{
+    switch (shape) {
+    case YASL_CURSOR_TEXT: return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_TEXT;
+    case YASL_CURSOR_LINK: return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_POINTER;
+    case YASL_CURSOR_CROSSHAIR: return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_CROSSHAIR;
+    case YASL_CURSOR_MOVE: return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_MOVE;
+    case YASL_CURSOR_RESIZE_EW: return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_EW_RESIZE;
+    case YASL_CURSOR_RESIZE_NS: return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NS_RESIZE;
+    case YASL_CURSOR_RESIZE_NWSE: return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NWSE_RESIZE;
+    case YASL_CURSOR_RESIZE_NESW: return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NESW_RESIZE;
+    default: return WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_DEFAULT;
+    }
+}
+
+static void seat_set_cursor(struct seat *s, struct wayland_surface *w, enum yasl_cursor shape)
+{
+    if (!s->pointer || !s->pointer_serial || s->pointer_focus != w ||
+        s->cursor_shape == (int)shape)
+        return;
+    if (shape == YASL_CURSOR_HIDDEN)
+        wl_pointer_set_cursor(s->pointer, s->pointer_serial, NULL, 0, 0);
+    else if (s->cursor_shape_dev)
+        wp_cursor_shape_device_v1_set_shape(s->cursor_shape_dev,
+                s->pointer_serial, cursor_shape_of(shape));
+    else
+        set_cursor_theme_fallback(s, w, shape);
+    s->cursor_shape = shape;
+}
+
+static void tool_set_cursor(struct tablet_tool *t, enum yasl_cursor shape)
+{
+    if (!t->proximity_serial)
+        return;
+    if (shape == YASL_CURSOR_HIDDEN)
+        zwp_tablet_tool_v2_set_cursor(t->proxy, t->proximity_serial, NULL, 0, 0);
+    else if (t->shape_dev)
+        wp_cursor_shape_device_v1_set_shape(t->shape_dev, t->proximity_serial,
+                                            cursor_shape_of(shape));
+}
+
+void wayland_surface_set_cursor(struct wayland_surface *w, enum yasl_cursor shape)
+{
+    if (!w || !w->conn || w->destroyed || (unsigned)shape > YASL_CURSOR_HIDDEN) return;
+    w->cursor = shape;
+    for (struct seat *s = w->conn->seats; s; s = s->next) {
+        seat_set_cursor(s, w, shape);
+        if (s->tool && s->tablet_focus == w)
+            tool_set_cursor(s->tool, shape);
+    }
+}
+
+static void press_queue_flush(struct seat *s, struct press_queue *q,
+                              struct wayland_surface *only, uint64_t *buttons,
+                              struct yasl_mouse_event like)
+{
+    int kept = 0;
+    int count = q->n;
+    for (int i = 0; i < count; i++) {
+        struct pending_press p = q->ev[(q->head + i) & 7];
+        if (only && p.surface != only) {
+            q->ev[kept++] = p;
+            continue;
+        }
+        if (!p.surface) continue;
+        uint64_t mask = 1ull << p.button;
+        *buttons = (*buttons & ~mask) | ((uint64_t)(!p.release) << p.button);
+        struct yasl_mouse_event ev = like;
+        ev.pos = p.pos;
+        ev.button = p.button;
+        ev.kind = (enum yasl_pointer_kind)p.release;
+        push_mouse(s, p.surface, ev);
+    }
+    q->head = 0;
+    q->n = kept;
+}
+
+static void press_queue_push(struct press_queue *q, struct wayland_surface *w,
+                             struct yasl_vector2i pos, int button, bool release)
+{
+    if (q->n == 8) {
+        q->head = (q->head + 1) & 7;
+        q->n--;
+    }
+    q->ev[(q->head + q->n) & 7] = (struct pending_press){
+        .surface = w, .pos = pos, .button = button, .release = release,
+    };
+    q->n++;
+}
+
+static void press_queue_forget(struct press_queue *q, struct wayland_surface *w)
+{
+    for (int i = 0; i < q->n; i++) {
+        int idx = (q->head + i) & 7;
+        if (q->ev[idx].surface == w)
+            q->ev[idx].surface = NULL;
+    }
+}
+
+void seat_pointer_reset(struct seat *s)
+{
+    s->pointer_buttons = 0;
+    s->pointer_serial = 0;
+    s->motion_pending = false;
+    memset(s->axis, 0, sizeof(s->axis));
+    memset(s->axis_value120, 0, sizeof(s->axis_value120));
+    memset(s->axis_discrete, 0, sizeof(s->axis_discrete));
+    memset(s->axis_has_value120, 0, sizeof(s->axis_has_value120));
+    memset(s->axis_has_discrete, 0, sizeof(s->axis_has_discrete));
+    s->cursor_shape = -1;
+}
+
+static void pointer_frame(void *data, struct wl_pointer *pointer);
+
+static void pointer_event_done(struct seat *s)
+{
+    if (s->pointer && wl_pointer_get_version(s->pointer) < WL_POINTER_FRAME_SINCE_VERSION)
+        pointer_frame(s, s->pointer);
+}
+
+static void flush_pending_motion(struct seat *s, struct wayland_surface *w)
+{
+    if (!s->motion_pending) return;
+    s->motion_pending = false;
+    report_mouse(s, w, s->pointer_pos, motion_button(s->pointer_buttons), YASL_PTR_MOTION);
+}
+
+static void pointer_enter(void *data, struct wl_pointer *pointer,
+        uint32_t serial, struct wl_surface *surface,
+        wl_fixed_t surface_x, wl_fixed_t surface_y)
+{
+    (void)pointer;
+    struct seat *s = data;
+    struct wayland_surface *w = conn_surface_for(s->conn, surface);
+    s->pointer_focus = w;
+    if (!w) return;
+    s->pointer_pos = device_from_fixed(w, surface_x, surface_y);
+    s->pointer_serial = serial;
+    s->cursor_shape = -1;
+    seat_set_cursor(s, w, w->cursor);
+    s->motion_pending = true;
+    pointer_event_done(s);
+}
+
+static void pointer_leave(void *data, struct wl_pointer *pointer,
+        uint32_t serial, struct wl_surface *surface)
+{
+    (void)pointer; (void)serial; (void)surface;
+    struct seat *s = data;
+    struct wayland_surface *w = s->pointer_focus;
+    s->pointer_focus = NULL;
+    if (!w) return;
+    if (s->ptr_left)
+        pointer_frame(s, s->pointer);
+    s->ptr_left = w;
+    s->ptr_left_pos = s->pointer_pos;
+    s->ptr_left_motion = s->motion_pending;
+    s->motion_pending = false;
+    pointer_event_done(s);
+}
+
+static void pointer_motion(void *data, struct wl_pointer *pointer,
+        uint32_t time, wl_fixed_t surface_x, wl_fixed_t surface_y)
+{
+    (void)pointer; (void)time;
+    struct seat *s = data;
+    struct wayland_surface *w = s->pointer_focus;
+    if (!w) return;
+    s->pointer_pos = device_from_fixed(w, surface_x, surface_y);
+    s->motion_pending = true;
+    pointer_event_done(s);
+}
+
+static void pointer_button(void *data, struct wl_pointer *pointer,
+        uint32_t serial, uint32_t time, uint32_t button, uint32_t state)
+{
+    (void)pointer; (void)time;
+    struct seat *s = data;
+    struct wayland_surface *w = s->pointer_focus;
+    if (unlikely(!w)) return;
+
+    static const int8_t btn_map[8] = {
+        [0] = 0, /* BTN_LEFT (0x110) */
+        [1] = 2, /* BTN_RIGHT (0x111) */
+        [2] = 1, /* BTN_MIDDLE (0x112) */
+        [3] = 3, /* BTN_SIDE (0x113) */
+        [4] = 4, /* BTN_EXTRA (0x114) */
+        [5] = 4, /* BTN_FORWARD (0x115) */
+        [6] = 3, /* BTN_BACK (0x116) */
+        [7] = -1,
+    };
+    unsigned idx = button - 0x110;
+    if (unlikely(idx >= 7)) return;
+    int b = btn_map[idx];
+    if (unlikely(b < 0)) return;
+    seat_note_input(s, serial);
+    bool release = (state == WL_POINTER_BUTTON_STATE_RELEASED);
+    if (!release) {
+        s->press_serial = serial;
+        s->press_surface = w;
+    }
+    press_queue_push(&s->ptr_presses, w, s->pointer_pos, b, release);
+    pointer_event_done(s);
+}
+
+static void pointer_axis(void *data, struct wl_pointer *pointer,
+        uint32_t time, uint32_t axis, wl_fixed_t value)
+{
+    (void)pointer; (void)time;
+    struct seat *s = data;
+    if (unlikely(!s->pointer_focus)) return;
+    double v = wl_fixed_to_double(value);
+    if (likely(axis < 2)) {
+        s->axis[axis] += v;
+    }
+    pointer_event_done(s);
+}
+
+static void pointer_axis_source(void *data, struct wl_pointer *pointer, uint32_t axis_source)
+{
+    (void)pointer;
+    (void)data; (void)axis_source;
+}
+
+static void pointer_axis_stop(void *data, struct wl_pointer *pointer, uint32_t time, uint32_t axis)
+{
+    /* A stop ends a gesture, not the offsets already received in this frame. */
+    (void)data; (void)pointer; (void)time; (void)axis;
+}
+
+static void pointer_axis_discrete(void *data, struct wl_pointer *pointer, uint32_t axis, int32_t discrete)
+{
+    (void)pointer;
+    struct seat *s = data;
+    if (axis < 2) {
+        s->axis_discrete[axis] += discrete;
+        s->axis_has_discrete[axis] = true;
+    }
+}
+
+static void pointer_axis_value120(void *data, struct wl_pointer *pointer, uint32_t axis, int32_t value120)
+{
+    (void)pointer;
+    struct seat *s = data;
+    if (axis < 2) {
+        s->axis_value120[axis] += value120;
+        s->axis_has_value120[axis] = true;
+    }
+}
+
+static void pointer_frame_scroll(struct seat *s, struct wayland_surface *w)
+{
+    double lines[2];
+    for (int axis = 0; axis < 2; axis++) {
+        /* A wheel may provide all three representations. Pick one, never sum
+         * them. value120 preserves high-resolution detents on both axes. */
+        lines[axis] = s->axis_has_value120[axis] ? s->axis_value120[axis] / 120.0 :
+            s->axis_has_discrete[axis] ? (double)s->axis_discrete[axis] :
+            s->axis[axis] / SCROLL_PX_PER_LINE;
+        s->axis[axis] = s->axis_value120[axis] = 0;
+        s->axis_discrete[axis] = 0;
+        s->axis_has_value120[axis] = s->axis_has_discrete[axis] = false;
+    }
+    report_wheel(s, w, s->pointer_pos, lines[1], lines[0]);
+}
+
+static void pointer_frame(void *data, struct wl_pointer *pointer)
+{
+    (void)pointer;
+    struct seat *s = data;
+    struct wayland_surface *left = s->ptr_left;
+    if (left) {
+        s->ptr_left = NULL;
+        if (s->ptr_left_motion)
+            report_mouse(s, left, s->ptr_left_pos, motion_button(s->pointer_buttons), YASL_PTR_MOTION);
+        press_queue_flush(s, &s->ptr_presses, left, &s->pointer_buttons, (struct yasl_mouse_event){0});
+        report_mouse(s, left, s->ptr_left_pos, 3, YASL_PTR_LEAVE);
+        struct yasl_vector2i pos = s->pointer_pos;
+        bool motion = s->motion_pending;
+        uint32_t serial = s->pointer_focus ? s->pointer_serial : 0;
+        int shape = s->pointer_focus ? s->cursor_shape : -1;
+        seat_pointer_reset(s);
+        s->pointer_pos = pos;
+        s->motion_pending = motion;
+        s->pointer_serial = serial;
+        s->cursor_shape = shape;
+    }
+    struct wayland_surface *w = s->pointer_focus;
+    if (!w) {
+        s->ptr_presses.n = 0;
+        return;
+    }
+
+    flush_pending_motion(s, w);
+    press_queue_flush(s, &s->ptr_presses, NULL, &s->pointer_buttons, (struct yasl_mouse_event){0});
+
+    pointer_frame_scroll(s, w);
+}
+
+static void pointer_axis_relative_direction(void *data, struct wl_pointer *pointer, uint32_t axis, uint32_t direction)
+{ (void)data; (void)pointer; (void)axis; (void)direction; }
+static void pointer_warp(void *data, struct wl_pointer *pointer, wl_fixed_t x, wl_fixed_t y)
+{ (void)data; (void)pointer; (void)x; (void)y; }
+
+static const struct wl_pointer_listener pointer_listener = {
+    .axis_relative_direction = pointer_axis_relative_direction,
+    .warp = pointer_warp,
+    .enter = pointer_enter,
+    .leave = pointer_leave,
+    .motion = pointer_motion,
+    .button = pointer_button,
+    .axis = pointer_axis,
+    .frame = pointer_frame,
+    .axis_source = pointer_axis_source,
+    .axis_stop = pointer_axis_stop,
+    .axis_discrete = pointer_axis_discrete,
+    .axis_value120 = pointer_axis_value120,
+};
+
+static struct touch_point *touch_find(struct seat *s, int32_t id)
+{
+    for (int i = 0; i < SEAT_TOUCH_POINTS; i++)
+        if (s->touch_points[i].active && s->touch_points[i].id == id)
+            return &s->touch_points[i];
+    return NULL;
+}
+
+static struct yasl_vector2i touch_pos(const struct touch_point *p)
+{
+    double scale = p->surface->scale_factor;
+    return (struct yasl_vector2i){
+        .x = device_px_round(p->x * scale), .y = device_px_round(p->y * scale),
+    };
+}
+
+
+
+static void touch_report(struct seat *s, struct touch_point *p, int button,
+                         enum yasl_pointer_kind kind)
+{
+    push_mouse(s, p->surface, (struct yasl_mouse_event){
+        .pos = touch_pos(p), .button = button, .kind = kind,
+        .device = YASL_PTR_DEV_TOUCH,
+    });
+}
+
+static void touch_down(void *data, struct wl_touch *touch,
+        uint32_t serial, uint32_t time, struct wl_surface *surface,
+        int32_t id, wl_fixed_t x, wl_fixed_t y)
+{
+    (void)touch; (void)time;
+    struct seat *s = data;
+    struct wayland_surface *w = conn_surface_for(s->conn, surface);
+    if (!w || touch_find(s, id)) return;
+    struct touch_point *p = NULL;
+    for (int i = 0; i < SEAT_TOUCH_POINTS && !p; i++)
+        if (!s->touch_points[i].active)
+            p = &s->touch_points[i];
+    if (!p) return;
+    seat_note_input(s, serial);
+    s->press_serial = serial;
+    s->press_surface = w;
+    *p = (struct touch_point){
+        .surface = w, .id = id, .active = true, .down = true,
+        .x = wl_fixed_to_double(x), .y = wl_fixed_to_double(y),
+    };
+}
+
+static void touch_up(void *data, struct wl_touch *touch, uint32_t serial, uint32_t time, int32_t id)
+{
+    (void)touch; (void)serial; (void)time;
+    struct touch_point *p = touch_find(data, id);
+    if (p) p->up = true;
+}
+
+static void touch_motion(void *data, struct wl_touch *touch, uint32_t time, int32_t id, wl_fixed_t x, wl_fixed_t y)
+{
+    (void)touch; (void)time;
+    struct touch_point *p = touch_find(data, id);
+    if (!p) return;
+    p->x = wl_fixed_to_double(x);
+    p->y = wl_fixed_to_double(y);
+    p->moved = true;
+}
+
+static void touch_frame(void *data, struct wl_touch *touch)
+{
+    (void)touch;
+    struct seat *s = data;
+    int active_n = 0;
+    double centroid_sum = 0;
+    int centroid_n = 0;
+    for (int i = 0; i < SEAT_TOUCH_POINTS; i++) {
+        struct touch_point *p = &s->touch_points[i];
+        if (!p->active) continue;
+        if (p->down && !s->touch_primary && !s->touch_scrolling) {
+            s->touch_primary = p;
+            s->touch_pressed = true;
+            touch_report(s, p, 0, YASL_PTR_PRESS);
+        }
+        if (!p->up) {
+            active_n++;
+            if (s->touch_primary && p->surface == s->touch_primary->surface) {
+                centroid_sum += p->y;
+                centroid_n++;
+            }
+        }
+    }
+    struct touch_point *primary = s->touch_primary;
+    if (primary && !s->touch_scrolling && active_n >= 2) {
+        if (s->touch_pressed)
+            touch_report(s, primary, 0, YASL_PTR_RELEASE);
+        s->touch_pressed = false;
+        s->touch_scrolling = true;
+        s->touch_scroll_y = centroid_n ? centroid_sum / centroid_n : 0;
+    } else if (s->touch_scrolling && primary && active_n >= 2) {
+        double y = centroid_n ? centroid_sum / centroid_n : 0;
+        double dy = y - s->touch_scroll_y;
+        s->touch_scroll_y = y;
+        if (dy != 0.0) {
+            double lines = dy / SCROLL_PX_PER_LINE;
+            push_mouse(s, primary->surface, (struct yasl_mouse_event){
+                .pos = touch_pos(primary), .kind = YASL_PTR_SCROLL,
+                .scroll = {0, -lines}, .device = YASL_PTR_DEV_TOUCH,
+            });
+        }
+    } else if (primary && primary->moved && s->touch_pressed) {
+        touch_report(s, primary, 0, YASL_PTR_MOTION);
+    }
+    for (int i = 0; i < SEAT_TOUCH_POINTS; i++) {
+        struct touch_point *p = &s->touch_points[i];
+        if (!p->active) continue;
+        if (p->up) {
+            active_n--;
+            if (p == s->touch_primary) {
+                if (s->touch_pressed)
+                    touch_report(s, p, 0, YASL_PTR_RELEASE);
+                s->touch_pressed = false;
+                s->touch_primary = NULL;
+            }
+            *p = (struct touch_point){0};
+        } else {
+            p->down = p->moved = false;
+        }
+    }
+    if (active_n <= 0)
+        s->touch_scrolling = false;
+}
+
+static void touch_cancel(void *data, struct wl_touch *touch)
+{
+    (void)touch;
+    struct seat *s = data;
+    if (s->touch_primary && s->touch_pressed)
+        touch_report(s, s->touch_primary, 0, YASL_PTR_RELEASE);
+    memset(s->touch_points, 0, sizeof(s->touch_points));
+    s->touch_primary = NULL;
+    s->touch_pressed = false;
+    s->touch_scrolling = false;
+}
+
+static void touch_shape(void *data, struct wl_touch *touch, int32_t id, wl_fixed_t major, wl_fixed_t minor)
+{ (void)data; (void)touch; (void)id; (void)major; (void)minor; }
+static void touch_orientation(void *data, struct wl_touch *touch, int32_t id, wl_fixed_t orientation)
+{ (void)data; (void)touch; (void)id; (void)orientation; }
+
+static const struct wl_touch_listener touch_listener = {
+    .shape = touch_shape, .orientation = touch_orientation,
+    .down = touch_down, .up = touch_up, .motion = touch_motion,
+    .frame = touch_frame, .cancel = touch_cancel,
+};
+
+static struct yasl_mouse_event tool_event(const struct seat *s)
+{
+    return (struct yasl_mouse_event){
+        .device = s->tool && s->tool->eraser ? YASL_PTR_DEV_ERASER : YASL_PTR_DEV_PEN,
+        .pen = s->pen,
+    };
+}
+
+static void tablet_tool_proximity_in(void *data,
+        struct zwp_tablet_tool_v2 *tool, uint32_t serial,
+        struct zwp_tablet_v2 *tablet, struct wl_surface *surface)
+{
+    (void)tool; (void)tablet;
+    struct tablet_tool *t = data;
+    struct seat *s = t->seat;
+    struct wayland_surface *w = conn_surface_for(s->conn, surface);
+    s->tablet_focus = w;
+    s->tool = t;
+    s->tool_buttons = 0;
+    s->pen = (struct yasl_pointer_pen){0};
+    t->proximity_serial = serial;
+    if (!w) return;
+    if (s->conn->cursor_shape_mgr && !t->shape_dev)
+        t->shape_dev = wp_cursor_shape_manager_v1_get_tablet_tool_v2(
+                s->conn->cursor_shape_mgr, t->proxy);
+    tool_set_cursor(t, w->cursor);
+    s->tool_motion = true;
+}
+
+static void tablet_tool_proximity_out(void *data, struct zwp_tablet_tool_v2 *tool)
+{
+    (void)tool;
+    struct tablet_tool *t = data;
+    struct seat *s = t->seat;
+    struct wayland_surface *w = s->tablet_focus;
+    if (w) {
+        press_queue_flush(s, &s->tool_presses, NULL, &s->tool_buttons, tool_event(s));
+        s->pen.pressure = 0;
+        struct yasl_mouse_event ev = tool_event(s);
+        ev.pos = s->tool_pos;
+        ev.button = 3;
+        ev.kind = YASL_PTR_LEAVE;
+        push_mouse(s, w, ev);
+    }
+    s->tool_presses.n = 0;
+    s->tablet_focus = NULL;
+    s->tool = NULL;
+    s->tool_motion = false;
+    s->tool_wheel = 0;
+    s->tool_buttons = 0;
+    t->proximity_serial = 0;
+}
+
+static void tablet_tool_down(void *data, struct zwp_tablet_tool_v2 *tool, uint32_t serial)
+{
+    (void)tool;
+    struct seat *s = ((struct tablet_tool *)data)->seat;
+    struct wayland_surface *w = s->tablet_focus;
+    if (!w) return;
+    seat_note_input(s, serial);
+    s->press_serial = serial;
+    s->press_surface = w;
+    press_queue_push(&s->tool_presses, w, s->tool_pos, 0, false);
+}
+
+static void tablet_tool_up(void *data, struct zwp_tablet_tool_v2 *tool)
+{
+    (void)tool;
+    struct seat *s = ((struct tablet_tool *)data)->seat;
+    struct wayland_surface *w = s->tablet_focus;
+    if (!w) return;
+    s->pen.pressure = 0;
+    press_queue_push(&s->tool_presses, w, s->tool_pos, 0, true);
+}
+
+static void tablet_tool_motion(void *data, struct zwp_tablet_tool_v2 *tool, wl_fixed_t x, wl_fixed_t y)
+{
+    (void)tool;
+    struct seat *s = ((struct tablet_tool *)data)->seat;
+    struct wayland_surface *w = s->tablet_focus;
+    if (!w) return;
+    s->tool_pos = device_from_fixed(w, x, y);
+    s->tool_motion = true;
+}
+
+static void tablet_tool_button(void *data, struct zwp_tablet_tool_v2 *tool,
+        uint32_t serial, uint32_t button, uint32_t state)
+{
+    (void)tool;
+    struct seat *s = ((struct tablet_tool *)data)->seat;
+    struct wayland_surface *w = s->tablet_focus;
+    if (!w) return;
+    seat_note_input(s, serial);
+    int b;
+    switch (button) {
+    case BTN_STYLUS:  b = 2; break;
+    case BTN_STYLUS2: b = 1; break;
+    case BTN_STYLUS3: b = 3; break;
+    default: return;
+    }
+    bool release = state == ZWP_TABLET_TOOL_V2_BUTTON_STATE_RELEASED;
+    press_queue_push(&s->tool_presses, w, s->tool_pos, b, release);
+}
+
+static void tool_pressure(void *d, struct zwp_tablet_tool_v2 *t, uint32_t v)
+{
+    (void)t;
+    struct seat *s = ((struct tablet_tool *)d)->seat;
+    s->pen.pressure = v > 65535 ? 65535 : (uint16_t)v;
+    s->tool_motion = true;
+}
+
+static int8_t tilt_degrees(wl_fixed_t v)
+{
+    double d = wl_fixed_to_double(v);
+    return (int8_t)(d < -90 ? -90 : d > 90 ? 90 : lround(d));
+}
+
+static void tool_tilt(void *d, struct zwp_tablet_tool_v2 *t, wl_fixed_t x, wl_fixed_t y)
+{
+    (void)t;
+    struct seat *s = ((struct tablet_tool *)d)->seat;
+    s->pen.tilt_x = tilt_degrees(x);
+    s->pen.tilt_y = tilt_degrees(y);
+    s->tool_motion = true;
+}
+
+static void tool_wheel(void *d, struct zwp_tablet_tool_v2 *t, wl_fixed_t deg, int32_t clicks)
+{
+    (void)t; (void)deg;
+    ((struct tablet_tool *)d)->seat->tool_wheel += clicks;
+}
+
+static void tool_frame(void *d, struct zwp_tablet_tool_v2 *t, uint32_t time)
+{
+    (void)t; (void)time;
+    struct seat *s = ((struct tablet_tool *)d)->seat;
+    struct wayland_surface *w = s->tablet_focus;
+    if (!w) {
+        s->tool_presses.n = 0;
+        s->tool_wheel = 0;
+        return;
+    }
+    struct yasl_mouse_event like = tool_event(s);
+    if (s->tool_motion) {
+        struct yasl_mouse_event ev = like;
+        ev.pos = s->tool_pos;
+        ev.button = motion_button(s->tool_buttons);
+        ev.kind = YASL_PTR_MOTION;
+        push_mouse(s, w, ev);
+        s->tool_motion = false;
+    }
+    press_queue_flush(s, &s->tool_presses, NULL, &s->tool_buttons, like);
+    if (s->tool_wheel) {
+        struct yasl_mouse_event ev = like;
+        ev.pos = s->tool_pos;
+        ev.kind = YASL_PTR_SCROLL;
+        ev.scroll.y = s->tool_wheel;
+        push_mouse(s, w, ev);
+        s->tool_wheel = 0;
+    }
+}
+
+static void tablet_tool_removed(void *data, struct zwp_tablet_tool_v2 *tool)
+{
+    struct tablet_tool *t = data;
+    struct seat *s = t->seat;
+    if (s->tool == t) {
+        tablet_tool_proximity_out(t, tool);
+    }
+    struct tablet_tool **link = &s->tablet_tools;
+    while (*link && *link != t)
+        link = &(*link)->next;
+    if (*link)
+        *link = t->next;
+    if (t->shape_dev)
+        wp_cursor_shape_device_v1_destroy(t->shape_dev);
+    zwp_tablet_tool_v2_destroy(tool);
+    free(t);
+}
+
+static void tool_type(void *d, struct zwp_tablet_tool_v2 *t, uint32_t type)
+{
+    (void)t;
+    ((struct tablet_tool *)d)->eraser = type == ZWP_TABLET_TOOL_V2_TYPE_ERASER;
+}
+
+static void tool_hardware_serial(void *d, struct zwp_tablet_tool_v2 *t, uint32_t hi, uint32_t lo) { (void)d; (void)t; (void)hi; (void)lo; }
+static void tool_hardware_id_wacom(void *d, struct zwp_tablet_tool_v2 *t, uint32_t hi, uint32_t lo) { (void)d; (void)t; (void)hi; (void)lo; }
+static void tool_capability(void *d, struct zwp_tablet_tool_v2 *t, uint32_t cap) { (void)d; (void)t; (void)cap; }
+static void tool_done(void *d, struct zwp_tablet_tool_v2 *t) { (void)d; (void)t; }
+static void tool_distance(void *d, struct zwp_tablet_tool_v2 *t, uint32_t v) { (void)d; (void)t; (void)v; }
+static void tool_rotation(void *d, struct zwp_tablet_tool_v2 *t, wl_fixed_t deg) { (void)d; (void)t; (void)deg; }
+static void tool_slider(void *d, struct zwp_tablet_tool_v2 *t, int32_t pos) { (void)d; (void)t; (void)pos; }
+
+static const struct zwp_tablet_tool_v2_listener tablet_tool_listener = {
+    .type = tool_type, .hardware_serial = tool_hardware_serial,
+    .hardware_id_wacom = tool_hardware_id_wacom, .capability = tool_capability,
+    .done = tool_done, .removed = tablet_tool_removed,
+    .proximity_in = tablet_tool_proximity_in, .proximity_out = tablet_tool_proximity_out,
+    .down = tablet_tool_down, .up = tablet_tool_up, .motion = tablet_tool_motion,
+    .pressure = tool_pressure, .distance = tool_distance, .tilt = tool_tilt,
+    .rotation = tool_rotation, .slider = tool_slider, .wheel = tool_wheel,
+    .button = tablet_tool_button, .frame = tool_frame,
+};
+
+static void tablet_name(void *data, struct zwp_tablet_v2 *tablet, const char *name) { (void)data; (void)tablet; (void)name; }
+static void tablet_id(void *data, struct zwp_tablet_v2 *tablet, uint32_t vid, uint32_t pid) { (void)data; (void)tablet; (void)vid; (void)pid; }
+static void tablet_path(void *data, struct zwp_tablet_v2 *tablet, const char *path) { (void)data; (void)tablet; (void)path; }
+static void tablet_done(void *data, struct zwp_tablet_v2 *tablet) { (void)data; (void)tablet; }
+static void tablet_bustype(void *data, struct zwp_tablet_v2 *tablet, uint32_t bustype) { (void)data; (void)tablet; (void)bustype; }
+
+static void tablet_removed(void *data, struct zwp_tablet_v2 *tablet)
+{
+    struct seat *s = data;
+    struct tablet_device **link = &s->tablet_devices;
+    while (*link && (*link)->proxy != tablet)
+        link = &(*link)->next;
+    if (*link) {
+        struct tablet_device *removed = *link;
+        *link = removed->next;
+        free(removed);
+    }
+    zwp_tablet_v2_destroy(tablet);
+}
+
+static const struct zwp_tablet_v2_listener tablet_listener = {
+    .name = tablet_name, .id = tablet_id, .path = tablet_path,
+    .done = tablet_done, .removed = tablet_removed, .bustype = tablet_bustype,
+};
+
+/* yasl does not use pad groups. The group proxy belongs to the client, so
+ * destroy it here rather than leak it. */
+static void tablet_pad_group(void *data, struct zwp_tablet_pad_v2 *pad, struct zwp_tablet_pad_group_v2 *group) { (void)data; (void)pad; zwp_tablet_pad_group_v2_destroy(group); }
+static void tablet_pad_path(void *data, struct zwp_tablet_pad_v2 *pad, const char *path) { (void)data; (void)pad; (void)path; }
+static void tablet_pad_buttons(void *data, struct zwp_tablet_pad_v2 *pad, uint32_t buttons) { (void)data; (void)pad; (void)buttons; }
+static void tablet_pad_done(void *data, struct zwp_tablet_pad_v2 *pad) { (void)data; (void)pad; }
+static void tablet_pad_button(void *data, struct zwp_tablet_pad_v2 *pad, uint32_t time, uint32_t button, uint32_t state) { (void)data; (void)pad; (void)time; (void)button; (void)state; }
+static void tablet_pad_enter(void *data, struct zwp_tablet_pad_v2 *pad, uint32_t serial, struct zwp_tablet_v2 *tablet, struct wl_surface *surface) { (void)data; (void)pad; (void)serial; (void)tablet; (void)surface; }
+static void tablet_pad_leave(void *data, struct zwp_tablet_pad_v2 *pad, uint32_t serial, struct wl_surface *surface) { (void)data; (void)pad; (void)serial; (void)surface; }
+
+static void tablet_pad_removed(void *data, struct zwp_tablet_pad_v2 *pad)
+{
+    struct seat *s = data;
+    struct tablet_pad **link = &s->tablet_pads;
+    while (*link && (*link)->proxy != pad)
+        link = &(*link)->next;
+    if (*link) {
+        struct tablet_pad *removed = *link;
+        *link = removed->next;
+        free(removed);
+    }
+    zwp_tablet_pad_v2_destroy(pad);
+}
+
+static const struct zwp_tablet_pad_v2_listener tablet_pad_listener = {
+    .group = tablet_pad_group, .path = tablet_pad_path, .buttons = tablet_pad_buttons,
+    .done = tablet_pad_done, .button = tablet_pad_button, .enter = tablet_pad_enter,
+    .leave = tablet_pad_leave, .removed = tablet_pad_removed,
+};
+
+void seat_destroy_tablet(struct seat *s)
+{
+    while (s->tablet_tools)
+        tablet_tool_removed(s->tablet_tools, s->tablet_tools->proxy);
+    while (s->tablet_pads)
+        tablet_pad_removed(s, s->tablet_pads->proxy);
+    while (s->tablet_devices)
+        tablet_removed(s, s->tablet_devices->proxy);
+    if (s->tablet_seat) {
+        zwp_tablet_seat_v2_destroy(s->tablet_seat);
+        s->tablet_seat = NULL;
+    }
+}
+
+static void tablet_seat_tablet_added(void *data, struct zwp_tablet_seat_v2 *tablet_seat, struct zwp_tablet_v2 *tablet)
+{
+    (void)tablet_seat;
+    struct seat *s = data;
+    struct tablet_device *owned = calloc(1, sizeof(*owned));
+    if (!owned) { zwp_tablet_v2_destroy(tablet); return; }
+    owned->proxy = tablet;
+    owned->next = s->tablet_devices;
+    s->tablet_devices = owned;
+    zwp_tablet_v2_add_listener(tablet, &tablet_listener, s);
+}
+
+static void tablet_seat_tool_added(void *data, struct zwp_tablet_seat_v2 *tablet_seat, struct zwp_tablet_tool_v2 *tool)
+{
+    (void)tablet_seat;
+    struct seat *s = data;
+    struct tablet_tool *owned = calloc(1, sizeof(*owned));
+    if (!owned) { zwp_tablet_tool_v2_destroy(tool); return; }
+    owned->proxy = tool;
+    owned->seat = s;
+    owned->next = s->tablet_tools;
+    s->tablet_tools = owned;
+    zwp_tablet_tool_v2_add_listener(tool, &tablet_tool_listener, owned);
+}
+
+static void tablet_seat_pad_added(void *data, struct zwp_tablet_seat_v2 *tablet_seat, struct zwp_tablet_pad_v2 *pad)
+{
+    (void)tablet_seat;
+    struct seat *s = data;
+    struct tablet_pad *owned = calloc(1, sizeof(*owned));
+    if (!owned) { zwp_tablet_pad_v2_destroy(pad); return; }
+    owned->proxy = pad;
+    owned->next = s->tablet_pads;
+    s->tablet_pads = owned;
+    zwp_tablet_pad_v2_add_listener(pad, &tablet_pad_listener, s);
+}
+
+static const struct zwp_tablet_seat_v2_listener tablet_seat_listener = {
+    .tablet_added = tablet_seat_tablet_added,
+    .tool_added = tablet_seat_tool_added,
+    .pad_added = tablet_seat_pad_added,
+};
+
+static void clipboard_received(const char *text, size_t len, bool uri_list,
+                             struct wl_surface *on, void *ud)
+{
+    struct seat *s = ud;
+    struct wayland_display *c = s->conn;
+    struct wayland_surface *w = conn_surface_for(c, on);
+    if (uri_list) w = surface_root(w);
+    if (!w || w->closed) return;
+    struct yasl_input_event ev = {
+        .surface = &w->base,
+        .kind = uri_list ? YASL_INPUT_DROP_FILES : YASL_INPUT_PASTE,
+    };
+    if (uri_list) {
+        ev.drop_files.files = text;
+        ev.drop_files.len = len;
+    } else {
+        ev.paste.text = text;
+        ev.paste.len = len;
+    }
+    input_queue_push(&w->input, &ev);
+}
+
+static void clipboard_drag(enum yasl_drag_event ev, struct wl_surface *on,
+                           double x, double y, void *ud)
+{
+    struct seat *s = ud;
+    conn_drag_target(s->conn, ev, on, x, y);
+}
+
+static void clipboard_drop_hover(enum yasl_drop_event ev, struct wl_surface *on,
+                                 double x, double y, void *ud)
+{
+    struct seat *s = ud;
+    conn_drop_target(s->conn, ev, on, x, y);
+}
+
+void seat_clipboard_ensure(struct seat *s)
+{
+    struct wayland_display *c = s->conn;
+    if (!c->data_manager || !s->proxy)
+        return;
+    if (!s->clipboard) {
+        s->clipboard = clipboard_create(c->wl, c->data_manager, s->proxy,
+                                        c->loop, clipboard_received, s);
+        if (!s->clipboard)
+            return;
+        clipboard_set_drag_handler(s->clipboard, clipboard_drag, s);
+        clipboard_set_drop_handler(s->clipboard, clipboard_drop_hover, s);
+    }
+    if (c->primary_selection_mgr)
+        clipboard_set_primary_manager(s->clipboard, c->primary_selection_mgr);
+}
+
+static void seat_drop_pointer(struct seat *s)
+{
+    if (s->cursor_shape_dev) {
+        wp_cursor_shape_device_v1_destroy(s->cursor_shape_dev);
+        s->cursor_shape_dev = NULL;
+    }
+    if (s->pointer) {
+        if (wl_pointer_get_version(s->pointer) >= WL_POINTER_RELEASE_SINCE_VERSION)
+            wl_pointer_release(s->pointer);
+        else
+            wl_pointer_destroy(s->pointer);
+        s->pointer = NULL;
+    }
+    seat_pointer_reset(s);
+    s->pointer_focus = s->ptr_left = NULL;
+    s->ptr_presses.n = 0;
+}
+
+static void seat_drop_keyboard(struct seat *s)
+{
+    keyboard_repeat_stop(s);
+    keyboard_text_reset(s);
+    if (s->keyboard) {
+        if (wl_keyboard_get_version(s->keyboard) >= WL_KEYBOARD_RELEASE_SINCE_VERSION)
+            wl_keyboard_release(s->keyboard);
+        else
+            wl_keyboard_destroy(s->keyboard);
+        s->keyboard = NULL;
+    }
+    s->repeat_rate = 0;
+    struct wayland_surface *w = s->keyboard_focus;
+    s->keyboard_focus = NULL;
+    if (w && !s->focus_leaving)
+        s->focus_leaving = w;
+}
+
+static void seat_drop_touch(struct seat *s)
+{
+    if (s->touch) {
+        touch_cancel(s, s->touch);
+        if (wl_touch_get_version(s->touch) >= WL_TOUCH_RELEASE_SINCE_VERSION)
+            wl_touch_release(s->touch);
+        else
+            wl_touch_destroy(s->touch);
+        s->touch = NULL;
+    }
+}
+
+static void seat_capabilities(void *data, struct wl_seat *proxy, uint32_t caps)
+{
+    struct seat *s = data;
+    struct wayland_display *c = s->conn;
+    if (caps & WL_SEAT_CAPABILITY_KEYBOARD) {
+        if (!s->keyboard) {
+            s->keyboard = wl_seat_get_keyboard(proxy);
+            if (s->keyboard)
+                wl_keyboard_add_listener(s->keyboard, &keyboard_listener, s);
+            if (s->keyboard && wl_keyboard_get_version(s->keyboard) <
+                    WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION) {
+                s->repeat_rate = 25;
+                s->repeat_delay = 600;
+            }
+        }
+    } else if (s->keyboard) {
+        seat_drop_keyboard(s);
+    }
+
+    if (caps & WL_SEAT_CAPABILITY_POINTER) {
+        if (!s->pointer) {
+            s->pointer = wl_seat_get_pointer(proxy);
+            if (s->pointer)
+                wl_pointer_add_listener(s->pointer, &pointer_listener, s);
+            if (s->pointer && c->cursor_shape_mgr)
+                s->cursor_shape_dev = wp_cursor_shape_manager_v1_get_pointer(
+                        c->cursor_shape_mgr, s->pointer);
+        }
+    } else if (s->pointer) {
+        seat_drop_pointer(s);
+    }
+
+    if (caps & WL_SEAT_CAPABILITY_TOUCH) {
+        if (!s->touch) {
+            s->touch = wl_seat_get_touch(proxy);
+            if (s->touch)
+                wl_touch_add_listener(s->touch, &touch_listener, s);
+        }
+    } else if (s->touch) {
+        seat_drop_touch(s);
+    }
+
+    if (c->tablet_mgr && !s->tablet_seat) {
+        s->tablet_seat = zwp_tablet_manager_v2_get_tablet_seat(c->tablet_mgr, proxy);
+        if (s->tablet_seat)
+            zwp_tablet_seat_v2_add_listener(s->tablet_seat, &tablet_seat_listener, s);
+    }
+
+    if (c->text_input_mgr && !s->text_input) {
+        s->text_input = zwp_text_input_manager_v3_get_text_input(c->text_input_mgr, proxy);
+        if (s->text_input)
+            zwp_text_input_v3_add_listener(s->text_input, &text_input_listener, s);
+    }
+
+    seat_clipboard_ensure(s);
+}
+
+static void seat_name(void *data, struct wl_seat *seat, const char *name)
+{ (void)data; (void)seat; (void)name; }
+
+const struct wl_seat_listener seat_listener = {
+    .capabilities = seat_capabilities,
+    .name = seat_name,
+};
+
+void seat_bind(struct wayland_display *c, struct wl_registry *registry,
+               uint32_t name, uint32_t version)
+{
+    struct seat *s = calloc(1, sizeof(*s));
+    if (!s) return;
+    s->conn = c;
+    s->name = name;
+    s->repeat_fd = -1;
+    s->cursor_shape = -1;
+    s->proxy = wl_registry_bind(registry, name, &wl_seat_interface,
+                                version < 8 ? version : 8);
+    if (!s->proxy) {
+        free(s);
+        return;
+    }
+    s->next = c->seats;
+    c->seats = s;
+    wl_seat_add_listener(s->proxy, &seat_listener, s);
+    keyboard_repeat_init(s);
+}
+
+void seat_forget_surface(struct seat *s, struct wayland_surface *w)
+{
+    clipboard_forget_surface(s->clipboard, w->surface);
+    struct wayland_surface **refs[] = {
+        &s->pointer_focus, &s->keyboard_focus,
+        &s->tablet_focus, &s->ime_focus, &s->focus_leaving, &s->ptr_left,
+        &s->press_surface,
+    };
+    for (size_t i = 0; i < sizeof(refs) / sizeof(refs[0]); i++)
+        if (*refs[i] == w)
+            *refs[i] = NULL;
+    press_queue_forget(&s->ptr_presses, w);
+    press_queue_forget(&s->tool_presses, w);
+    for (int i = 0; i < SEAT_TOUCH_POINTS; i++) {
+        if (s->touch_points[i].active && s->touch_points[i].surface == w) {
+            if (s->touch_primary == &s->touch_points[i]) {
+                s->touch_primary = NULL;
+                s->touch_pressed = false;
+            }
+            s->touch_points[i] = (struct touch_point){0};
+        }
+    }
+}
+
+void seat_destroy(struct seat *s)
+{
+    struct wayland_display *c = s->conn;
+    for (struct seat **link = &c->seats; *link; link = &(*link)->next) {
+        if (*link == s) {
+            *link = s->next;
+            break;
+        }
+    }
+    if (c->active_seat == s)
+        c->active_seat = NULL;
+    for (struct wayland_surface *w = c->surfaces; w; w = w->conn_next) {
+        if (w->ime_seat == s) {
+            w->ime_seat = NULL;
+            ime_reset(w);
+        }
+    }
+    if (c->drag.seat == s)
+        conn_drag_end(c);
+    if (s->text_input)
+        zwp_text_input_v3_destroy(s->text_input);
+    seat_destroy_tablet(s);
+    seat_drop_pointer(s);
+    seat_drop_keyboard(s);
+    struct wayland_surface *left = s->focus_leaving;
+    if (left && !conn_keyboard_on(c, left, NULL)) {
+        struct yasl_input_event ev = {
+            .kind = YASL_INPUT_FOCUS,
+            .surface = &left->base,
+            .focus = { .focused = false },
+        };
+        input_queue_push(&left->input, &ev);
+    }
+    seat_drop_touch(s);
+    clipboard_destroy(s->clipboard);
+    if (s->repeat_watch > 0) yasl_loop_del_fd(c->loop, s->repeat_watch);
+    if (s->repeat_fd >= 0) close(s->repeat_fd);
+    if (s->cursor_viewport) wp_viewport_destroy(s->cursor_viewport);
+    if (s->cursor_surface) wl_surface_destroy(s->cursor_surface);
+    if (s->xkb_state) xkb_state_unref(s->xkb_state);
+    if (s->compose) xkb_compose_state_unref(s->compose);
+    if (s->xkb_keymap) xkb_keymap_unref(s->xkb_keymap);
+    if (s->proxy) {
+        if (wl_seat_get_version(s->proxy) >= WL_SEAT_RELEASE_SINCE_VERSION)
+            wl_seat_release(s->proxy);
+        else
+            wl_seat_destroy(s->proxy);
+    }
+    free(s);
+}
+
+bool seat_remove(struct wayland_display *c, uint32_t name)
+{
+    for (struct seat *s = c->seats; s; s = s->next) {
+        if (s->name == name) {
+            seat_destroy(s);
+            return true;
+        }
+    }
+    return false;
+}
+
+int display_input_init(struct wayland_display *c)
+{
+    for (struct seat *s = c->seats; s; s = s->next) {
+        keyboard_repeat_init(s);
+        seat_clipboard_ensure(s);
+    }
+    return 0;
+}
+
+void surface_init_cursor(struct wayland_display *c)
+{
+    if (c->cursor_shape_mgr)
+        return;
+    const char *env_size = getenv("XCURSOR_SIZE");
+    int size = env_size ? atoi(env_size) : 0;
+    c->cursor_theme_name = getenv("XCURSOR_THEME");
+    c->cursor_size = size > 0 && size <= 512 ? size : 24;
+    cursor_theme_for(c, 1);
+}