From 94a60f8a98f7ccabf43ad7fad0ef888a953d0bb2 Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Sun, 16 Mar 2025 19:14:29 +0530
Subject: [PATCH 01/27] Support most of tablet-v2
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Missing: pad support.
I’ve stubbed enough that it shouldn’t crash if one is added
    (I feel like it should be possible to stub less,
    but I didn’t know enough to do that!),
but since I don’t have such a thing to test or benefit from,
I’ve skipped it for now.
I have the feeling they’re not so common anyway?
My tablet has ten buttons, but they come through as keyboard, not pad.
And OpenTabletDriver doesn’t look to be able to produce pads.

There are still some improvements to make:

  • I haven’t played with zwp_tablet_tool_v2.set_cursor yet;
    it may warrant something extra.

  • I want to add a drawing mode in the example, a trivial sketching app.

  • I like the metadata and frame accumulators I made in the example.
    I want to shift them into sctk itself as handlers or whatever,
    because I think that’s going to be a pretty common desire.

  • There are some places where I’m passing, say, a wl_seat,
    because it was done in the code I was basing it off,
    and I’m not sure if it’s useful or not.
    Need to whittle the *Data things down, where possible.

  • I’ve got a few TODOs from things that I just don’t know about.
    Each and every one should be checked.
---
 examples/tablet.rs         | 741 +++++++++++++++++++++++++++++++++++++
 src/seat/mod.rs            |   1 +
 src/seat/tablet/manager.rs |  62 ++++
 src/seat/tablet/mod.rs     |  62 ++++
 src/seat/tablet/pad.rs     | 167 +++++++++
 src/seat/tablet/seat.rs    |  91 +++++
 src/seat/tablet/tablet.rs  | 110 ++++++
 src/seat/tablet/tool.rs    | 376 +++++++++++++++++++
 8 files changed, 1610 insertions(+)
 create mode 100644 examples/tablet.rs
 create mode 100644 src/seat/tablet/manager.rs
 create mode 100644 src/seat/tablet/mod.rs
 create mode 100644 src/seat/tablet/pad.rs
 create mode 100644 src/seat/tablet/seat.rs
 create mode 100644 src/seat/tablet/tablet.rs
 create mode 100644 src/seat/tablet/tool.rs

diff --git a/examples/tablet.rs b/examples/tablet.rs
new file mode 100644
index 000000000..a8a16b805
--- /dev/null
+++ b/examples/tablet.rs
@@ -0,0 +1,741 @@
+//! An example demonstrating tablets
+
+use std::collections::{HashSet, HashMap};
+
+use smithay_client_toolkit::{
+    compositor::{CompositorHandler, CompositorState},
+    delegate_compositor, delegate_output, delegate_pointer,
+    delegate_registry, delegate_tablet, delegate_seat, delegate_shm, delegate_xdg_shell,
+    delegate_xdg_window,
+    output::{OutputHandler, OutputState},
+    registry::{ProvidesRegistryState, RegistryState},
+    registry_handlers,
+    seat::{
+        pointer::{PointerEvent, PointerEventKind, PointerHandler},
+        tablet::{
+            ToolType,
+            ToolCapability,
+            TabletState,
+            TabletSeatHandler,
+            TabletEvent, TabletEventList, TabletHandler,
+            TabletToolInitEvent, TabletToolInitEventList,
+            TabletToolEventFrame,
+            TabletToolEvent, TabletToolHandler,
+        },
+        Capability, SeatHandler, SeatState,
+    },
+    shell::{
+        xdg::{
+            window::{Window, WindowConfigure, WindowDecorations, WindowHandler},
+            XdgShell,
+        },
+        WaylandSurface,
+    },
+    shm::{slot::SlotPool, Shm, ShmHandler},
+};
+use wayland_client::{
+    globals::registry_queue_init,
+    protocol::{wl_output, wl_pointer, wl_region, wl_seat, wl_shm, wl_surface},
+    Connection, Dispatch, QueueHandle,
+    Proxy,
+};
+use wayland_protocols::wp::tablet::zv2::client::{
+    zwp_tablet_seat_v2::ZwpTabletSeatV2,
+    zwp_tablet_tool_v2::ZwpTabletToolV2,
+    zwp_tablet_v2::ZwpTabletV2,
+    // zwp_tablet_pad_v2::ZwpTabletPadV2,
+    // zwp_tablet_pad_group_v2::ZwpTabletPadGroupV2,
+    // zwp_tablet_pad_ring_v2::ZwpTabletPadRingV2,
+    // zwp_tablet_pad_strip_v2::ZwpTabletPadStripV2,
+};
+
+const RED: raqote::SolidSource = raqote::SolidSource { r: 221, g: 0, b: 0, a: 255 };
+const GREEN: raqote::SolidSource = raqote::SolidSource { r: 0, g: 170, b: 0, a: 255 };
+const SOLID_RED: raqote::Source = raqote::Source::Solid(RED);
+const SOLID_GREEN: raqote::Source = raqote::Source::Solid(GREEN);
+
+const WHITE: raqote::SolidSource = raqote::SolidSource { r: 255, g: 255, b: 255, a: 255 };
+const BLACK: raqote::SolidSource = raqote::SolidSource { r: 0, g: 0, b: 0, a: 255 };
+const SOLID_BLACK: raqote::Source = raqote::Source::Solid(BLACK);
+
+fn main() {
+    env_logger::init();
+
+    let conn = Connection::connect_to_env().unwrap();
+
+    let (globals, mut event_queue) = registry_queue_init(&conn).unwrap();
+    let qh = event_queue.handle();
+
+    let font = font_kit::source::SystemSource::new()
+        .select_best_match(
+            &[font_kit::family_name::FamilyName::SansSerif],
+            &font_kit::properties::Properties::new(),
+        )
+        .unwrap()
+        .load()
+        .unwrap();
+
+    let mut simple_window = SimpleWindow {
+        registry_state: RegistryState::new(&globals),
+        seat_state: SeatState::new(&globals, &qh),
+        output_state: OutputState::new(&globals, &qh),
+        compositor_state: CompositorState::bind(&globals, &qh)
+            .expect("wl_compositor not available"),
+        shm_state: Shm::bind(&globals, &qh).expect("wl_shm not available"),
+        xdg_shell_state: XdgShell::bind(&globals, &qh).expect("xdg shell not available"),
+        tablet_state: TabletState::bind(&globals, &qh),
+
+        exit: false,
+        width: 256,
+        height: 256,
+        window: None,
+        tablet_seat: None,
+        tablets: HashMap::new(),
+        tools: HashMap::new(),
+        font,
+    };
+
+    let surface = simple_window.compositor_state.create_surface(&qh);
+
+    let window =
+        simple_window.xdg_shell_state.create_window(surface, WindowDecorations::ServerDefault, &qh);
+
+    window.set_title("A wayland window");
+    window.set_app_id("io.github.smithay.client-toolkit.Tablet");
+    window.set_min_size(Some((256, 256)));
+
+    window.commit();
+
+    simple_window.window = Some(window);
+
+    while !simple_window.exit {
+        event_queue.blocking_dispatch(&mut simple_window).unwrap();
+    }
+}
+
+#[derive(Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+struct TabletMetadata {
+    /// The descriptive name of the tablet device.
+    name: Option<String>,
+    /// The USB vendor and product IDs for the tablet device.
+    id: Option<(u32, u32)>,
+    /// System-specific device paths for the tablet.
+    ///
+    /// Path format is unspecified.
+    /// Clients must figure out what to do with them, if they care.
+    paths: Vec<String>,
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+struct Button {
+    serial: u32,
+    button: u32,
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+struct TabletToolCapabilities {
+    tilt: bool,
+    pressure: bool,
+    distance: bool,
+    rotation: bool,
+    slider: bool,
+    wheel: bool,
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+struct TabletToolInfo {
+    tool_type: ToolType,
+    hardware_serial: Option<(u32, u32)>,
+    hardware_id_wacom: Option<(u32, u32)>,
+    capabilities: TabletToolCapabilities,
+}
+
+/// The current state of the tool.
+///
+/// This covers everything, and may, for some applications,
+/// be the most practical way of perceiving it;
+/// but button is more likely to be desired as events,
+/// and wheel is fundamentally a delta thing,
+/// so for at least them you probably want to consume the events.
+///
+/// Also you won’t get the last frame’s time, if you view it this way,
+/// as a proximity_out event deletes the state.
+#[derive(Debug)]
+struct TabletToolState {
+    // ProximityIn
+    serial: u32,
+    tablet: ZwpTabletV2,
+    surface: wl_surface::WlSurface,
+    // Down (cleared on Up), stores serial
+    down: Option<u32>,
+    // Motion
+    x: f64,
+    y: f64,
+    // Pressure
+    pressure: u16,
+    // Distance
+    distance: u16,
+    // Tilt
+    tilt_x: f64,
+    tilt_y: f64,
+    // Rotation
+    rotation_degrees: f64,
+    // Slider
+    slider_position: i32,
+    // Wheel
+    wheel_degrees: f64,
+    wheel_clicks: i32,
+    // Button
+    buttons: HashSet<Button>,
+}
+
+struct ToolInfoAndState {
+    /// Static info about the tool and its capabilities.
+    info: TabletToolInfo,
+    /// The time the last frame was sent,
+    /// or zero if no frames have come yet.
+    last_frame_time: u32,
+    /// The current state of the tool, if in proximity.
+    state: Option<TabletToolState>,
+}
+
+impl ToolInfoAndState {
+    /// Get the pressure according to the Web Pointer Events API:
+    /// scaled in the range \[0, 1\],
+    /// and set to 0.5 when down if pressure isn’t supported.
+    fn pressure_web(&self) -> f64 {
+        match (self.info.capabilities.pressure, &self.state) {
+            (true, &Some(TabletToolState { pressure, .. })) => pressure as f64 / 65535.0,
+            (false, Some(TabletToolState { down: Some(_), .. })) => 0.5,
+            _ => 0.0,
+        }
+    }
+}
+
+struct SimpleWindow {
+    registry_state: RegistryState,
+    seat_state: SeatState,
+    output_state: OutputState,
+    compositor_state: CompositorState,
+    shm_state: Shm,
+    xdg_shell_state: XdgShell,
+    tablet_state: TabletState,
+
+    exit: bool,
+    width: u32,
+    height: u32,
+    window: Option<Window>,
+    tablet_seat: Option<ZwpTabletSeatV2>,
+
+    tools: HashMap<ZwpTabletToolV2, ToolInfoAndState>,
+    tablets: HashMap<ZwpTabletV2, TabletMetadata>,
+
+    font: font_kit::loaders::freetype::Font,
+}
+
+impl CompositorHandler for SimpleWindow {
+    fn scale_factor_changed(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        _surface: &wl_surface::WlSurface,
+        _new_factor: i32,
+    ) {
+        // Not needed for this example.
+    }
+
+    fn transform_changed(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        _surface: &wl_surface::WlSurface,
+        _new_transform: wl_output::Transform,
+    ) {
+        // Not needed for this example.
+    }
+
+    fn frame(
+        &mut self,
+        conn: &Connection,
+        qh: &QueueHandle<Self>,
+        _surface: &wl_surface::WlSurface,
+        _time: u32,
+    ) {
+        self.draw(conn, qh);
+    }
+
+    fn surface_enter(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        _surface: &wl_surface::WlSurface,
+        _output: &wl_output::WlOutput,
+    ) {
+        // Not needed for this example.
+    }
+
+    fn surface_leave(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        _surface: &wl_surface::WlSurface,
+        _output: &wl_output::WlOutput,
+    ) {
+        // Not needed for this example.
+    }
+}
+
+impl OutputHandler for SimpleWindow {
+    fn output_state(&mut self) -> &mut OutputState {
+        &mut self.output_state
+    }
+
+    fn new_output(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        _output: wl_output::WlOutput,
+    ) {
+    }
+
+    fn update_output(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        _output: wl_output::WlOutput,
+    ) {
+    }
+
+    fn output_destroyed(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        _output: wl_output::WlOutput,
+    ) {
+    }
+}
+
+impl WindowHandler for SimpleWindow {
+    fn request_close(&mut self, _: &Connection, _: &QueueHandle<Self>, _: &Window) {
+        self.exit = true;
+    }
+
+    fn configure(
+        &mut self,
+        conn: &Connection,
+        qh: &QueueHandle<Self>,
+        _window: &Window,
+        configure: WindowConfigure,
+        _serial: u32,
+    ) {
+        self.width = configure.new_size.0.map(|v| v.get()).unwrap_or(256);
+        self.height = configure.new_size.1.map(|v| v.get()).unwrap_or(256);
+        self.draw(conn, qh);
+    }
+}
+
+impl SeatHandler for SimpleWindow {
+    fn seat_state(&mut self) -> &mut SeatState {
+        &mut self.seat_state
+    }
+
+    fn new_seat(&mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _seat: wl_seat::WlSeat) {
+        // TODO: I would have thought tablet seat initialisation should happen here,
+        // but this doesn’t seem to be called?
+        // I’m not at all sure I’m structuring this the right way.
+        panic!("I thought new_seat didn’t get called?");
+    }
+
+    fn new_capability(
+        &mut self,
+        _conn: &Connection,
+        qh: &QueueHandle<Self>,
+        seat: wl_seat::WlSeat,
+        _capability: Capability,
+    ) {
+        if self.tablet_seat.is_none() {
+            let tablet_seat = self.tablet_state.get_tablet_seat(&seat, qh).ok();
+            if tablet_seat.is_some() {
+                println!("Created tablet seat");
+            } else {
+                println!("Compositor does not support tablet events");
+            }
+            self.tablet_seat = tablet_seat;
+        }
+    }
+
+    fn remove_capability(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        _seat: wl_seat::WlSeat,
+        _capability: Capability,
+    ) {
+    }
+
+    fn remove_seat(&mut self, _: &Connection, _: &QueueHandle<Self>, _: wl_seat::WlSeat) {
+        // TODO: do we need to release tablet_seat, or will it sort itself out?
+    }
+}
+
+impl PointerHandler for SimpleWindow {
+    fn pointer_frame(
+        &mut self,
+        conn: &Connection,
+        qh: &QueueHandle<Self>,
+        _pointer: &wl_pointer::WlPointer,
+        events: &[PointerEvent],
+    ) {
+        for event in events {
+            if let PointerEventKind::Release { .. } = event.kind {
+                self.change_constraint(conn, qh);
+            }
+        }
+    }
+}
+
+impl TabletSeatHandler for SimpleWindow {
+    fn tablet_added(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        _tablet_seat: &ZwpTabletSeatV2,
+        _seat: &wl_seat::WlSeat,
+        tablet: ZwpTabletV2,
+    ) {
+        println!("Added tablet: {}", tablet.id());
+    }
+
+    fn tool_added(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        _tablet_seat: &ZwpTabletSeatV2,
+        _seat: &wl_seat::WlSeat,
+        tool: ZwpTabletToolV2,
+    ) {
+        println!("Added tablet tool: {}", tool.id());
+    }
+
+    // fn pad_added(
+    //     &mut self,
+    //     _conn: &Connection,
+    //     _qh: &QueueHandle<Self>,
+    //     _tablet_seat: &ZwpTabletSeatV2,
+    //     _seat: &wl_seat::WlSeat,
+    //     pad: ZwpTabletPadV2,
+    // ) {
+    //     println!("Added tablet pad: {}", pad.id());
+    // }
+}
+
+impl TabletHandler for SimpleWindow {
+    fn init_done(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        tablet: &ZwpTabletV2,
+        events: TabletEventList,
+    ) {
+        let mut metadata = TabletMetadata::default();
+        for event in events {
+            match event {
+                TabletEvent::Name { name } => metadata.name = Some(name),
+                TabletEvent::Id { vid, pid } => metadata.id = Some((vid, pid)),
+                TabletEvent::Path { path } => metadata.paths.push(path),
+            }
+        }
+        println!("Tablet {} initialised: {:#?}", tablet.id(), metadata);
+        self.tablets.insert(tablet.clone(), metadata);
+    }
+
+    fn removed(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        tablet: &ZwpTabletV2,
+    ) {
+        println!("Tablet {} removed", tablet.id());
+        self.tablets.remove(tablet);
+    }
+}
+
+impl TabletToolHandler for SimpleWindow {
+    fn init_done(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        tablet_tool: &ZwpTabletToolV2,
+        events: TabletToolInitEventList,
+    ) {
+        let mut tool_type = None;
+        let mut hardware_serial = None;
+        let mut hardware_id_wacom = None;
+        let mut capabilities = TabletToolCapabilities {
+            tilt: false,
+            pressure: false,
+            distance: false,
+            rotation: false,
+            slider: false,
+            wheel: false,
+        };
+        for event in events {
+            match event {
+                TabletToolInitEvent::Type { tool_type: t } => tool_type = Some(t),
+                TabletToolInitEvent::HardwareSerial { hardware_serial_hi, hardware_serial_lo } => hardware_serial = Some((hardware_serial_hi, hardware_serial_lo)),
+                TabletToolInitEvent::HardwareIdWacom { hardware_id_hi, hardware_id_lo } => hardware_id_wacom = Some((hardware_id_hi, hardware_id_lo)),
+                TabletToolInitEvent::Capability { capability: ToolCapability::Tilt } => capabilities.tilt = true,
+                TabletToolInitEvent::Capability { capability: ToolCapability::Pressure } => capabilities.pressure = true,
+                TabletToolInitEvent::Capability { capability: ToolCapability::Distance } => capabilities.distance = true,
+                TabletToolInitEvent::Capability { capability: ToolCapability::Rotation } => capabilities.rotation = true,
+                TabletToolInitEvent::Capability { capability: ToolCapability::Slider } => capabilities.slider = true,
+                TabletToolInitEvent::Capability { capability: ToolCapability::Wheel } => capabilities.wheel = true,
+                TabletToolInitEvent::Capability { capability: _ } => (),
+            }
+        }
+        let info = TabletToolInfo {
+            tool_type: tool_type.expect("zwp_tablet_tool_v2.type event missing"),
+            hardware_serial,
+            hardware_id_wacom,
+            capabilities,
+        };
+        println!("Tablet tool {} initialised: {:#?}", tablet_tool.id(), info);
+        self.tools.insert(tablet_tool.clone(), ToolInfoAndState {
+            info,
+            last_frame_time: 0,
+            state: None,
+        });
+    }
+
+    fn removed(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        tablet_tool: &ZwpTabletToolV2,
+    ) {
+        println!("Tablet tool {} removed", tablet_tool.id());
+    }
+
+    fn tablet_tool_frame(
+        &mut self,
+        _conn: &Connection,
+        _qh: &QueueHandle<Self>,
+        tablet_tool: &ZwpTabletToolV2,
+        frame: TabletToolEventFrame,
+    ) {
+        println!("Tablet tool {} frame: {:#?}", tablet_tool.id(), frame);
+        let TabletToolEventFrame { time, events } = frame;
+        let mut events = events.into_iter();
+        let tias = self.tools.get_mut(tablet_tool).unwrap();
+        let state = tias.state.get_or_insert_with(|| {
+            let Some(TabletToolEvent::ProximityIn { serial, tablet, surface }) = events.next()
+            else {
+                panic!("First zwp_tablet_tool_v2 frame didn’t start with a proximity_in event");
+            };
+            TabletToolState {
+                // ProximityIn
+                serial,
+                tablet,
+                surface,
+                // Down (cleared on Up)
+                down: None,
+                // Motion
+                x: 0.0,
+                y: 0.0,
+                // Pressure
+                pressure: 0,
+                // Distance
+                distance: 0,
+                // Tilt
+                tilt_x: 0.0,
+                tilt_y: 0.0,
+                // Rotation
+                rotation_degrees: 0.0,
+                // Slider
+                slider_position: 0,
+                // Wheel
+                wheel_degrees: 0.0,
+                wheel_clicks: 0,
+                // Button
+                buttons: HashSet::new(),
+            }
+        });
+        tias.last_frame_time = time;
+
+        for event in events {
+            match event {
+                TabletToolEvent::ProximityIn { serial, tablet, surface } => {
+                    state.serial = serial;
+                    state.tablet = tablet;
+                    state.surface = surface;
+                },
+                TabletToolEvent::ProximityOut => {
+                    tias.state = None;
+                    // Given that a frame is supposed to represent a single hardware event,
+                    // I think you can fairly say it’d be mad to proximity_out and
+                    // immediately proximity_in in the same frame.
+                    // So I think we’re OK to just break.
+                    break;
+                },
+                TabletToolEvent::Down { serial } => {
+                    state.down = Some(serial);
+                },
+                TabletToolEvent::Up => {
+                    state.down = None;
+                },
+                TabletToolEvent::Motion { x, y } => {
+                    state.x = x;
+                    state.y = y;
+                },
+                TabletToolEvent::Pressure { pressure } => {
+                    state.pressure = pressure;
+                },
+                TabletToolEvent::Distance { distance } => {
+                    state.distance = distance;
+                },
+                TabletToolEvent::Tilt { tilt_x, tilt_y } => {
+                    state.tilt_x = tilt_x;
+                    state.tilt_y = tilt_y;
+                },
+                TabletToolEvent::Rotation { degrees } => {
+                    state.rotation_degrees = degrees;
+                },
+                TabletToolEvent::Slider { position } => {
+                    state.slider_position = position;
+                },
+                TabletToolEvent::Wheel { degrees, clicks } => {
+                    // These ones use += because they’re deltas, unlike the rest.
+                    state.wheel_degrees += degrees;
+                    state.wheel_clicks += clicks;
+                },
+                TabletToolEvent::Button { serial, button, pressed } => {
+                    if pressed {
+                        state.buttons.insert(Button { serial, button });
+                    } else {
+                        state.buttons.remove(&Button { serial, button });
+                    }
+                },
+            }
+        }
+    }
+}
+
+impl ShmHandler for SimpleWindow {
+    fn shm_state(&mut self) -> &mut Shm {
+        &mut self.shm_state
+    }
+}
+
+impl SimpleWindow {
+    pub fn draw(&mut self, _conn: &Connection, qh: &QueueHandle<Self>) {
+        if let Some(window) = self.window.as_ref() {
+            let width = self.width;
+            let height = self.height;
+            let stride = self.width as i32 * 4;
+
+            let mut pool = SlotPool::new(width as usize * height as usize * 4, &self.shm_state)
+                .expect("Failed to create pool");
+
+            let buffer = pool
+                .create_buffer(width as i32, height as i32, stride, wl_shm::Format::Xrgb8888)
+                .expect("create buffer")
+                .0;
+
+            let mut dt = raqote::DrawTarget::from_backing(
+                width as i32,
+                height as i32,
+                bytemuck::cast_slice_mut(pool.canvas(&buffer).unwrap()),
+            );
+            dt.clear(WHITE);
+            let mut y = 16.;
+            if self.tablets.is_empty() {
+                dt.draw_text(
+                    &self.font,
+                    14.,
+                    "No tablets found",
+                    raqote::Point::new(2., y),
+                    &SOLID_RED,
+                    &raqote::DrawOptions::new(),
+                );
+            } else {
+                for (id, tablet_metadata) in &self.tablets {
+                    let text = match &tablet_metadata.name {
+                        Some(name) => name,
+                        None => &*id.id().to_string(),
+                    };
+                    dt.draw_text(
+                        &self.font,
+                        14.,
+                        text,
+                        raqote::Point::new(2., y),
+                        &SOLID_BLACK,
+                        &raqote::DrawOptions::new(),
+                    );
+                    y += 16.0;
+                }
+            }
+
+            for tias in self.tools.values() {
+                if let Some(state) = &tias.state {
+                    let mut pb = raqote::PathBuilder::new();
+                    let pressure = tias.pressure_web();
+                    pb.arc(
+                        state.x as f32,// * self.width as f32,
+                        state.y as f32,// * self.height as f32,
+                        10.0 + 30.0 * pressure as f32,
+                        0.,
+                        2. * std::f32::consts::PI,
+                    );
+                    pb.close();
+                    dt.fill(
+                        &pb.finish(),
+                        &if state.down.is_some() { SOLID_GREEN } else { SOLID_RED },
+                        &raqote::DrawOptions::new(),
+                    );
+                }
+            }
+
+            // Damage the entire window
+            window.wl_surface().damage_buffer(0, 0, self.width as i32, self.height as i32);
+
+            // Request our next frame
+            window.wl_surface().frame(qh, window.wl_surface().clone());
+
+            // Attach and commit to present.
+            buffer.attach_to(window.wl_surface()).expect("buffer attach");
+            window.wl_surface().commit();
+        }
+    }
+}
+
+delegate_compositor!(SimpleWindow);
+delegate_output!(SimpleWindow);
+delegate_shm!(SimpleWindow);
+
+delegate_seat!(SimpleWindow);
+delegate_pointer!(SimpleWindow);
+delegate_tablet!(SimpleWindow);
+
+delegate_xdg_shell!(SimpleWindow);
+delegate_xdg_window!(SimpleWindow);
+
+delegate_registry!(SimpleWindow);
+
+impl ProvidesRegistryState for SimpleWindow {
+    fn registry(&mut self) -> &mut RegistryState {
+        &mut self.registry_state
+    }
+    registry_handlers![OutputState, SeatState,];
+}
+
+impl Dispatch<wl_region::WlRegion, ()> for SimpleWindow {
+    fn event(
+        _: &mut Self,
+        _: &wl_region::WlRegion,
+        _: wl_region::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<SimpleWindow>,
+    ) {
+    }
+}
diff --git a/src/seat/mod.rs b/src/seat/mod.rs
index ecdbcc443..1b5dfd25d 100644
--- a/src/seat/mod.rs
+++ b/src/seat/mod.rs
@@ -25,6 +25,7 @@ pub mod pointer;
 pub mod pointer_constraints;
 pub mod relative_pointer;
 pub mod touch;
+pub mod tablet;
 
 use pointer::cursor_shape::CursorShapeManager;
 use pointer::{PointerData, PointerDataExt, PointerHandler, ThemeSpec, ThemedPointer, Themes};
diff --git a/src/seat/tablet/manager.rs b/src/seat/tablet/manager.rs
new file mode 100644
index 000000000..30c7577c1
--- /dev/null
+++ b/src/seat/tablet/manager.rs
@@ -0,0 +1,62 @@
+use wayland_client::{
+    globals::GlobalList,
+    protocol::wl_seat::WlSeat,
+    Connection,
+    Dispatch,
+    QueueHandle,
+};
+
+use wayland_protocols::wp::tablet::zv2::client::{
+    zwp_tablet_manager_v2::{self, ZwpTabletManagerV2},
+    zwp_tablet_seat_v2::ZwpTabletSeatV2,
+};
+
+use crate::{error::GlobalError, globals::GlobalData, registry::GlobalProxy};
+use super::seat::TabletSeatData;
+
+#[derive(Debug)]
+pub struct TabletState {
+    tablet_manager: GlobalProxy<ZwpTabletManagerV2>,
+}
+
+impl TabletState {
+    /// Bind `zwp_tablet_manager_v2` global, if it exists
+    pub fn bind<D>(globals: &GlobalList, qh: &QueueHandle<D>) -> Self
+    where
+        D: Dispatch<ZwpTabletManagerV2, GlobalData> + 'static,
+    {
+        Self {
+            tablet_manager: GlobalProxy::from(globals.bind(qh, 1..=1, GlobalData)),
+        }
+    }
+
+    pub fn get_tablet_seat<D>(
+        &self,
+        seat: &WlSeat,
+        qh: &QueueHandle<D>,
+    ) -> Result<ZwpTabletSeatV2, GlobalError>
+    where
+        D: Dispatch<ZwpTabletSeatV2, TabletSeatData> + 'static,
+    {
+        let udata = TabletSeatData { wl_seat: seat.clone() };
+        Ok(self.tablet_manager.get()?.get_tablet_seat(seat, qh, udata))
+    }
+}
+
+impl<D> Dispatch<ZwpTabletManagerV2, GlobalData, D>
+    for TabletState
+where
+    D: Dispatch<ZwpTabletManagerV2, GlobalData>,
+    // TODO: which Handler traits, if any, should D be constrained to?
+{
+    fn event(
+        _data: &mut D,
+        _manager: &ZwpTabletManagerV2,
+        _event: zwp_tablet_manager_v2::Event,
+        _: &GlobalData,
+        _conn: &Connection,
+        _qh: &QueueHandle<D>,
+    ) {
+        unreachable!()
+    }
+}
diff --git a/src/seat/tablet/mod.rs b/src/seat/tablet/mod.rs
new file mode 100644
index 000000000..b76927199
--- /dev/null
+++ b/src/seat/tablet/mod.rs
@@ -0,0 +1,62 @@
+// zwp_tablet_manager_v2
+mod manager;
+pub use manager::TabletState;
+
+// zwp_tablet_seat_v2
+mod seat;
+pub use seat::{TabletSeatHandler, TabletSeatData};
+
+// zwp_tablet_v2
+mod tablet;
+pub use tablet::{TabletEvent, TabletHandler, TabletData, TabletEventList};
+
+// zwp_tablet_tool_v2
+mod tool;
+pub use tool::{
+    TabletToolInitEvent,
+    TabletToolInitEventList,
+    ToolCapability, ToolType,
+    TabletToolEventFrame, TabletToolEvent, TabletToolEventList,
+    TabletToolHandler,
+    TabletToolData,
+};
+
+// zwp_tablet_pad_v2
+//pub use seat::{TabletPadData, TabletPadHandler};
+mod pad;
+pub use pad::{
+    TabletPadData,
+    TabletPadGroupData,
+    TabletPadRingData,
+    TabletPadStripData,
+};
+
+#[macro_export]
+macro_rules! delegate_tablet {
+    ($(@<$( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+>)? $ty: ty) => {
+        $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_manager_v2::ZwpTabletManagerV2: $crate::globals::GlobalData
+        ] => $crate::seat::tablet::TabletState);
+        $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_seat_v2::ZwpTabletSeatV2: $crate::seat::tablet::TabletSeatData
+        ] => $crate::seat::tablet::TabletState);
+        $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_v2::ZwpTabletV2: $crate::seat::tablet::TabletData
+        ] => $crate::seat::tablet::TabletState);
+        $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_tool_v2::ZwpTabletToolV2: $crate::seat::tablet::TabletToolData
+        ] => $crate::seat::tablet::TabletState);
+        $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_v2::ZwpTabletPadV2: $crate::seat::tablet::TabletPadData
+        ] => $crate::seat::tablet::TabletState);
+        $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_group_v2::ZwpTabletPadGroupV2: $crate::seat::tablet::TabletPadGroupData
+        ] => $crate::seat::tablet::TabletState);
+        $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_ring_v2::ZwpTabletPadRingV2: $crate::seat::tablet::TabletPadRingData
+        ] => $crate::seat::tablet::TabletState);
+        $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_strip_v2::ZwpTabletPadStripV2: $crate::seat::tablet::TabletPadStripData
+        ] => $crate::seat::tablet::TabletState);
+    };
+}
diff --git a/src/seat/tablet/pad.rs b/src/seat/tablet/pad.rs
new file mode 100644
index 000000000..dde8179e5
--- /dev/null
+++ b/src/seat/tablet/pad.rs
@@ -0,0 +1,167 @@
+#![allow(unused_variables)]
+
+// TODO, stub, just enough so it doesn’t crash if a pad is added (hopefully).
+// I, Chris Morgan, hooked all the rest of this stuff up,
+// but I don’t have a pad, and don’t see any good dummy device for testing,
+// and I won’t benefit from this stuff myself anyway.
+// It should be straightforward to implement, but there’s a fair bit of surface area.
+// Sorry if you wanted it now.
+// Offer to buy me a suitable device, and I’ll be interested.
+
+use wayland_client::{
+    event_created_child,
+    Connection,
+    Dispatch,
+    QueueHandle,
+};
+use wayland_protocols::wp::tablet::zv2::client::{
+    // TODO: zwp_tablet_pad_ring_v2, zwp_tablet_pad_strip_v2, zwp_tablet_pad_group_v2.
+    zwp_tablet_pad_ring_v2::{self, ZwpTabletPadRingV2},
+    zwp_tablet_pad_strip_v2::{self, ZwpTabletPadStripV2},
+    zwp_tablet_pad_group_v2::{self, ZwpTabletPadGroupV2, EVT_STRIP_OPCODE, EVT_RING_OPCODE},
+    zwp_tablet_pad_v2::{self, ZwpTabletPadV2, EVT_GROUP_OPCODE},
+};
+use super::TabletState;
+
+#[doc(hidden)]
+#[derive(Debug)]
+pub struct TabletPadData;
+
+impl TabletPadData {
+    pub fn new() -> TabletPadData { TabletPadData }
+}
+
+// zwp_tablet_pad_v2
+// Request: set_feedback
+// Request: destroy
+// Event: group
+// Event: path
+// Event: buttons
+// Event: done
+// Event: button
+// Event: enter
+// Event: leave
+// Event: removed
+// Enum: button_state
+
+impl<D> Dispatch<ZwpTabletPadV2, TabletPadData, D>
+    for TabletState
+where
+    D: Dispatch<ZwpTabletPadV2, TabletPadData>
+     + Dispatch<ZwpTabletPadGroupV2, TabletPadGroupData>
+     //+ TabletPadHandler
+     + 'static,
+{
+    event_created_child!(D, ZwpTabletPadV2, [
+        EVT_GROUP_OPCODE => (ZwpTabletPadGroupV2, TabletPadGroupData),
+    ]);
+
+    fn event(
+        data: &mut D,
+        pad: &ZwpTabletPadV2,
+        event: zwp_tablet_pad_v2::Event,
+        udata: &TabletPadData,
+        conn: &Connection,
+        qh: &QueueHandle<D>,
+    ) {
+        log::warn!(target: "sctk", "got tablet pad event, unimplemented");
+    }
+}
+
+impl<D> Dispatch<ZwpTabletPadGroupV2, TabletPadGroupData, D>
+    for TabletState
+where
+    D: Dispatch<ZwpTabletPadGroupV2, TabletPadGroupData>
+     + Dispatch<ZwpTabletPadRingV2, TabletPadRingData>
+     + Dispatch<ZwpTabletPadStripV2, TabletPadStripData>
+     //+ TabletPadGroupHandler
+     + 'static,
+{
+    event_created_child!(D, ZwpTabletPadV2, [
+        EVT_RING_OPCODE => (ZwpTabletPadRingV2, TabletPadRingData),
+        EVT_STRIP_OPCODE => (ZwpTabletPadStripV2, TabletPadStripData),
+    ]);
+
+    fn event(
+        data: &mut D,
+        group: &ZwpTabletPadGroupV2,
+        event: zwp_tablet_pad_group_v2::Event,
+        udata: &TabletPadGroupData,
+        conn: &Connection,
+        qh: &QueueHandle<D>,
+    ) {
+        log::warn!(target: "sctk", "got tablet pad group event, unimplemented");
+    }
+}
+
+impl<D> Dispatch<ZwpTabletPadRingV2, TabletPadRingData, D>
+    for TabletState
+where
+    D: Dispatch<ZwpTabletPadRingV2, TabletPadRingData>
+     //+ TabletPadRingHandler,
+{
+    fn event(
+        data: &mut D,
+        ring: &ZwpTabletPadRingV2,
+        event: zwp_tablet_pad_ring_v2::Event,
+        udata: &TabletPadRingData,
+        conn: &Connection,
+        qh: &QueueHandle<D>,
+    ) {
+        log::warn!(target: "sctk", "got tablet pad ring event, unimplemented");
+    }
+}
+
+impl<D> Dispatch<ZwpTabletPadStripV2, TabletPadStripData, D>
+    for TabletState
+where
+    D: Dispatch<ZwpTabletPadStripV2, TabletPadStripData>
+     //+ TabletPadStripHandler,
+{
+    fn event(
+        data: &mut D,
+        strip: &ZwpTabletPadStripV2,
+        event: zwp_tablet_pad_strip_v2::Event,
+        udata: &TabletPadStripData,
+        conn: &Connection,
+        qh: &QueueHandle<D>,
+    ) {
+        log::warn!(target: "sctk", "got tablet pad strip event, unimplemented");
+    }
+}
+
+// zwp_tablet_pad_group_v2
+// Request: destroy
+// Event: buttons
+// Event: ring
+// Event: strip
+// Event: modes
+// Event: done
+// Event: mode_switch
+#[doc(hidden)]
+#[derive(Debug)]
+pub struct TabletPadGroupData;
+
+// zwp_tablet_pad_ring_v2
+// Request: set_feedback
+// Request: destroy
+// Event: source
+// Event: angle
+// Event: stop
+// Event: frame
+// Enum: source
+#[doc(hidden)]
+#[derive(Debug)]
+pub struct TabletPadRingData;
+
+// zwp_tablet_pad_strip_v2
+// Request: set_feedback
+// Request: destroy
+// Event: source
+// Event: position
+// Event: stop
+// Event: frame
+// Enum: source
+#[doc(hidden)]
+#[derive(Debug)]
+pub struct TabletPadStripData;
diff --git a/src/seat/tablet/seat.rs b/src/seat/tablet/seat.rs
new file mode 100644
index 000000000..81289b170
--- /dev/null
+++ b/src/seat/tablet/seat.rs
@@ -0,0 +1,91 @@
+use wayland_client::{
+    event_created_child,
+    protocol::wl_seat::WlSeat,
+    Connection,
+    Dispatch,
+    QueueHandle,
+};
+use wayland_protocols::wp::tablet::zv2::client::{
+    zwp_tablet_seat_v2::{self, ZwpTabletSeatV2, EVT_TABLET_ADDED_OPCODE, EVT_TOOL_ADDED_OPCODE, EVT_PAD_ADDED_OPCODE},
+    zwp_tablet_tool_v2::ZwpTabletToolV2,
+    zwp_tablet_v2::ZwpTabletV2,
+    zwp_tablet_pad_v2::ZwpTabletPadV2,
+};
+
+use super::{TabletState, TabletData, TabletToolData, TabletPadData};
+
+pub trait TabletSeatHandler: Sized {
+    fn tablet_added(
+        &mut self,
+        conn: &Connection,
+        qh: &QueueHandle<Self>,
+        tablet_seat: &ZwpTabletSeatV2,
+        seat: &WlSeat,
+        id: ZwpTabletV2,
+    );
+    fn tool_added(
+        &mut self,
+        conn: &Connection,
+        qh: &QueueHandle<Self>,
+        tablet_seat: &ZwpTabletSeatV2,
+        seat: &WlSeat,
+        id: ZwpTabletToolV2,
+    );
+    ///// TODO; non-functional stub, just so it doesn’t crash if a pad is present (I hope?).
+    ///// Nothing more is hooked up for pads.
+    //fn pad_added(
+    //    &mut self,
+    //    conn: &Connection,
+    //    qh: &QueueHandle<Self>,
+    //    tablet_seat: &ZwpTabletSeatV2,
+    //    seat: &WlSeat,
+    //    id: ZwpTabletPadV2,
+    //);
+}
+
+#[doc(hidden)]
+#[derive(Debug)]
+pub struct TabletSeatData {
+    pub(crate) wl_seat: WlSeat,
+}
+
+impl<D> Dispatch<ZwpTabletSeatV2, TabletSeatData, D>
+    for TabletState
+where
+    D: Dispatch<ZwpTabletSeatV2, TabletSeatData>
+     + Dispatch<ZwpTabletV2, TabletData>
+     + Dispatch<ZwpTabletToolV2, TabletToolData>
+     + Dispatch<ZwpTabletPadV2, TabletPadData>
+     + TabletSeatHandler
+     + 'static,
+{
+    event_created_child!(D, ZwpTabletSeatV2, [
+        EVT_TABLET_ADDED_OPCODE => (ZwpTabletV2, TabletData::new()),
+        EVT_TOOL_ADDED_OPCODE => (ZwpTabletToolV2, TabletToolData::new()),
+        EVT_PAD_ADDED_OPCODE => (ZwpTabletPadV2, TabletPadData::new()),
+    ]);
+
+    fn event(
+        data: &mut D,
+        tablet_seat: &ZwpTabletSeatV2,
+        event: zwp_tablet_seat_v2::Event,
+        udata: &TabletSeatData,
+        conn: &Connection,
+        qh: &QueueHandle<D>,
+    ) {
+        match event {
+            zwp_tablet_seat_v2::Event::TabletAdded { id } => {
+                data.tablet_added(conn, qh, tablet_seat, &udata.wl_seat, id);
+            },
+            zwp_tablet_seat_v2::Event::ToolAdded { id } => {
+                data.tool_added(conn, qh, tablet_seat, &udata.wl_seat, id);
+            },
+            zwp_tablet_seat_v2::Event::PadAdded { id } => {
+                log::warn!(target: "sctk", "zwp_tablet_seat_v2.pad_added: unimplemented");
+                id.destroy();
+                //data.pad_added(conn, qh, tablet_seat, &udata.wl_seat, id);
+            },
+            _ => unreachable!(),
+        }
+    }
+}
diff --git a/src/seat/tablet/tablet.rs b/src/seat/tablet/tablet.rs
new file mode 100644
index 000000000..9d310d2b7
--- /dev/null
+++ b/src/seat/tablet/tablet.rs
@@ -0,0 +1,110 @@
+use std::mem;
+use std::sync::Mutex;
+
+use wayland_backend::smallvec::SmallVec;
+use wayland_client::{
+    Connection,
+    Dispatch,
+    QueueHandle,
+};
+use wayland_protocols::wp::tablet::zv2::client::zwp_tablet_v2::{self, ZwpTabletV2};
+
+use super::TabletState;
+
+#[derive(Debug)]
+pub enum TabletEvent {
+    /// The descriptive name of the tablet device
+    Name {
+        name: String,
+    },
+    /// The USB vendor and product IDs for the tablet device
+    Id {
+        vid: u32,
+        pid: u32,
+    },
+    /// System-specific device paths for the tablet.
+    ///
+    /// Path format is unspecified. Clients must figure out what to do with them, if they care.
+    Path {
+        path: String,
+    },
+}
+
+pub trait TabletHandler: Sized {
+    /// This is fired at the time of the `zwp_tablet_v2.done` event,
+    /// and coalesces any `name`, `id` and `path` events that precede it.
+    fn init_done(
+        &mut self,
+        conn: &Connection,
+        qh: &QueueHandle<Self>,
+        tablet: &ZwpTabletV2,
+        events: TabletEventList,
+    );
+
+    /// Sent when the tablet has been removed from the system.
+    /// When a tablet is removed, some tools may be removed.
+    ///
+    /// This method is responsible for running `tablet.destroy()`.  ← TODO: true or not?
+    fn removed(
+        &mut self,
+        conn: &Connection,
+        qh: &QueueHandle<Self>,
+        tablet: &ZwpTabletV2,
+    );
+}
+
+#[doc(hidden)]
+#[derive(Debug)]
+pub struct TabletData {
+    //seat: WlSeat,
+    //tablet_seat: ZwpTabletSeatV2,
+    inner: Mutex<TabletDataInner>,
+}
+
+impl TabletData {
+    pub fn new() -> Self {
+        Self { inner: Default::default() }
+    }
+}
+
+// This will typically reach 3 events: name, id, path;
+// but it could be as few as zero for an unnamed virtual device,
+// and it could be more for something with multiple paths.
+pub type TabletEventList = SmallVec<[TabletEvent; 3]>;
+
+#[derive(Debug, Default)]
+struct TabletDataInner {
+    /// List of pending events.
+    pending: TabletEventList,
+}
+
+impl<D> Dispatch<ZwpTabletV2, TabletData, D>
+    for TabletState
+where
+    D: Dispatch<ZwpTabletV2, TabletData> + TabletHandler,
+{
+    fn event(
+        data: &mut D,
+        tablet: &ZwpTabletV2,
+        event: zwp_tablet_v2::Event,
+        udata: &TabletData,
+        conn: &Connection,
+        qh: &QueueHandle<D>,
+    ) {
+        let mut guard = udata.inner.lock().unwrap();
+        match event {
+            zwp_tablet_v2::Event::Name { name } => guard.pending.push(TabletEvent::Name { name }),
+            zwp_tablet_v2::Event::Id { vid, pid } => guard.pending.push(TabletEvent::Id { vid, pid }),
+            zwp_tablet_v2::Event::Path { path } => guard.pending.push(TabletEvent::Path { path }),
+            zwp_tablet_v2::Event::Done => {
+                let pending = mem::take(&mut guard.pending);
+                drop(guard);
+                data.init_done(conn, qh, tablet, pending);
+            },
+            zwp_tablet_v2::Event::Removed => {
+                data.removed(conn, qh, tablet);
+            },
+            _ => unreachable!(),
+        }
+    }
+}
diff --git a/src/seat/tablet/tool.rs b/src/seat/tablet/tool.rs
new file mode 100644
index 000000000..a0c1db2ca
--- /dev/null
+++ b/src/seat/tablet/tool.rs
@@ -0,0 +1,376 @@
+use std::mem;
+use std::sync::Mutex;
+
+use wayland_backend::smallvec::SmallVec;
+use wayland_client::{
+    protocol::wl_surface::WlSurface,
+    Connection,
+    Dispatch,
+    QueueHandle,
+    Proxy,
+    WEnum,
+};
+use wayland_protocols::wp::tablet::zv2::client::{
+    zwp_tablet_tool_v2::{self, ZwpTabletToolV2},
+    zwp_tablet_v2::ZwpTabletV2,
+    // TODO: zwp_tablet_pad_ring_v2, zwp_tablet_pad_strip_v2, zwp_tablet_pad_group_v2.
+    //zwp_tablet_pad_v2::{self, ZwpTabletPadV2},
+};
+
+use super::TabletState;
+pub use zwp_tablet_tool_v2::{Capability as ToolCapability, Type as ToolType};
+
+#[derive(Debug)]
+pub enum TabletToolInitEvent {
+    Type {
+        tool_type: ToolType,
+    },
+    HardwareSerial {
+        hardware_serial_hi: u32,
+        hardware_serial_lo: u32,
+    },
+    HardwareIdWacom {
+        hardware_id_hi: u32,
+        hardware_id_lo: u32,
+    },
+    Capability {
+        capability: ToolCapability,
+    },
+}
+
+#[derive(Debug)]
+pub struct TabletToolEventFrame {
+    /// The time of the event with millisecond granularity
+    pub time: u32,
+    /// All the state changes that have occurred since the previous frame
+    pub events: TabletToolEventList,
+}
+
+#[derive(Debug)]
+pub enum TabletToolEvent {
+    /// Notification that this tool is focused on a certain surface.
+    ///
+    /// This event can be received when the tool has moved from one surface to another,
+    /// or when the tool has come back into proximity above the surface.
+    ///
+    /// If any button is logically down when the tool comes into proximity,
+    /// the respective `Button` event is sent after the `ProximityIn` event but within the same frame.
+    ProximityIn {
+        serial: u32,
+        tablet: ZwpTabletV2,
+        surface: WlSurface,
+    },
+
+    /// Notification that this tool has either left proximity,
+    /// or is no longer focused on a certain surface.
+    ///
+    /// When the tablet tool leaves proximity of the tablet,
+    /// button release events are sent for each button that was held down at the time of leaving proximity.
+    /// These events are sent before the `ProximityOut` event but within the same frame.
+    ///
+    /// If the tool stays within proximity of the tablet,
+    /// but the focus changes from one surface to another,
+    /// a button release event may not be sent until the button is actually released or the tool leaves the proximity of the tablet.
+    ProximityOut,
+
+    /// Sent whenever the tablet tool comes in contact with the surface of the tablet.
+    ///
+    /// If the tool is already in contact with the tablet when entering the input region,
+    /// the client owning said region will receive a `ProximityIn` event,
+    /// followed by a `Down` event in the same frame.
+    ///
+    /// Note that this event describes logical contact, not physical contact.
+    /// On some devices, a compositor may not consider a tool in logical contact until a minimum physical pressure threshold is exceeded.
+    Down {
+        serial: u32,
+    },
+
+    /// Sent whenever the tablet tool stops making contact with the surface of the tablet,
+    /// or when the tablet tool moves out of the input region and the compositor grab (if any) is dismissed.
+    ///
+    /// If the tablet tool moves out of the input region while in contact with the surface of the tablet and the compositor does not have an ongoing grab on the surface,
+    /// the client owning said region will receive an `Up` event,
+    /// followed by a `ProximityOut` event in the same frame.
+    /// If the compositor has an ongoing grab on this device,
+    /// this event sequence is sent whenever the grab is dismissed in the future.
+    ///
+    /// Note that this event describes logical contact, not physical contact.
+    /// On some devices, a compositor may not consider a tool out of logical contact until physical pressure falls below a specific threshold.
+    Up,
+
+    /// Sent whenever a tablet tool moves.
+    Motion {
+        x: f64,
+        y: f64,
+    },
+
+    /// Sent whenever the pressure axis on a tool changes.
+    /// The value of this event is normalized to a value between 0 and 65535.
+    ///
+    /// Note that pressure may be nonzero even when a tool is not in logical contact.
+    /// See the Down and Up events for more details.
+    Pressure {
+        pressure: u16,
+    },
+
+    /// Sent whenever the distance axis on a tool changes.
+    /// The value of this event is normalized to a value between 0 and 65535.
+    ///
+    /// Note that distance may be nonzero even when a tool is not in logical contact.
+    /// See the Down and Up events for more details.
+    Distance {
+        distance: u16,
+    },
+
+    /// Sent whenever one or both of the tilt axes on a tool change.
+    /// Each tilt value is in degrees, relative to the z-axis of the tablet.
+    /// The angle is positive when the top of a tool tilts along the positive x or y axis.
+    Tilt {
+        tilt_x: f64,
+        tilt_y: f64,
+    },
+
+    /// Sent whenever the z-rotation axis on the tool changes.
+    /// The rotation value is in degrees clockwise from the tool's logical neutral position.
+    Rotation {
+        degrees: f64,
+    },
+
+    /// Sent whenever the slider position on the tool changes.
+    /// The value is normalized between -65535 and 65535,
+    /// with 0 as the logical neutral position of the slider.
+    Slider {
+        position: i32,
+    },
+
+    /// Sent whenever the wheel on the tool emits an event.
+    /// This event contains two values for the same axis change.
+    ///
+    /// Clients should choose either value and avoid mixing degrees and clicks.
+    /// The compositor may accumulate values smaller than a logical click and emulate click events when a certain threshold is met.
+    /// Thus, wheel events with non-zero `clicks` values may have different `degrees` values.
+    Wheel {
+        /// The wheel delta in degrees.
+        ///
+        /// This value is in the same orientation as the `wl_pointer.vertical_scroll` axis.
+        degrees: f64,
+        /// The wheel delta in discrete clicks.
+        ///
+        /// This value is in discrete logical clicks of the mouse wheel,
+        /// and may be zero if the movement of the wheel was less than one logical click.
+        clicks: i32,
+    },
+
+    /// Sent whenever a button on the tool is pressed or released.
+    ///
+    /// If a button is held down when the tool moves in or out of proximity,
+    /// button events are generated by the compositor.
+    /// See `ProximityIn` and `ProximityOut` for details.
+    Button {
+        serial: u32,
+        /// The button whose state has changed
+        button: u32,
+        /// Whether the button was pressed (`true`) or released (`false`)
+        pressed: bool,
+    },
+}
+
+pub trait TabletToolHandler: Sized {
+    /// This is fired at the time of the `zwp_tablet_tool_v2.done` event,
+    /// and coalesces any `type`, `hardware_serial`, `hardware_serial_wacom` and `capability` events that precede it.
+    fn init_done(
+        &mut self,
+        conn: &Connection,
+        qh: &QueueHandle<Self>,
+        tablet: &ZwpTabletToolV2,
+        events: TabletToolInitEventList,
+    );
+
+    /// Sent when the tablet has been removed from the system.
+    /// When a tablet is removed, some tools may be removed.
+    ///
+    /// This method is responsible for running `tablet.destroy()`.
+    fn removed(
+        &mut self,
+        conn: &Connection,
+        qh: &QueueHandle<Self>,
+        tablet: &ZwpTabletToolV2,
+    );
+
+    /// A series of axis and/or button updates have been received from the tablet.
+    /// All the events within this frame should be considered one hardware event.
+    fn tablet_tool_frame(
+        &mut self,
+        conn: &Connection,
+        qh: &QueueHandle<Self>,
+        tablet: &ZwpTabletToolV2,
+        frame: TabletToolEventFrame,
+    );
+}
+
+#[doc(hidden)]
+#[derive(Debug)]
+pub struct TabletToolData {
+    //seat: WlSeat,
+    //tablet_seat: ZwpTabletToolSeatV2,
+    inner: Mutex<TabletToolDataInner>,
+}
+
+impl TabletToolData {
+    pub fn new() -> Self {
+        Self { inner: Default::default() }
+    }
+}
+
+pub type TabletToolInitEventList = Vec<TabletToolInitEvent>;
+pub type TabletToolEventList = SmallVec<[TabletToolEvent; 3]>;
+
+#[derive(Debug, Default)]
+struct TabletToolDataInner {
+    /// List of pending init-time events, flushed when a `done` event comes in,
+    /// after which it will be perpetually empty.
+    pending_init: TabletToolInitEventList,
+
+    /// List of pending events, flushed when a `frame` event comes in.
+    pending_frame: TabletToolEventList,
+}
+
+impl<D> Dispatch<ZwpTabletToolV2, TabletToolData, D>
+    for TabletState
+where
+    D: Dispatch<ZwpTabletToolV2, TabletToolData> + TabletToolHandler,
+{
+    fn event(
+        data: &mut D,
+        tool: &ZwpTabletToolV2,
+        event: zwp_tablet_tool_v2::Event,
+        udata: &TabletToolData,
+        conn: &Connection,
+        qh: &QueueHandle<D>,
+    ) {
+        let mut guard = udata.inner.lock().unwrap();
+        match event {
+
+            // Initial burst of static description events
+            // (one Type,
+            // zero or one HardwareSerial,
+            // zero or one HardwareIdWacom,
+            // zero or more Capability,
+            // then finished with Done).
+
+            zwp_tablet_tool_v2::Event::Type { tool_type } => {
+                guard.pending_init.push(TabletToolInitEvent::Type {
+                    tool_type: match tool_type {
+                        WEnum::Value(tool_type) => tool_type,
+                        WEnum::Unknown(unknown) => {
+                            log::warn!(target: "sctk", "{}: invalid tablet tool type: {:x}", tool.id(), unknown);
+                            return;
+                        },
+                    },
+                });
+            },
+            zwp_tablet_tool_v2::Event::HardwareSerial { hardware_serial_hi, hardware_serial_lo } => {
+                guard.pending_init.push(TabletToolInitEvent::HardwareSerial { hardware_serial_hi, hardware_serial_lo });
+            },
+            zwp_tablet_tool_v2::Event::HardwareIdWacom { hardware_id_hi, hardware_id_lo } => {
+                guard.pending_init.push(TabletToolInitEvent::HardwareIdWacom { hardware_id_hi, hardware_id_lo });
+            },
+            zwp_tablet_tool_v2::Event::Capability { capability } => {
+                guard.pending_init.push(TabletToolInitEvent::Capability {
+                    capability: match capability {
+                        WEnum::Value(capability) => capability,
+                        WEnum::Unknown(unknown) => {
+                            log::warn!(target: "sctk", "{}: invalid tablet tool capability: {:x}", tool.id(), unknown);
+                            return;
+                        },
+                    },
+                });
+            },
+            zwp_tablet_tool_v2::Event::Done => {
+                let events = mem::take(&mut guard.pending_init);
+                drop(guard);
+                data.init_done(conn, qh, tool, events);
+            },
+
+            // Destruction
+
+            zwp_tablet_tool_v2::Event::Removed => {
+                data.removed(conn, qh, tool);
+            },
+
+            // Burst of frame data events
+            // (one or more of ProximityIn, ProximityOut, Down, Up, Motion,
+            // Pressure, Distance, Tilt, Rotation, Slider, Wheel, Button,
+            // with some restrictions on ordering and such;
+            // then finished with Frame).
+
+            zwp_tablet_tool_v2::Event::ProximityIn { serial, tablet, surface } => {
+                guard.pending_frame.push(TabletToolEvent::ProximityIn { serial, tablet, surface });
+            },
+            zwp_tablet_tool_v2::Event::ProximityOut => {
+                guard.pending_frame.push(TabletToolEvent::ProximityOut);
+            },
+            zwp_tablet_tool_v2::Event::Down { serial } => {
+                guard.pending_frame.push(TabletToolEvent::Down { serial });
+            },
+            zwp_tablet_tool_v2::Event::Up => {
+                guard.pending_frame.push(TabletToolEvent::Up);
+            },
+            zwp_tablet_tool_v2::Event::Motion { x, y } => {
+                guard.pending_frame.push(TabletToolEvent::Motion { x, y });
+            },
+            zwp_tablet_tool_v2::Event::Pressure { pressure } => {
+                // “The value of this event is normalized to a value between 0 and 65535.”
+                // But the wayland Wire format only supports 32-bit integers, so we cast it.
+                // <https://wayland.freedesktop.org/docs/html/ch04.html#:~:text=xml.-,Wire%20Format>.
+                guard.pending_frame.push(TabletToolEvent::Pressure { pressure: pressure as u16 });
+            },
+            zwp_tablet_tool_v2::Event::Distance { distance } => {
+                // Same deal, “normalized to a value between 0 and 65535”.
+                guard.pending_frame.push(TabletToolEvent::Distance { distance: distance as u16 });
+            },
+            zwp_tablet_tool_v2::Event::Tilt { tilt_x, tilt_y } => {
+                guard.pending_frame.push(TabletToolEvent::Tilt { tilt_x, tilt_y });
+            },
+            zwp_tablet_tool_v2::Event::Rotation { degrees } => {
+                guard.pending_frame.push(TabletToolEvent::Rotation { degrees });
+            },
+            zwp_tablet_tool_v2::Event::Slider { position } => {
+                // This one is “normalized between -65535 and 65535”, 17 bits, so it stays i32.
+                guard.pending_frame.push(TabletToolEvent::Slider { position });
+            },
+            zwp_tablet_tool_v2::Event::Wheel { degrees, clicks } => {
+                guard.pending_frame.push(TabletToolEvent::Wheel { degrees, clicks });
+            },
+            zwp_tablet_tool_v2::Event::Button { serial, button, state } => {
+                guard.pending_frame.push(TabletToolEvent::Button {
+                    serial,
+                    button,
+                    pressed: match state {
+                        WEnum::Value(zwp_tablet_tool_v2::ButtonState::Pressed) => true,
+                        WEnum::Value(zwp_tablet_tool_v2::ButtonState::Released) => false,
+                        WEnum::Value(_) => unreachable!(),
+                        WEnum::Unknown(unknown) => {
+                            log::warn!(target: "sctk", "{}: invalid tablet tool button state: {:x}", tool.id(), unknown);
+                            return;
+                        },
+                    },
+                });
+            },
+            zwp_tablet_tool_v2::Event::Frame { time } => {
+                // TODO: pass ownership of the events list.
+                // I was copying what something else did around here,
+                // but since we don’t do anything more with them,
+                // it would be better to cede ownership.
+                // The only issue is that it exposes SmallVec what is nicer an implementation type.
+                let events = mem::take(&mut guard.pending_frame);
+                drop(guard);
+                data.tablet_tool_frame(conn, qh, tool, TabletToolEventFrame {
+                    time,
+                    events,
+                });
+            },
+            _ => unreachable!(),
+        }
+    }
+}

From eb83d743b7dc25b0292b916ef76a389bdaad795f Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Tue, 18 Mar 2025 17:18:19 +0530
Subject: [PATCH 02/27] [WIP] Expand the tablet example for pseudo-drawing
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

I want something *like* this,
partly because it’s a more interesting demo for tablets,
and partly because I want something showing overdrawing.

The implementation is terrible in various ways that I know,
and probably terrible in various ways that I don’t yet know.
But it works… mostly. And it *normally* doesn’t segfault.
I’m just committing it to get *something* out there for now,
not because it’s finished.

Pretty sure I’m going to ditch the mode stuff and put at least the
tablet tool info, state and circle thing into a cursor.
That’s cool.
---
 examples/tablet.rs | 452 ++++++++++++++++++++++++++++++++++-----------
 1 file changed, 349 insertions(+), 103 deletions(-)

diff --git a/examples/tablet.rs b/examples/tablet.rs
index a8a16b805..818cd2d30 100644
--- a/examples/tablet.rs
+++ b/examples/tablet.rs
@@ -4,14 +4,14 @@ use std::collections::{HashSet, HashMap};
 
 use smithay_client_toolkit::{
     compositor::{CompositorHandler, CompositorState},
-    delegate_compositor, delegate_output, delegate_pointer,
+    delegate_compositor, delegate_output, delegate_keyboard,
     delegate_registry, delegate_tablet, delegate_seat, delegate_shm, delegate_xdg_shell,
     delegate_xdg_window,
     output::{OutputHandler, OutputState},
     registry::{ProvidesRegistryState, RegistryState},
     registry_handlers,
     seat::{
-        pointer::{PointerEvent, PointerEventKind, PointerHandler},
+        keyboard::{KeyEvent, KeyboardHandler, Keysym, Modifiers, RawModifiers},
         tablet::{
             ToolType,
             ToolCapability,
@@ -31,11 +31,11 @@ use smithay_client_toolkit::{
         },
         WaylandSurface,
     },
-    shm::{slot::SlotPool, Shm, ShmHandler},
+    shm::{slot::{SlotPool, Buffer}, Shm, ShmHandler},
 };
 use wayland_client::{
     globals::registry_queue_init,
-    protocol::{wl_output, wl_pointer, wl_region, wl_seat, wl_shm, wl_surface},
+    protocol::{wl_output, wl_keyboard, wl_region, wl_seat, wl_shm, wl_surface},
     Connection, Dispatch, QueueHandle,
     Proxy,
 };
@@ -75,39 +75,50 @@ fn main() {
         .load()
         .unwrap();
 
+    let compositor_state = CompositorState::bind(&globals, &qh)
+                    .expect("wl_compositor not available");
+    let shm_state = Shm::bind(&globals, &qh).expect("wl_shm not available");
+    let xdg_shell_state = XdgShell::bind(&globals, &qh).expect("xdg shell not available");
+
+    let surface = compositor_state.create_surface(&qh);
+
+    let window = xdg_shell_state.create_window(surface, WindowDecorations::ServerDefault, &qh);
+
+    window.set_title("A wayland window");
+    window.set_app_id("io.github.smithay.client-toolkit.Tablet");
+    window.set_min_size(Some((256, 256)));
+
+    window.commit();
+
+    let width = 256;
+    let height = 256;
+    // Initial size, but it grows automatically as needed.
+    let pool = SlotPool::new(width as usize * height as usize * 4, &shm_state)
+        .expect("Failed to create pool");
+
     let mut simple_window = SimpleWindow {
         registry_state: RegistryState::new(&globals),
         seat_state: SeatState::new(&globals, &qh),
         output_state: OutputState::new(&globals, &qh),
-        compositor_state: CompositorState::bind(&globals, &qh)
-            .expect("wl_compositor not available"),
-        shm_state: Shm::bind(&globals, &qh).expect("wl_shm not available"),
-        xdg_shell_state: XdgShell::bind(&globals, &qh).expect("xdg shell not available"),
+        compositor_state,
+        shm_state,
+        xdg_shell_state,
         tablet_state: TabletState::bind(&globals, &qh),
 
         exit: false,
-        width: 256,
-        height: 256,
-        window: None,
+        width,
+        height,
+        window,
+        keyboard: None,
+        keyboard_focus: false,
         tablet_seat: None,
         tablets: HashMap::new(),
         tools: HashMap::new(),
+        pool,
+        mode: Mode::Points,
         font,
     };
 
-    let surface = simple_window.compositor_state.create_surface(&qh);
-
-    let window =
-        simple_window.xdg_shell_state.create_window(surface, WindowDecorations::ServerDefault, &qh);
-
-    window.set_title("A wayland window");
-    window.set_app_id("io.github.smithay.client-toolkit.Tablet");
-    window.set_min_size(Some((256, 256)));
-
-    window.commit();
-
-    simple_window.window = Some(window);
-
     while !simple_window.exit {
         event_queue.blocking_dispatch(&mut simple_window).unwrap();
     }
@@ -224,11 +235,14 @@ struct SimpleWindow {
     exit: bool,
     width: u32,
     height: u32,
-    window: Option<Window>,
+    window: Window,
+    keyboard: Option<wl_keyboard::WlKeyboard>,
+    keyboard_focus: bool,
     tablet_seat: Option<ZwpTabletSeatV2>,
-
-    tools: HashMap<ZwpTabletToolV2, ToolInfoAndState>,
     tablets: HashMap<ZwpTabletV2, TabletMetadata>,
+    tools: HashMap<ZwpTabletToolV2, ToolInfoAndState>,
+    pool: SlotPool,
+    mode: Mode,
 
     font: font_kit::loaders::freetype::Font,
 }
@@ -330,6 +344,9 @@ impl WindowHandler for SimpleWindow {
     ) {
         self.width = configure.new_size.0.map(|v| v.get()).unwrap_or(256);
         self.height = configure.new_size.1.map(|v| v.get()).unwrap_or(256);
+        if self.mode.is_sketch() {
+            self.reset_sketch_mode();
+        }
         self.draw(conn, qh);
     }
 }
@@ -351,8 +368,21 @@ impl SeatHandler for SimpleWindow {
         _conn: &Connection,
         qh: &QueueHandle<Self>,
         seat: wl_seat::WlSeat,
-        _capability: Capability,
+        capability: Capability,
     ) {
+        if capability == Capability::Keyboard && self.keyboard.is_none() {
+            println!("Set keyboard capability");
+            let keyboard = self
+                .seat_state
+                .get_keyboard(
+                    qh,
+                    &seat,
+                    None,
+                )
+                .expect("Failed to create keyboard");
+
+            self.keyboard = Some(keyboard);
+        }
         if self.tablet_seat.is_none() {
             let tablet_seat = self.tablet_state.get_tablet_seat(&seat, qh).ok();
             if tablet_seat.is_some() {
@@ -378,20 +408,71 @@ impl SeatHandler for SimpleWindow {
     }
 }
 
-impl PointerHandler for SimpleWindow {
-    fn pointer_frame(
+impl KeyboardHandler for SimpleWindow {
+    fn enter(
         &mut self,
-        conn: &Connection,
-        qh: &QueueHandle<Self>,
-        _pointer: &wl_pointer::WlPointer,
-        events: &[PointerEvent],
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        _: &wl_keyboard::WlKeyboard,
+        surface: &wl_surface::WlSurface,
+        _: u32,
+        _: &[u32],
+        _: &[Keysym],
     ) {
-        for event in events {
-            if let PointerEventKind::Release { .. } = event.kind {
-                self.change_constraint(conn, qh);
-            }
+        if self.window.wl_surface() == surface {
+            self.keyboard_focus = true;
+        }
+    }
+
+    fn leave(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        _: &wl_keyboard::WlKeyboard,
+        surface: &wl_surface::WlSurface,
+        _: u32,
+    ) {
+        if self.window.wl_surface() == surface {
+            self.keyboard_focus = false;
         }
     }
+
+    fn press_key(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        _: &wl_keyboard::WlKeyboard,
+        _: u32,
+        event: KeyEvent,
+    ) {
+        match event.keysym {
+            Keysym::n => self.toggle_mode(),
+            Keysym::r if self.mode.is_sketch() => self.reset_sketch_mode(),
+            _ => (),
+        }
+    }
+
+    fn release_key(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        _: &wl_keyboard::WlKeyboard,
+        _: u32,
+        _: KeyEvent,
+    ) {
+    }
+
+    fn update_modifiers(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        _: &wl_keyboard::WlKeyboard,
+        _: u32,
+        _: Modifiers,
+        _: RawModifiers,
+        _: u32,
+    ) {
+    }
 }
 
 impl TabletSeatHandler for SimpleWindow {
@@ -627,93 +708,258 @@ impl ShmHandler for SimpleWindow {
 }
 
 impl SimpleWindow {
-    pub fn draw(&mut self, _conn: &Connection, qh: &QueueHandle<Self>) {
-        if let Some(window) = self.window.as_ref() {
-            let width = self.width;
-            let height = self.height;
-            let stride = self.width as i32 * 4;
-
-            let mut pool = SlotPool::new(width as usize * height as usize * 4, &self.shm_state)
-                .expect("Failed to create pool");
-
-            let buffer = pool
-                .create_buffer(width as i32, height as i32, stride, wl_shm::Format::Xrgb8888)
-                .expect("create buffer")
-                .0;
-
-            let mut dt = raqote::DrawTarget::from_backing(
-                width as i32,
-                height as i32,
-                bytemuck::cast_slice_mut(pool.canvas(&buffer).unwrap()),
+    pub fn draw(&mut self, conn: &Connection, qh: &QueueHandle<Self>) {
+        match self.mode {
+            Mode::Points => self.draw_point(conn, qh),
+            Mode::Sketch { .. } => self.draw_sketch(conn, qh),
+        }
+    }
+
+    pub fn draw_point(&mut self, _conn: &Connection, qh: &QueueHandle<Self>) {
+        let width = self.width;
+        let height = self.height;
+        let stride = self.width as i32 * 4;
+
+        let buffer = self.pool
+            .create_buffer(width as i32, height as i32, stride, wl_shm::Format::Xrgb8888)
+            .expect("create buffer")
+            .0;
+
+        let mut dt = raqote::DrawTarget::from_backing(
+            width as i32,
+            height as i32,
+            bytemuck::cast_slice_mut(self.pool.canvas(&buffer).unwrap()),
+        );
+        dt.clear(WHITE);
+        let mut y = 16.;
+        if self.tablets.is_empty() {
+            dt.draw_text(
+                &self.font,
+                14.,
+                "No tablets found",
+                raqote::Point::new(2., y),
+                &SOLID_RED,
+                &raqote::DrawOptions::new(),
             );
-            dt.clear(WHITE);
-            let mut y = 16.;
-            if self.tablets.is_empty() {
+        } else {
+            for (id, tablet_metadata) in &self.tablets {
+                let text = match &tablet_metadata.name {
+                    Some(name) => name,
+                    None => &*id.id().to_string(),
+                };
                 dt.draw_text(
                     &self.font,
                     14.,
-                    "No tablets found",
+                    text,
                     raqote::Point::new(2., y),
-                    &SOLID_RED,
+                    &SOLID_BLACK,
                     &raqote::DrawOptions::new(),
                 );
-            } else {
-                for (id, tablet_metadata) in &self.tablets {
-                    let text = match &tablet_metadata.name {
-                        Some(name) => name,
-                        None => &*id.id().to_string(),
-                    };
-                    dt.draw_text(
-                        &self.font,
-                        14.,
-                        text,
-                        raqote::Point::new(2., y),
-                        &SOLID_BLACK,
-                        &raqote::DrawOptions::new(),
-                    );
-                    y += 16.0;
-                }
+                y += 16.0;
+            }
+        }
+
+        for tias in self.tools.values() {
+            if let Some(state) = &tias.state {
+                let mut pb = raqote::PathBuilder::new();
+                let pressure = tias.pressure_web();
+                pb.arc(
+                    state.x as f32,// * self.width as f32,
+                    state.y as f32,// * self.height as f32,
+                    10.0 + 30.0 * pressure as f32,
+                    0.,
+                    2. * std::f32::consts::PI,
+                );
+                pb.close();
+                dt.fill(
+                    &pb.finish(),
+                    &if state.down.is_some() { SOLID_GREEN } else { SOLID_RED },
+                    &raqote::DrawOptions::new(),
+                );
+            }
+        }
+
+        // Damage the entire window
+        let surface = self.window.wl_surface();
+        surface.damage_buffer(0, 0, self.width as i32, self.height as i32);
+
+        // Request our next frame
+        surface.frame(qh, surface.clone());
+
+        // Attach and commit to present.
+        buffer.attach_to(surface).expect("buffer attach");
+        surface.commit();
+    }
+
+    fn draw_sketch(&mut self, _conn: &Connection, qh: &QueueHandle<Self>) {
+        let Mode::Sketch { buffer, busy_buffer } = &mut self.mode
+        else { unreachable!() };
+
+        println!("draw_sketch");
+        let canvas = match self.pool.canvas(buffer) {
+            Some(canvas) => canvas,
+            None => {
+                // I don’t know if I’m using this wrong,
+                // but I want to copy from one buffer to another buffer,
+                // which I understand is allowed (see below),
+                // and I suppose they should both go in the same SlotPool,
+                // but the use of &mut prevents me accessing both at once,
+                // and… and… and… meh, I’m just going to do something stupid for now.
+                // TODO find out from someone who actually knows what they’re doing,
+                // what the appropriate solution is.
+                let old_canvas = unsafe {
+                    std::mem::transmute::<&'_ mut [u8], &'static [u8]>(
+                        self.pool.raw_data_mut(&buffer.slot())
+                    )
+                };
+
+                // This should be rare
+                // (TODO: the rest of this ssentence is found in other examples here,
+                // but I seem to hit it immediatley in Sway, so I dunno if it’s even true),
+                // but if the compositor has not released the previous
+                // buffer, we need double-buffering.
+                let (mut second_buffer, canvas) = self
+                    .pool
+                    .create_buffer(
+                        self.width as i32,
+                        self.height as i32,
+                        self.width as i32 * 4,
+                        wl_shm::Format::Xrgb8888,
+                    )
+                    .expect("create buffer");
+                // Now, we copy from the busy buffer to the new one.
+                // <https://lists.freedesktop.org/archives/wayland-devel/2020-June/041490.html#:~:text=you%20can%20play%20tricks,readbacks%20may%20have%20issues>
+                // tells me that this is safe, but that there may be issues.
+                // I’m out of my depth here.
+                // Maybe that’s why there isn’t a &Buffer → &[u8] method?
+                // Anyway, for now I’ll just do this and hope for the best.
+                canvas.copy_from_slice(old_canvas);
+                // And we swap them. We’ll later need to mark the damage
+                // regions that the busy buffer needs to copy back from this one.
+                std::mem::swap(buffer, &mut second_buffer);
+                *busy_buffer = Some((second_buffer, vec![]));
+                // … but y’know what? For now I’m just going to trash it,
+                // instead of implementing that.
+                // Consider this a stub for a possibly bad idea.
+                *busy_buffer = None;
+                canvas
             }
+        };
+        let mut dt = raqote::DrawTarget::from_backing(
+            self.width as i32,
+            self.height as i32,
+            //bytemuck::cast_slice_mut(self.pool.canvas(&buffer).unwrap()),
+            bytemuck::cast_slice_mut(canvas),
+        );
+
+        let surface = self.window.wl_surface();
+
+        for tool in self.tools.values() {
+            if let Some(state @ TabletToolState { down: Some(_), .. }) = &tool.state {
+                let mut pb = raqote::PathBuilder::new();
+                let pressure = tool.pressure_web();
+
+                let radius = 10.0 * pressure as f32;
+                pb.arc(
+                    state.x as f32,
+                    state.y as f32,
+                    radius,
+                    0.,
+                    2. * std::f32::consts::PI,
+                );
+                pb.close();
+                dt.fill(
+                    &pb.finish(),
+                    &raqote::Source::Solid(raqote::SolidSource {
+                        r: (state.tilt_x + 90.0 / 180.0 * 255.0) as u8,
+                        g: (state.tilt_y + 90.0 / 180.0 * 255.0) as u8,
+                        b: (state.rotation_degrees / 360.0 * 255.0 % 255.0) as u8,
+                        a: if tool.info.capabilities.slider {
+                            ((state.slider_position + 65535) as f64 / 131071.0 * 255.0) as u8
+                        } else {
+                            // Sure, 0 is the neutraal position and all that,
+                            // but semitransparent looks a bit odd,
+                            // so sans slider support, we’ll just go opaque.
+                            // (b being 0 if rotation is not supported is fine.)
+                            255
+                        },
+                    }),
+                    &raqote::DrawOptions::new(),
+                );
 
-            for tias in self.tools.values() {
-                if let Some(state) = &tias.state {
-                    let mut pb = raqote::PathBuilder::new();
-                    let pressure = tias.pressure_web();
-                    pb.arc(
-                        state.x as f32,// * self.width as f32,
-                        state.y as f32,// * self.height as f32,
-                        10.0 + 30.0 * pressure as f32,
-                        0.,
-                        2. * std::f32::consts::PI,
-                    );
-                    pb.close();
-                    dt.fill(
-                        &pb.finish(),
-                        &if state.down.is_some() { SOLID_GREEN } else { SOLID_RED },
-                        &raqote::DrawOptions::new(),
-                    );
-                }
+                surface.damage_buffer(
+                    ((state.x as f32) - radius).floor() as i32,
+                    ((state.y as f32) - radius).floor() as i32,
+                    ((state.x as f32) + radius).ceil() as i32,
+                    ((state.y as f32) + radius).ceil() as i32,
+                );
             }
+        }
 
-            // Damage the entire window
-            window.wl_surface().damage_buffer(0, 0, self.width as i32, self.height as i32);
+        // Request our next frame
+        surface.frame(qh, surface.clone());
+
+        // Attach and commit to present.
+        buffer.attach_to(surface).expect("buffer attach");
+        surface.commit();
+    }
 
-            // Request our next frame
-            window.wl_surface().frame(qh, window.wl_surface().clone());
+    fn reset_sketch_mode(&mut self) {
+        let buffer = self.pool
+            .create_buffer(
+                self.width as i32,
+                self.height as i32,
+                self.width as i32 * 4,
+                wl_shm::Format::Xrgb8888,
+            )
+            .expect("create buffer")
+            .0;
+
+        // Now we actually clear the buffer, making everything opaque white.
+        for x in buffer.canvas(&mut self.pool).unwrap() {
+            *x = 255;
+        }
+        self.window.wl_surface().damage_buffer(0, 0, i32::MAX, i32::MAX);
+        self.mode = Mode::Sketch { buffer, busy_buffer: None };
+    }
 
-            // Attach and commit to present.
-            buffer.attach_to(window.wl_surface()).expect("buffer attach");
-            window.wl_surface().commit();
+    fn toggle_mode(&mut self) {
+        println!("Switching mode to {:?}", self.mode);
+        match self.mode {
+            Mode::Points => self.reset_sketch_mode(),
+            Mode::Sketch { .. } => self.mode = Mode::Points,
         }
     }
 }
 
+#[derive(Debug)]
+pub enum Mode {
+    Points,
+    Sketch {
+        /// The buffer that gets drawn to and attached to the surface.
+        buffer: Buffer,
+        /// If the first buffer is not released, we swap to this buffer.
+        /// The buffer that gets copied to after drawing, and 
+        busy_buffer: Option<(Buffer, Vec<(i32, i32, i32, i32)>)>,
+    },
+}
+
+impl Mode {
+    fn is_points(&self) -> bool {
+        matches!(self, Mode::Points)
+    }
+
+    fn is_sketch(&self) -> bool {
+        matches!(self, Mode::Sketch { .. })
+    }
+}
+
 delegate_compositor!(SimpleWindow);
 delegate_output!(SimpleWindow);
 delegate_shm!(SimpleWindow);
 
 delegate_seat!(SimpleWindow);
-delegate_pointer!(SimpleWindow);
+delegate_keyboard!(SimpleWindow);
 delegate_tablet!(SimpleWindow);
 
 delegate_xdg_shell!(SimpleWindow);

From 5d11d0bbb4f9ca5bd284084d5f3dfc762c6170ff Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Wed, 19 Mar 2025 11:10:36 +0530
Subject: [PATCH 03/27] One approach to collecting tablet metadata

This lets the user consume it in either way.
---
 examples/tablet.rs        | 31 ++++++-------------------------
 src/seat/tablet/mod.rs    |  2 +-
 src/seat/tablet/tablet.rs | 34 ++++++++++++++++++++++++++++++++++
 3 files changed, 41 insertions(+), 26 deletions(-)

diff --git a/examples/tablet.rs b/examples/tablet.rs
index 818cd2d30..8ba7506dd 100644
--- a/examples/tablet.rs
+++ b/examples/tablet.rs
@@ -21,6 +21,7 @@ use smithay_client_toolkit::{
             TabletToolInitEvent, TabletToolInitEventList,
             TabletToolEventFrame,
             TabletToolEvent, TabletToolHandler,
+            tablet::TabletMetadata,
         },
         Capability, SeatHandler, SeatState,
     },
@@ -124,19 +125,6 @@ fn main() {
     }
 }
 
-#[derive(Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
-struct TabletMetadata {
-    /// The descriptive name of the tablet device.
-    name: Option<String>,
-    /// The USB vendor and product IDs for the tablet device.
-    id: Option<(u32, u32)>,
-    /// System-specific device paths for the tablet.
-    ///
-    /// Path format is unspecified.
-    /// Clients must figure out what to do with them, if they care.
-    paths: Vec<String>,
-}
-
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 struct Button {
     serial: u32,
@@ -513,27 +501,20 @@ impl TabletSeatHandler for SimpleWindow {
 impl TabletHandler for SimpleWindow {
     fn init_done(
         &mut self,
-        _conn: &Connection,
-        _qh: &QueueHandle<Self>,
+        _: &Connection,
+        _: &QueueHandle<Self>,
         tablet: &ZwpTabletV2,
         events: TabletEventList,
     ) {
-        let mut metadata = TabletMetadata::default();
-        for event in events {
-            match event {
-                TabletEvent::Name { name } => metadata.name = Some(name),
-                TabletEvent::Id { vid, pid } => metadata.id = Some((vid, pid)),
-                TabletEvent::Path { path } => metadata.paths.push(path),
-            }
-        }
+        let metadata = TabletMetadata::from(events);
         println!("Tablet {} initialised: {:#?}", tablet.id(), metadata);
         self.tablets.insert(tablet.clone(), metadata);
     }
 
     fn removed(
         &mut self,
-        _conn: &Connection,
-        _qh: &QueueHandle<Self>,
+        _: &Connection,
+        _: &QueueHandle<Self>,
         tablet: &ZwpTabletV2,
     ) {
         println!("Tablet {} removed", tablet.id());
diff --git a/src/seat/tablet/mod.rs b/src/seat/tablet/mod.rs
index b76927199..563b8eff1 100644
--- a/src/seat/tablet/mod.rs
+++ b/src/seat/tablet/mod.rs
@@ -7,7 +7,7 @@ mod seat;
 pub use seat::{TabletSeatHandler, TabletSeatData};
 
 // zwp_tablet_v2
-mod tablet;
+pub mod tablet;
 pub use tablet::{TabletEvent, TabletHandler, TabletData, TabletEventList};
 
 // zwp_tablet_tool_v2
diff --git a/src/seat/tablet/tablet.rs b/src/seat/tablet/tablet.rs
index 9d310d2b7..06b610a12 100644
--- a/src/seat/tablet/tablet.rs
+++ b/src/seat/tablet/tablet.rs
@@ -108,3 +108,37 @@ where
         }
     }
 }
+
+/// An accumulator of tablet metadata events.
+#[derive(Debug, Default)]
+pub struct TabletMetadata {
+    /// The descriptive name of the tablet device.
+    pub name: Option<String>,
+    /// The USB vendor and product IDs for the tablet device.
+    pub id: Option<(u32, u32)>,
+    /// System-specific device paths for the tablet.
+    ///
+    /// Path format is unspecified.
+    /// Clients must figure out what to do with them, if they care.
+    pub paths: Vec<String>,
+}
+
+impl From<TabletEventList> for TabletMetadata {
+    fn from(events: TabletEventList) -> Self {
+        TabletMetadata::from_iter(events)
+    }
+}
+
+impl FromIterator<TabletEvent> for TabletMetadata {
+    fn from_iter<T: IntoIterator<Item = TabletEvent>>(events: T) -> Self {
+        let mut metadata = TabletMetadata::default();
+        for event in events {
+            match event {
+                TabletEvent::Name { name } => metadata.name = Some(name),
+                TabletEvent::Id { vid, pid } => metadata.id = Some((vid, pid)),
+                TabletEvent::Path { path } => metadata.paths.push(path),
+            }
+        }
+        metadata
+    }
+}

From 8ae623e7e0e2076716c63e2f79b66a8e2929b307 Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Wed, 19 Mar 2025 13:44:06 +0530
Subject: [PATCH 04/27] Tablet info events: new approach, always collect
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

I’m not *certain* why tablet-v2 uses a burst of events for descriptions.
For frames it makes inherent sense,
as that’s often the way you want to view it,
and for some things close to necessary, if you want it to be meaningful,
but for the static device descriptions it doesn’t make *inherent* sense.

My guesses are:

(1) The information isn’t all available at once.
    I don’t believe this is correct, or meaningfully so.

(2) Wayland protocol wire format limitations.
    I don’t know if it can express a list of strings¹, like paths?

(3) Forwards-compatibility measure.
    Is adding a new event to the burst easier than
    adding a new argument to an existing event?

It would be good to know whether it’s just vagaries of Wayland,
in which case reconstructing the pieces is preferrable,
or whether there is enduring purpose to the fragmentation.

Effects of this change:

  • Ergonomics: significant improvement for direct usage,
    much of a muchness for abstraction layers wanting to use their own struct.

  • Idle memory usage: reduced by 40 bytes per tablet.

  • Runtime: will typically make one more allocation than before.
    Fixable by changing paths from Vec<String> to SmallVec<[String; 1]>,
    in which case runtime should overall be slightly better than before.
    But I’m not sure if we want to expose SmallVec like that.

—⁂—

¹ <https://wayland.freedesktop.org/docs/html/ch04.html#sect-Protocol-Wire-Format:~:text=array>,
  it’s just called “array” and it’s not clear to me what it can contain.
---
 examples/tablet.rs        |  5 +--
 src/seat/tablet/mod.rs    |  2 +-
 src/seat/tablet/tablet.rs | 82 ++++++++++++---------------------------
 3 files changed, 27 insertions(+), 62 deletions(-)

diff --git a/examples/tablet.rs b/examples/tablet.rs
index 8ba7506dd..966cafc23 100644
--- a/examples/tablet.rs
+++ b/examples/tablet.rs
@@ -17,7 +17,7 @@ use smithay_client_toolkit::{
             ToolCapability,
             TabletState,
             TabletSeatHandler,
-            TabletEvent, TabletEventList, TabletHandler,
+            TabletHandler,
             TabletToolInitEvent, TabletToolInitEventList,
             TabletToolEventFrame,
             TabletToolEvent, TabletToolHandler,
@@ -504,9 +504,8 @@ impl TabletHandler for SimpleWindow {
         _: &Connection,
         _: &QueueHandle<Self>,
         tablet: &ZwpTabletV2,
-        events: TabletEventList,
+        metadata: TabletMetadata,
     ) {
-        let metadata = TabletMetadata::from(events);
         println!("Tablet {} initialised: {:#?}", tablet.id(), metadata);
         self.tablets.insert(tablet.clone(), metadata);
     }
diff --git a/src/seat/tablet/mod.rs b/src/seat/tablet/mod.rs
index 563b8eff1..72a3b3dab 100644
--- a/src/seat/tablet/mod.rs
+++ b/src/seat/tablet/mod.rs
@@ -8,7 +8,7 @@ pub use seat::{TabletSeatHandler, TabletSeatData};
 
 // zwp_tablet_v2
 pub mod tablet;
-pub use tablet::{TabletEvent, TabletHandler, TabletData, TabletEventList};
+pub use tablet::{TabletEvent, TabletHandler, TabletData};
 
 // zwp_tablet_tool_v2
 mod tool;
diff --git a/src/seat/tablet/tablet.rs b/src/seat/tablet/tablet.rs
index 06b610a12..a5eba8bc7 100644
--- a/src/seat/tablet/tablet.rs
+++ b/src/seat/tablet/tablet.rs
@@ -1,7 +1,6 @@
 use std::mem;
 use std::sync::Mutex;
 
-use wayland_backend::smallvec::SmallVec;
 use wayland_client::{
     Connection,
     Dispatch,
@@ -32,13 +31,13 @@ pub enum TabletEvent {
 
 pub trait TabletHandler: Sized {
     /// This is fired at the time of the `zwp_tablet_v2.done` event,
-    /// and coalesces any `name`, `id` and `path` events that precede it.
+    /// and collects any preceding `name`, `id` and `path` events into a [`TabletMetadata`].
     fn init_done(
         &mut self,
         conn: &Connection,
         qh: &QueueHandle<Self>,
         tablet: &ZwpTabletV2,
-        events: TabletEventList,
+        metadata: TabletMetadata,
     );
 
     /// Sent when the tablet has been removed from the system.
@@ -53,31 +52,32 @@ pub trait TabletHandler: Sized {
     );
 }
 
+/// An accumulator of tablet metadata events.
+#[derive(Debug, Default)]
+pub struct TabletMetadata {
+    /// The descriptive name of the tablet device.
+    pub name: Option<String>,
+    /// The USB vendor and product IDs for the tablet device.
+    pub id: Option<(u32, u32)>,
+    /// System-specific device paths for the tablet.
+    ///
+    /// Path format is unspecified.
+    /// Clients must figure out what to do with them, if they care.
+    pub paths: Vec<String>,
+}
+
 #[doc(hidden)]
 #[derive(Debug)]
 pub struct TabletData {
-    //seat: WlSeat,
-    //tablet_seat: ZwpTabletSeatV2,
-    inner: Mutex<TabletDataInner>,
+    metadata: Mutex<TabletMetadata>,
 }
 
 impl TabletData {
     pub fn new() -> Self {
-        Self { inner: Default::default() }
+        Self { metadata: Default::default() }
     }
 }
 
-// This will typically reach 3 events: name, id, path;
-// but it could be as few as zero for an unnamed virtual device,
-// and it could be more for something with multiple paths.
-pub type TabletEventList = SmallVec<[TabletEvent; 3]>;
-
-#[derive(Debug, Default)]
-struct TabletDataInner {
-    /// List of pending events.
-    pending: TabletEventList,
-}
-
 impl<D> Dispatch<ZwpTabletV2, TabletData, D>
     for TabletState
 where
@@ -91,15 +91,15 @@ where
         conn: &Connection,
         qh: &QueueHandle<D>,
     ) {
-        let mut guard = udata.inner.lock().unwrap();
+        let mut guard = udata.metadata.lock().unwrap();
         match event {
-            zwp_tablet_v2::Event::Name { name } => guard.pending.push(TabletEvent::Name { name }),
-            zwp_tablet_v2::Event::Id { vid, pid } => guard.pending.push(TabletEvent::Id { vid, pid }),
-            zwp_tablet_v2::Event::Path { path } => guard.pending.push(TabletEvent::Path { path }),
+            zwp_tablet_v2::Event::Name { name } => guard.name = Some(name),
+            zwp_tablet_v2::Event::Id { vid, pid } => guard.id = Some((vid, pid)),
+            zwp_tablet_v2::Event::Path { path } => guard.paths.push(path),
             zwp_tablet_v2::Event::Done => {
-                let pending = mem::take(&mut guard.pending);
+                let metadata = mem::take(&mut *guard);
                 drop(guard);
-                data.init_done(conn, qh, tablet, pending);
+                data.init_done(conn, qh, tablet, metadata);
             },
             zwp_tablet_v2::Event::Removed => {
                 data.removed(conn, qh, tablet);
@@ -108,37 +108,3 @@ where
         }
     }
 }
-
-/// An accumulator of tablet metadata events.
-#[derive(Debug, Default)]
-pub struct TabletMetadata {
-    /// The descriptive name of the tablet device.
-    pub name: Option<String>,
-    /// The USB vendor and product IDs for the tablet device.
-    pub id: Option<(u32, u32)>,
-    /// System-specific device paths for the tablet.
-    ///
-    /// Path format is unspecified.
-    /// Clients must figure out what to do with them, if they care.
-    pub paths: Vec<String>,
-}
-
-impl From<TabletEventList> for TabletMetadata {
-    fn from(events: TabletEventList) -> Self {
-        TabletMetadata::from_iter(events)
-    }
-}
-
-impl FromIterator<TabletEvent> for TabletMetadata {
-    fn from_iter<T: IntoIterator<Item = TabletEvent>>(events: T) -> Self {
-        let mut metadata = TabletMetadata::default();
-        for event in events {
-            match event {
-                TabletEvent::Name { name } => metadata.name = Some(name),
-                TabletEvent::Id { vid, pid } => metadata.id = Some((vid, pid)),
-                TabletEvent::Path { path } => metadata.paths.push(path),
-            }
-        }
-        metadata
-    }
-}

From 0c8f542775522761b55cac475f1c0448e1a199c6 Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Wed, 19 Mar 2025 13:45:26 +0530
Subject: [PATCH 05/27] =?UTF-8?q?Naming:=20=E2=80=9Cdescription=E2=80=9D?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This stuff is known by diverse names in the spec:
  • static information;
  • static characteristics;
  • static description;
And there may be more names I didn’t notice.

I think you could reasonably call it “metadata”, “info”, “description”,
maybe even “characteristics”; no need for the “static” part of the name.

In tablet tools, there’s state as well as the static information,
and access both at once (e.g. pressure and whether pressure-capable).
The name “state” is easy there, but since you’re touching both at once,
the name for this bit becomes a little more important.

My thoughts:
  • “info” feels just a *little* too vague;
  • “metadata” feels a *little* too confusable with sctk’s “data”,
    though on the other hand that’s largely invisible to users;
  • “characteristics” is too long, not elegantly shortenable,
    and the English word only really feels appropriate for capabilities,
    not names, paths and serial numbers;
  • “description” is longer than I’d like,
    and if you shorten it it becomes more confusable with “descriptor”.
---
 examples/tablet.rs        | 16 ++++++++--------
 src/seat/tablet/tablet.rs | 18 +++++++++---------
 2 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/examples/tablet.rs b/examples/tablet.rs
index 966cafc23..cecd9b624 100644
--- a/examples/tablet.rs
+++ b/examples/tablet.rs
@@ -21,7 +21,7 @@ use smithay_client_toolkit::{
             TabletToolInitEvent, TabletToolInitEventList,
             TabletToolEventFrame,
             TabletToolEvent, TabletToolHandler,
-            tablet::TabletMetadata,
+            tablet::TabletDescription,
         },
         Capability, SeatHandler, SeatState,
     },
@@ -227,7 +227,7 @@ struct SimpleWindow {
     keyboard: Option<wl_keyboard::WlKeyboard>,
     keyboard_focus: bool,
     tablet_seat: Option<ZwpTabletSeatV2>,
-    tablets: HashMap<ZwpTabletV2, TabletMetadata>,
+    tablets: HashMap<ZwpTabletV2, TabletDescription>,
     tools: HashMap<ZwpTabletToolV2, ToolInfoAndState>,
     pool: SlotPool,
     mode: Mode,
@@ -504,10 +504,10 @@ impl TabletHandler for SimpleWindow {
         _: &Connection,
         _: &QueueHandle<Self>,
         tablet: &ZwpTabletV2,
-        metadata: TabletMetadata,
+        description: TabletDescription,
     ) {
-        println!("Tablet {} initialised: {:#?}", tablet.id(), metadata);
-        self.tablets.insert(tablet.clone(), metadata);
+        println!("Tablet {} initialised: {:#?}", tablet.id(), description);
+        self.tablets.insert(tablet.clone(), description);
     }
 
     fn removed(
@@ -722,10 +722,10 @@ impl SimpleWindow {
                 &raqote::DrawOptions::new(),
             );
         } else {
-            for (id, tablet_metadata) in &self.tablets {
-                let text = match &tablet_metadata.name {
+            for (tablet, description) in &self.tablets {
+                let text = match &description.name {
                     Some(name) => name,
-                    None => &*id.id().to_string(),
+                    None => &*tablet.id().to_string(),
                 };
                 dt.draw_text(
                     &self.font,
diff --git a/src/seat/tablet/tablet.rs b/src/seat/tablet/tablet.rs
index a5eba8bc7..6680bc7bd 100644
--- a/src/seat/tablet/tablet.rs
+++ b/src/seat/tablet/tablet.rs
@@ -31,13 +31,13 @@ pub enum TabletEvent {
 
 pub trait TabletHandler: Sized {
     /// This is fired at the time of the `zwp_tablet_v2.done` event,
-    /// and collects any preceding `name`, `id` and `path` events into a [`TabletMetadata`].
+    /// and collects any preceding `name`, `id` and `path` events into a [`TabletDescription`].
     fn init_done(
         &mut self,
         conn: &Connection,
         qh: &QueueHandle<Self>,
         tablet: &ZwpTabletV2,
-        metadata: TabletMetadata,
+        description: TabletDescription,
     );
 
     /// Sent when the tablet has been removed from the system.
@@ -52,9 +52,9 @@ pub trait TabletHandler: Sized {
     );
 }
 
-/// An accumulator of tablet metadata events.
+/// The description of a tablet device.
 #[derive(Debug, Default)]
-pub struct TabletMetadata {
+pub struct TabletDescription {
     /// The descriptive name of the tablet device.
     pub name: Option<String>,
     /// The USB vendor and product IDs for the tablet device.
@@ -69,12 +69,12 @@ pub struct TabletMetadata {
 #[doc(hidden)]
 #[derive(Debug)]
 pub struct TabletData {
-    metadata: Mutex<TabletMetadata>,
+    description: Mutex<TabletDescription>,
 }
 
 impl TabletData {
     pub fn new() -> Self {
-        Self { metadata: Default::default() }
+        Self { description: Default::default() }
     }
 }
 
@@ -91,15 +91,15 @@ where
         conn: &Connection,
         qh: &QueueHandle<D>,
     ) {
-        let mut guard = udata.metadata.lock().unwrap();
+        let mut guard = udata.description.lock().unwrap();
         match event {
             zwp_tablet_v2::Event::Name { name } => guard.name = Some(name),
             zwp_tablet_v2::Event::Id { vid, pid } => guard.id = Some((vid, pid)),
             zwp_tablet_v2::Event::Path { path } => guard.paths.push(path),
             zwp_tablet_v2::Event::Done => {
-                let metadata = mem::take(&mut *guard);
+                let description = mem::take(&mut *guard);
                 drop(guard);
-                data.init_done(conn, qh, tablet, metadata);
+                data.init_done(conn, qh, tablet, description);
             },
             zwp_tablet_v2::Event::Removed => {
                 data.removed(conn, qh, tablet);

From 1ced013b068f74dc9e9ffee61b3f400e9019a1e2 Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Wed, 19 Mar 2025 14:04:36 +0530
Subject: [PATCH 06/27] Restructure code somewhat
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

I’m not fond of some of these names.

I’m not fond of deep paths.

Yet I think that overall this restructuring of access is an improvement.
A little.
Maybe it needs to go further.

The trouble starts with tablet-v2’s own names for things.
Everything is zwp_tablet_*_v2… except zwp_tablet_v2.
If you viewed “tablet” as the namespace,
it’d mean you have types Manager, Seat, Tool, Pad, PadGroup, PadRing and PadStrip…
and a type that’s not called Tablet because it actually just has no name.
A part of me wishes it was actually named zwp_tablet_tablet_v2.

It gets worse when you have this notion of a “tablet seat”.

At present I have modules named sctk::seat::tablet::seat and sctk::seat::tablet::tablet.
I find this rather amusing, but freely admit it to be suboptimal.

Maybe we need a different convention.
As a general rule in Rust, you import types and traits individually,
functions by module, constants vary,
and you mostly avoid duplication of the module name in type names.
Across a large code base you may get many things called “Error”,
and if you want to deal with more than one, you rename the import.
But there are some places where a different convention holds:
you don’t import each thing from std::fmt, but just import the module,
and `impl fmt::Display`, referring to fmt::Formatter and fmt::Result.

If I controlled *all* the naming, I’d probably structure things so:

    sctk::seat::{
        TabletManager (mismatching sctk’s *State custom,
                       but matching zwp_tablet_manager_v2,
                       and notably not exposed in a submodule),
        tablet_seat::{Data (hidden), Handler},
        tablet::{
            Data (hidden),
            Description (accumulator for the initial burst of events),
            Event,
            Handler,
        },
        tablet_tool::{
            Capability (reexported enum),
            Data (hidden),
            Description (accumulator for the initial burst of events),
            Event,
            EventList (maybe gone?),
            Frame,
            Handler,
            InitEvent,
            InitEventList (maybe gone?),
            State (optional accumulator of frames,
                   nothing to do with sctk’s *State convention),
            Type (reexported enum),
        },
        tablet_pad::{
            I dunno, not so comfortable with the further namespacing here,
            we have pad, pad group, pad ring and pad strip.
            Might even rename the module just pad.
        },
    }

And users would generally be expected to use it like this:

    use sctk::seat::{TabletManager, tablet_seat, tablet, tablet_tool, tablet_pad};
    impl tablet_tool::Handler for … {
        fn …(
            …,
            events: Vec<tablet_tool::Event>,
        ) {
            if self.tools.get(tablet).type == tablet_tool::Type::Pen {

Another possibility would be putting everything inside sctk::seat::tablet:

    sctk::seat::tablet::{
        Manager, (spelling: tablet::Manager)
        seat::{Data, Handler}, (spelling: tablet::seat::Handler)
        tool::{…}, (spelling: tablet::tool::Handler)

        // Tablet itself is messy.
        // One possibility (spelling: tablet::tablet::Handler):
        tablet::{…},
        // Another possibility (spelling: tablet::Event):
        // Not so fond of this, especially if it led to tablet::State!
        …,

        // One possibility:
        pad::{…},
        pad_group::{…},
        pad_ring::{…},
        pad_strip::{…},
        // Another possibility:
        pad::{
            …,
            group::{…},
            ring::{…},
            strip::{…},
        },
    }

But tablet::tool::Handler is feeling a little icky,
and then we’re back with sctk::seat::tablet::seat.

There are at least three sets of customs: general Rust, Wayland, sctk.
It’s not possible to satisfy all three,
and at places it may be a struggle to satisfy even two.
I think we’re going to be breaking someone’s custom, somewhere,
however we do it.
---
 examples/tablet.rs         |  16 +++---
 src/seat/tablet/manager.rs |  62 ----------------------
 src/seat/tablet/mod.rs     | 103 ++++++++++++++++++++++++-------------
 src/seat/tablet/seat.rs    |   5 +-
 4 files changed, 80 insertions(+), 106 deletions(-)
 delete mode 100644 src/seat/tablet/manager.rs

diff --git a/examples/tablet.rs b/examples/tablet.rs
index cecd9b624..9b113e1a7 100644
--- a/examples/tablet.rs
+++ b/examples/tablet.rs
@@ -13,15 +13,15 @@ use smithay_client_toolkit::{
     seat::{
         keyboard::{KeyEvent, KeyboardHandler, Keysym, Modifiers, RawModifiers},
         tablet::{
-            ToolType,
-            ToolCapability,
             TabletState,
-            TabletSeatHandler,
-            TabletHandler,
-            TabletToolInitEvent, TabletToolInitEventList,
-            TabletToolEventFrame,
-            TabletToolEvent, TabletToolHandler,
-            tablet::TabletDescription,
+            seat::TabletSeatHandler,
+            tablet::{TabletHandler, TabletDescription},
+            tool::{
+                ToolType, ToolCapability,
+                TabletToolInitEvent, TabletToolInitEventList,
+                TabletToolEventFrame,
+                TabletToolEvent, TabletToolHandler,
+            },
         },
         Capability, SeatHandler, SeatState,
     },
diff --git a/src/seat/tablet/manager.rs b/src/seat/tablet/manager.rs
deleted file mode 100644
index 30c7577c1..000000000
--- a/src/seat/tablet/manager.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-use wayland_client::{
-    globals::GlobalList,
-    protocol::wl_seat::WlSeat,
-    Connection,
-    Dispatch,
-    QueueHandle,
-};
-
-use wayland_protocols::wp::tablet::zv2::client::{
-    zwp_tablet_manager_v2::{self, ZwpTabletManagerV2},
-    zwp_tablet_seat_v2::ZwpTabletSeatV2,
-};
-
-use crate::{error::GlobalError, globals::GlobalData, registry::GlobalProxy};
-use super::seat::TabletSeatData;
-
-#[derive(Debug)]
-pub struct TabletState {
-    tablet_manager: GlobalProxy<ZwpTabletManagerV2>,
-}
-
-impl TabletState {
-    /// Bind `zwp_tablet_manager_v2` global, if it exists
-    pub fn bind<D>(globals: &GlobalList, qh: &QueueHandle<D>) -> Self
-    where
-        D: Dispatch<ZwpTabletManagerV2, GlobalData> + 'static,
-    {
-        Self {
-            tablet_manager: GlobalProxy::from(globals.bind(qh, 1..=1, GlobalData)),
-        }
-    }
-
-    pub fn get_tablet_seat<D>(
-        &self,
-        seat: &WlSeat,
-        qh: &QueueHandle<D>,
-    ) -> Result<ZwpTabletSeatV2, GlobalError>
-    where
-        D: Dispatch<ZwpTabletSeatV2, TabletSeatData> + 'static,
-    {
-        let udata = TabletSeatData { wl_seat: seat.clone() };
-        Ok(self.tablet_manager.get()?.get_tablet_seat(seat, qh, udata))
-    }
-}
-
-impl<D> Dispatch<ZwpTabletManagerV2, GlobalData, D>
-    for TabletState
-where
-    D: Dispatch<ZwpTabletManagerV2, GlobalData>,
-    // TODO: which Handler traits, if any, should D be constrained to?
-{
-    fn event(
-        _data: &mut D,
-        _manager: &ZwpTabletManagerV2,
-        _event: zwp_tablet_manager_v2::Event,
-        _: &GlobalData,
-        _conn: &Connection,
-        _qh: &QueueHandle<D>,
-    ) {
-        unreachable!()
-    }
-}
diff --git a/src/seat/tablet/mod.rs b/src/seat/tablet/mod.rs
index 72a3b3dab..997978aae 100644
--- a/src/seat/tablet/mod.rs
+++ b/src/seat/tablet/mod.rs
@@ -1,35 +1,68 @@
-// zwp_tablet_manager_v2
-mod manager;
-pub use manager::TabletState;
+use wayland_client::{
+    globals::GlobalList,
+    protocol::wl_seat::WlSeat,
+    Connection,
+    Dispatch,
+    QueueHandle,
+};
+
+use wayland_protocols::wp::tablet::zv2::client::{
+    zwp_tablet_manager_v2::{self, ZwpTabletManagerV2},
+    zwp_tablet_seat_v2::ZwpTabletSeatV2,
+};
 
-// zwp_tablet_seat_v2
-mod seat;
-pub use seat::{TabletSeatHandler, TabletSeatData};
+use crate::{error::GlobalError, globals::GlobalData, registry::GlobalProxy};
 
-// zwp_tablet_v2
+pub mod seat;
 pub mod tablet;
-pub use tablet::{TabletEvent, TabletHandler, TabletData};
-
-// zwp_tablet_tool_v2
-mod tool;
-pub use tool::{
-    TabletToolInitEvent,
-    TabletToolInitEventList,
-    ToolCapability, ToolType,
-    TabletToolEventFrame, TabletToolEvent, TabletToolEventList,
-    TabletToolHandler,
-    TabletToolData,
-};
+pub mod tool;
+pub mod pad;
 
-// zwp_tablet_pad_v2
-//pub use seat::{TabletPadData, TabletPadHandler};
-mod pad;
-pub use pad::{
-    TabletPadData,
-    TabletPadGroupData,
-    TabletPadRingData,
-    TabletPadStripData,
-};
+#[derive(Debug)]
+pub struct TabletState {
+    tablet_manager: GlobalProxy<ZwpTabletManagerV2>,
+}
+
+impl TabletState {
+    /// Bind `zwp_tablet_manager_v2` global, if it exists
+    pub fn bind<D>(globals: &GlobalList, qh: &QueueHandle<D>) -> Self
+    where
+        D: Dispatch<ZwpTabletManagerV2, GlobalData> + 'static,
+    {
+        Self {
+            tablet_manager: GlobalProxy::from(globals.bind(qh, 1..=1, GlobalData)),
+        }
+    }
+
+    pub fn get_tablet_seat<D>(
+        &self,
+        seat: &WlSeat,
+        qh: &QueueHandle<D>,
+    ) -> Result<ZwpTabletSeatV2, GlobalError>
+    where
+        D: Dispatch<ZwpTabletSeatV2, seat::TabletSeatData> + 'static,
+    {
+        let udata = seat::TabletSeatData { wl_seat: seat.clone() };
+        Ok(self.tablet_manager.get()?.get_tablet_seat(seat, qh, udata))
+    }
+}
+
+impl<D> Dispatch<ZwpTabletManagerV2, GlobalData, D>
+    for TabletState
+where
+    D: Dispatch<ZwpTabletManagerV2, GlobalData>,
+{
+    fn event(
+        _data: &mut D,
+        _manager: &ZwpTabletManagerV2,
+        _event: zwp_tablet_manager_v2::Event,
+        _: &GlobalData,
+        _conn: &Connection,
+        _qh: &QueueHandle<D>,
+    ) {
+        unreachable!()
+    }
+}
 
 #[macro_export]
 macro_rules! delegate_tablet {
@@ -38,25 +71,25 @@ macro_rules! delegate_tablet {
             $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_manager_v2::ZwpTabletManagerV2: $crate::globals::GlobalData
         ] => $crate::seat::tablet::TabletState);
         $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
-            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_seat_v2::ZwpTabletSeatV2: $crate::seat::tablet::TabletSeatData
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_seat_v2::ZwpTabletSeatV2: $crate::seat::tablet::seat::TabletSeatData
         ] => $crate::seat::tablet::TabletState);
         $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
-            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_v2::ZwpTabletV2: $crate::seat::tablet::TabletData
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_v2::ZwpTabletV2: $crate::seat::tablet::tablet::TabletData
         ] => $crate::seat::tablet::TabletState);
         $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
-            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_tool_v2::ZwpTabletToolV2: $crate::seat::tablet::TabletToolData
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_tool_v2::ZwpTabletToolV2: $crate::seat::tablet::tool::TabletToolData
         ] => $crate::seat::tablet::TabletState);
         $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
-            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_v2::ZwpTabletPadV2: $crate::seat::tablet::TabletPadData
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_v2::ZwpTabletPadV2: $crate::seat::tablet::pad::TabletPadData
         ] => $crate::seat::tablet::TabletState);
         $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
-            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_group_v2::ZwpTabletPadGroupV2: $crate::seat::tablet::TabletPadGroupData
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_group_v2::ZwpTabletPadGroupV2: $crate::seat::tablet::pad::TabletPadGroupData
         ] => $crate::seat::tablet::TabletState);
         $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
-            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_ring_v2::ZwpTabletPadRingV2: $crate::seat::tablet::TabletPadRingData
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_ring_v2::ZwpTabletPadRingV2: $crate::seat::tablet::pad::TabletPadRingData
         ] => $crate::seat::tablet::TabletState);
         $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
-            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_strip_v2::ZwpTabletPadStripV2: $crate::seat::tablet::TabletPadStripData
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_strip_v2::ZwpTabletPadStripV2: $crate::seat::tablet::pad::TabletPadStripData
         ] => $crate::seat::tablet::TabletState);
     };
 }
diff --git a/src/seat/tablet/seat.rs b/src/seat/tablet/seat.rs
index 81289b170..952b9ed73 100644
--- a/src/seat/tablet/seat.rs
+++ b/src/seat/tablet/seat.rs
@@ -12,7 +12,10 @@ use wayland_protocols::wp::tablet::zv2::client::{
     zwp_tablet_pad_v2::ZwpTabletPadV2,
 };
 
-use super::{TabletState, TabletData, TabletToolData, TabletPadData};
+use super::TabletState;
+use super::tablet::TabletData;
+use super::tool::TabletToolData;
+use super::pad::TabletPadData;
 
 pub trait TabletSeatHandler: Sized {
     fn tablet_added(

From 61e0e44214a2260475c46677d723aff40c150625 Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Wed, 19 Mar 2025 14:59:54 +0530
Subject: [PATCH 07/27] Try a more radical module and naming structure
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This matches Wayland conventions a little better,
Rust conventions better in some ways and a little worse in others,
and sctk conventions worse.

I won’t describe the module shifts, they’re clear enough,
and were messy because I wasn’t sure about flat or nested before.

The in-module renames are mostly obvious X* → x::* changes.
  • A few Tool* (most were TabletTool*) have become tablet_tool::*.
  • TabletState → TabletManager (and it’s exported from sctk::seat).
  • TabletToolEventFrame → tablet_tool::Frame (dropped “Event”).
---
 examples/tablet.rs                            | 85 +++++++++----------
 src/seat/mod.rs                               |  5 ++
 src/seat/{tablet => }/tablet.rs               | 26 +++---
 src/seat/{tablet/mod.rs => tablet_manager.rs} | 45 +++++-----
 src/seat/{tablet/pad.rs => tablet_pad.rs}     | 65 +++++++-------
 src/seat/{tablet/seat.rs => tablet_seat.rs}   | 31 +++----
 src/seat/{tablet/tool.rs => tablet_tool.rs}   | 79 +++++++++--------
 7 files changed, 160 insertions(+), 176 deletions(-)
 rename src/seat/{tablet => }/tablet.rs (86%)
 rename src/seat/{tablet/mod.rs => tablet_manager.rs} (74%)
 rename src/seat/{tablet/pad.rs => tablet_pad.rs} (68%)
 rename src/seat/{tablet/seat.rs => tablet_seat.rs} (74%)
 rename src/seat/{tablet/tool.rs => tablet_tool.rs} (84%)

diff --git a/examples/tablet.rs b/examples/tablet.rs
index 9b113e1a7..67bf5f6fa 100644
--- a/examples/tablet.rs
+++ b/examples/tablet.rs
@@ -12,17 +12,10 @@ use smithay_client_toolkit::{
     registry_handlers,
     seat::{
         keyboard::{KeyEvent, KeyboardHandler, Keysym, Modifiers, RawModifiers},
-        tablet::{
-            TabletState,
-            seat::TabletSeatHandler,
-            tablet::{TabletHandler, TabletDescription},
-            tool::{
-                ToolType, ToolCapability,
-                TabletToolInitEvent, TabletToolInitEventList,
-                TabletToolEventFrame,
-                TabletToolEvent, TabletToolHandler,
-            },
-        },
+        TabletManager,
+        tablet_seat,
+        tablet,
+        tablet_tool,
         Capability, SeatHandler, SeatState,
     },
     shell::{
@@ -104,7 +97,7 @@ fn main() {
         compositor_state,
         shm_state,
         xdg_shell_state,
-        tablet_state: TabletState::bind(&globals, &qh),
+        tablet_manager: TabletManager::bind(&globals, &qh),
 
         exit: false,
         width,
@@ -143,7 +136,7 @@ struct TabletToolCapabilities {
 
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
 struct TabletToolInfo {
-    tool_type: ToolType,
+    tool_type: tablet_tool::Type,
     hardware_serial: Option<(u32, u32)>,
     hardware_id_wacom: Option<(u32, u32)>,
     capabilities: TabletToolCapabilities,
@@ -218,7 +211,7 @@ struct SimpleWindow {
     compositor_state: CompositorState,
     shm_state: Shm,
     xdg_shell_state: XdgShell,
-    tablet_state: TabletState,
+    tablet_manager: TabletManager,
 
     exit: bool,
     width: u32,
@@ -227,7 +220,7 @@ struct SimpleWindow {
     keyboard: Option<wl_keyboard::WlKeyboard>,
     keyboard_focus: bool,
     tablet_seat: Option<ZwpTabletSeatV2>,
-    tablets: HashMap<ZwpTabletV2, TabletDescription>,
+    tablets: HashMap<ZwpTabletV2, tablet::Description>,
     tools: HashMap<ZwpTabletToolV2, ToolInfoAndState>,
     pool: SlotPool,
     mode: Mode,
@@ -372,7 +365,7 @@ impl SeatHandler for SimpleWindow {
             self.keyboard = Some(keyboard);
         }
         if self.tablet_seat.is_none() {
-            let tablet_seat = self.tablet_state.get_tablet_seat(&seat, qh).ok();
+            let tablet_seat = self.tablet_manager.get_tablet_seat(&seat, qh).ok();
             if tablet_seat.is_some() {
                 println!("Created tablet seat");
             } else {
@@ -463,7 +456,7 @@ impl KeyboardHandler for SimpleWindow {
     }
 }
 
-impl TabletSeatHandler for SimpleWindow {
+impl tablet_seat::Handler for SimpleWindow {
     fn tablet_added(
         &mut self,
         _conn: &Connection,
@@ -498,13 +491,13 @@ impl TabletSeatHandler for SimpleWindow {
     // }
 }
 
-impl TabletHandler for SimpleWindow {
+impl tablet::Handler for SimpleWindow {
     fn init_done(
         &mut self,
         _: &Connection,
         _: &QueueHandle<Self>,
         tablet: &ZwpTabletV2,
-        description: TabletDescription,
+        description: tablet::Description,
     ) {
         println!("Tablet {} initialised: {:#?}", tablet.id(), description);
         self.tablets.insert(tablet.clone(), description);
@@ -521,13 +514,13 @@ impl TabletHandler for SimpleWindow {
     }
 }
 
-impl TabletToolHandler for SimpleWindow {
+impl tablet_tool::Handler for SimpleWindow {
     fn init_done(
         &mut self,
         _conn: &Connection,
         _qh: &QueueHandle<Self>,
         tablet_tool: &ZwpTabletToolV2,
-        events: TabletToolInitEventList,
+        events: tablet_tool::InitEventList,
     ) {
         let mut tool_type = None;
         let mut hardware_serial = None;
@@ -542,16 +535,16 @@ impl TabletToolHandler for SimpleWindow {
         };
         for event in events {
             match event {
-                TabletToolInitEvent::Type { tool_type: t } => tool_type = Some(t),
-                TabletToolInitEvent::HardwareSerial { hardware_serial_hi, hardware_serial_lo } => hardware_serial = Some((hardware_serial_hi, hardware_serial_lo)),
-                TabletToolInitEvent::HardwareIdWacom { hardware_id_hi, hardware_id_lo } => hardware_id_wacom = Some((hardware_id_hi, hardware_id_lo)),
-                TabletToolInitEvent::Capability { capability: ToolCapability::Tilt } => capabilities.tilt = true,
-                TabletToolInitEvent::Capability { capability: ToolCapability::Pressure } => capabilities.pressure = true,
-                TabletToolInitEvent::Capability { capability: ToolCapability::Distance } => capabilities.distance = true,
-                TabletToolInitEvent::Capability { capability: ToolCapability::Rotation } => capabilities.rotation = true,
-                TabletToolInitEvent::Capability { capability: ToolCapability::Slider } => capabilities.slider = true,
-                TabletToolInitEvent::Capability { capability: ToolCapability::Wheel } => capabilities.wheel = true,
-                TabletToolInitEvent::Capability { capability: _ } => (),
+                tablet_tool::InitEvent::Type { tool_type: t } => tool_type = Some(t),
+                tablet_tool::InitEvent::HardwareSerial { hardware_serial_hi, hardware_serial_lo } => hardware_serial = Some((hardware_serial_hi, hardware_serial_lo)),
+                tablet_tool::InitEvent::HardwareIdWacom { hardware_id_hi, hardware_id_lo } => hardware_id_wacom = Some((hardware_id_hi, hardware_id_lo)),
+                tablet_tool::InitEvent::Capability { capability: tablet_tool::Capability::Tilt } => capabilities.tilt = true,
+                tablet_tool::InitEvent::Capability { capability: tablet_tool::Capability::Pressure } => capabilities.pressure = true,
+                tablet_tool::InitEvent::Capability { capability: tablet_tool::Capability::Distance } => capabilities.distance = true,
+                tablet_tool::InitEvent::Capability { capability: tablet_tool::Capability::Rotation } => capabilities.rotation = true,
+                tablet_tool::InitEvent::Capability { capability: tablet_tool::Capability::Slider } => capabilities.slider = true,
+                tablet_tool::InitEvent::Capability { capability: tablet_tool::Capability::Wheel } => capabilities.wheel = true,
+                tablet_tool::InitEvent::Capability { capability: _ } => (),
             }
         }
         let info = TabletToolInfo {
@@ -582,14 +575,14 @@ impl TabletToolHandler for SimpleWindow {
         _conn: &Connection,
         _qh: &QueueHandle<Self>,
         tablet_tool: &ZwpTabletToolV2,
-        frame: TabletToolEventFrame,
+        frame: tablet_tool::Frame,
     ) {
         println!("Tablet tool {} frame: {:#?}", tablet_tool.id(), frame);
-        let TabletToolEventFrame { time, events } = frame;
+        let tablet_tool::Frame { time, events } = frame;
         let mut events = events.into_iter();
         let tias = self.tools.get_mut(tablet_tool).unwrap();
         let state = tias.state.get_or_insert_with(|| {
-            let Some(TabletToolEvent::ProximityIn { serial, tablet, surface }) = events.next()
+            let Some(tablet_tool::Event::ProximityIn { serial, tablet, surface }) = events.next()
             else {
                 panic!("First zwp_tablet_tool_v2 frame didn’t start with a proximity_in event");
             };
@@ -625,12 +618,12 @@ impl TabletToolHandler for SimpleWindow {
 
         for event in events {
             match event {
-                TabletToolEvent::ProximityIn { serial, tablet, surface } => {
+                tablet_tool::Event::ProximityIn { serial, tablet, surface } => {
                     state.serial = serial;
                     state.tablet = tablet;
                     state.surface = surface;
                 },
-                TabletToolEvent::ProximityOut => {
+                tablet_tool::Event::ProximityOut => {
                     tias.state = None;
                     // Given that a frame is supposed to represent a single hardware event,
                     // I think you can fairly say it’d be mad to proximity_out and
@@ -638,38 +631,38 @@ impl TabletToolHandler for SimpleWindow {
                     // So I think we’re OK to just break.
                     break;
                 },
-                TabletToolEvent::Down { serial } => {
+                tablet_tool::Event::Down { serial } => {
                     state.down = Some(serial);
                 },
-                TabletToolEvent::Up => {
+                tablet_tool::Event::Up => {
                     state.down = None;
                 },
-                TabletToolEvent::Motion { x, y } => {
+                tablet_tool::Event::Motion { x, y } => {
                     state.x = x;
                     state.y = y;
                 },
-                TabletToolEvent::Pressure { pressure } => {
+                tablet_tool::Event::Pressure { pressure } => {
                     state.pressure = pressure;
                 },
-                TabletToolEvent::Distance { distance } => {
+                tablet_tool::Event::Distance { distance } => {
                     state.distance = distance;
                 },
-                TabletToolEvent::Tilt { tilt_x, tilt_y } => {
+                tablet_tool::Event::Tilt { tilt_x, tilt_y } => {
                     state.tilt_x = tilt_x;
                     state.tilt_y = tilt_y;
                 },
-                TabletToolEvent::Rotation { degrees } => {
+                tablet_tool::Event::Rotation { degrees } => {
                     state.rotation_degrees = degrees;
                 },
-                TabletToolEvent::Slider { position } => {
+                tablet_tool::Event::Slider { position } => {
                     state.slider_position = position;
                 },
-                TabletToolEvent::Wheel { degrees, clicks } => {
+                tablet_tool::Event::Wheel { degrees, clicks } => {
                     // These ones use += because they’re deltas, unlike the rest.
                     state.wheel_degrees += degrees;
                     state.wheel_clicks += clicks;
                 },
-                TabletToolEvent::Button { serial, button, pressed } => {
+                tablet_tool::Event::Button { serial, button, pressed } => {
                     if pressed {
                         state.buttons.insert(Button { serial, button });
                     } else {
diff --git a/src/seat/mod.rs b/src/seat/mod.rs
index 1b5dfd25d..46e6d94be 100644
--- a/src/seat/mod.rs
+++ b/src/seat/mod.rs
@@ -25,7 +25,12 @@ pub mod pointer;
 pub mod pointer_constraints;
 pub mod relative_pointer;
 pub mod touch;
+mod tablet_manager;
+pub use tablet_manager::TabletManager;
+pub mod tablet_seat;
 pub mod tablet;
+pub mod tablet_tool;
+pub mod tablet_pad;
 
 use pointer::cursor_shape::CursorShapeManager;
 use pointer::{PointerData, PointerDataExt, PointerHandler, ThemeSpec, ThemedPointer, Themes};
diff --git a/src/seat/tablet/tablet.rs b/src/seat/tablet.rs
similarity index 86%
rename from src/seat/tablet/tablet.rs
rename to src/seat/tablet.rs
index 6680bc7bd..716e2d623 100644
--- a/src/seat/tablet/tablet.rs
+++ b/src/seat/tablet.rs
@@ -8,10 +8,8 @@ use wayland_client::{
 };
 use wayland_protocols::wp::tablet::zv2::client::zwp_tablet_v2::{self, ZwpTabletV2};
 
-use super::TabletState;
-
 #[derive(Debug)]
-pub enum TabletEvent {
+pub enum Event {
     /// The descriptive name of the tablet device
     Name {
         name: String,
@@ -29,15 +27,15 @@ pub enum TabletEvent {
     },
 }
 
-pub trait TabletHandler: Sized {
+pub trait Handler: Sized {
     /// This is fired at the time of the `zwp_tablet_v2.done` event,
-    /// and collects any preceding `name`, `id` and `path` events into a [`TabletDescription`].
+    /// and collects any preceding `name`, `id` and `path` events into a [`Description`].
     fn init_done(
         &mut self,
         conn: &Connection,
         qh: &QueueHandle<Self>,
         tablet: &ZwpTabletV2,
-        description: TabletDescription,
+        description: Description,
     );
 
     /// Sent when the tablet has been removed from the system.
@@ -54,7 +52,7 @@ pub trait TabletHandler: Sized {
 
 /// The description of a tablet device.
 #[derive(Debug, Default)]
-pub struct TabletDescription {
+pub struct Description {
     /// The descriptive name of the tablet device.
     pub name: Option<String>,
     /// The USB vendor and product IDs for the tablet device.
@@ -68,26 +66,26 @@ pub struct TabletDescription {
 
 #[doc(hidden)]
 #[derive(Debug)]
-pub struct TabletData {
-    description: Mutex<TabletDescription>,
+pub struct Data {
+    description: Mutex<Description>,
 }
 
-impl TabletData {
+impl Data {
     pub fn new() -> Self {
         Self { description: Default::default() }
     }
 }
 
-impl<D> Dispatch<ZwpTabletV2, TabletData, D>
-    for TabletState
+impl<D> Dispatch<ZwpTabletV2, Data, D>
+    for super::TabletManager
 where
-    D: Dispatch<ZwpTabletV2, TabletData> + TabletHandler,
+    D: Dispatch<ZwpTabletV2, Data> + Handler,
 {
     fn event(
         data: &mut D,
         tablet: &ZwpTabletV2,
         event: zwp_tablet_v2::Event,
-        udata: &TabletData,
+        udata: &Data,
         conn: &Connection,
         qh: &QueueHandle<D>,
     ) {
diff --git a/src/seat/tablet/mod.rs b/src/seat/tablet_manager.rs
similarity index 74%
rename from src/seat/tablet/mod.rs
rename to src/seat/tablet_manager.rs
index 997978aae..f11953492 100644
--- a/src/seat/tablet/mod.rs
+++ b/src/seat/tablet_manager.rs
@@ -13,17 +13,12 @@ use wayland_protocols::wp::tablet::zv2::client::{
 
 use crate::{error::GlobalError, globals::GlobalData, registry::GlobalProxy};
 
-pub mod seat;
-pub mod tablet;
-pub mod tool;
-pub mod pad;
-
 #[derive(Debug)]
-pub struct TabletState {
+pub struct TabletManager {
     tablet_manager: GlobalProxy<ZwpTabletManagerV2>,
 }
 
-impl TabletState {
+impl TabletManager {
     /// Bind `zwp_tablet_manager_v2` global, if it exists
     pub fn bind<D>(globals: &GlobalList, qh: &QueueHandle<D>) -> Self
     where
@@ -40,15 +35,15 @@ impl TabletState {
         qh: &QueueHandle<D>,
     ) -> Result<ZwpTabletSeatV2, GlobalError>
     where
-        D: Dispatch<ZwpTabletSeatV2, seat::TabletSeatData> + 'static,
+        D: Dispatch<ZwpTabletSeatV2, super::tablet_seat::Data> + 'static,
     {
-        let udata = seat::TabletSeatData { wl_seat: seat.clone() };
+        let udata = super::tablet_seat::Data { wl_seat: seat.clone() };
         Ok(self.tablet_manager.get()?.get_tablet_seat(seat, qh, udata))
     }
 }
 
 impl<D> Dispatch<ZwpTabletManagerV2, GlobalData, D>
-    for TabletState
+    for TabletManager
 where
     D: Dispatch<ZwpTabletManagerV2, GlobalData>,
 {
@@ -69,27 +64,27 @@ macro_rules! delegate_tablet {
     ($(@<$( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+>)? $ty: ty) => {
         $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
             $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_manager_v2::ZwpTabletManagerV2: $crate::globals::GlobalData
-        ] => $crate::seat::tablet::TabletState);
+        ] => $crate::seat::TabletManager);
         $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
-            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_seat_v2::ZwpTabletSeatV2: $crate::seat::tablet::seat::TabletSeatData
-        ] => $crate::seat::tablet::TabletState);
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_seat_v2::ZwpTabletSeatV2: $crate::seat::tablet_seat::Data
+        ] => $crate::seat::TabletManager);
         $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
-            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_v2::ZwpTabletV2: $crate::seat::tablet::tablet::TabletData
-        ] => $crate::seat::tablet::TabletState);
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_v2::ZwpTabletV2: $crate::seat::tablet::Data
+        ] => $crate::seat::TabletManager);
         $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
-            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_tool_v2::ZwpTabletToolV2: $crate::seat::tablet::tool::TabletToolData
-        ] => $crate::seat::tablet::TabletState);
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_tool_v2::ZwpTabletToolV2: $crate::seat::tablet_tool::Data
+        ] => $crate::seat::TabletManager);
         $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
-            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_v2::ZwpTabletPadV2: $crate::seat::tablet::pad::TabletPadData
-        ] => $crate::seat::tablet::TabletState);
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_v2::ZwpTabletPadV2: $crate::seat::tablet_pad::Data
+        ] => $crate::seat::TabletManager);
         $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
-            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_group_v2::ZwpTabletPadGroupV2: $crate::seat::tablet::pad::TabletPadGroupData
-        ] => $crate::seat::tablet::TabletState);
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_group_v2::ZwpTabletPadGroupV2: $crate::seat::tablet_pad::GroupData
+        ] => $crate::seat::TabletManager);
         $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
-            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_ring_v2::ZwpTabletPadRingV2: $crate::seat::tablet::pad::TabletPadRingData
-        ] => $crate::seat::tablet::TabletState);
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_ring_v2::ZwpTabletPadRingV2: $crate::seat::tablet_pad::RingData
+        ] => $crate::seat::TabletManager);
         $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
-            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_strip_v2::ZwpTabletPadStripV2: $crate::seat::tablet::pad::TabletPadStripData
-        ] => $crate::seat::tablet::TabletState);
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_strip_v2::ZwpTabletPadStripV2: $crate::seat::tablet_pad::StripData
+        ] => $crate::seat::TabletManager);
     };
 }
diff --git a/src/seat/tablet/pad.rs b/src/seat/tablet_pad.rs
similarity index 68%
rename from src/seat/tablet/pad.rs
rename to src/seat/tablet_pad.rs
index dde8179e5..9b6650b40 100644
--- a/src/seat/tablet/pad.rs
+++ b/src/seat/tablet_pad.rs
@@ -21,14 +21,13 @@ use wayland_protocols::wp::tablet::zv2::client::{
     zwp_tablet_pad_group_v2::{self, ZwpTabletPadGroupV2, EVT_STRIP_OPCODE, EVT_RING_OPCODE},
     zwp_tablet_pad_v2::{self, ZwpTabletPadV2, EVT_GROUP_OPCODE},
 };
-use super::TabletState;
 
 #[doc(hidden)]
 #[derive(Debug)]
-pub struct TabletPadData;
+pub struct Data;
 
-impl TabletPadData {
-    pub fn new() -> TabletPadData { TabletPadData }
+impl Data {
+    pub fn new() -> Data { Data }
 }
 
 // zwp_tablet_pad_v2
@@ -44,23 +43,23 @@ impl TabletPadData {
 // Event: removed
 // Enum: button_state
 
-impl<D> Dispatch<ZwpTabletPadV2, TabletPadData, D>
-    for TabletState
+impl<D> Dispatch<ZwpTabletPadV2, Data, D>
+    for super::TabletManager
 where
-    D: Dispatch<ZwpTabletPadV2, TabletPadData>
-     + Dispatch<ZwpTabletPadGroupV2, TabletPadGroupData>
-     //+ TabletPadHandler
+    D: Dispatch<ZwpTabletPadV2, Data>
+     + Dispatch<ZwpTabletPadGroupV2, GroupData>
+     //+ Handler
      + 'static,
 {
     event_created_child!(D, ZwpTabletPadV2, [
-        EVT_GROUP_OPCODE => (ZwpTabletPadGroupV2, TabletPadGroupData),
+        EVT_GROUP_OPCODE => (ZwpTabletPadGroupV2, GroupData),
     ]);
 
     fn event(
         data: &mut D,
         pad: &ZwpTabletPadV2,
         event: zwp_tablet_pad_v2::Event,
-        udata: &TabletPadData,
+        udata: &Data,
         conn: &Connection,
         qh: &QueueHandle<D>,
     ) {
@@ -68,25 +67,25 @@ where
     }
 }
 
-impl<D> Dispatch<ZwpTabletPadGroupV2, TabletPadGroupData, D>
-    for TabletState
+impl<D> Dispatch<ZwpTabletPadGroupV2, GroupData, D>
+    for super::TabletManager
 where
-    D: Dispatch<ZwpTabletPadGroupV2, TabletPadGroupData>
-     + Dispatch<ZwpTabletPadRingV2, TabletPadRingData>
-     + Dispatch<ZwpTabletPadStripV2, TabletPadStripData>
-     //+ TabletPadGroupHandler
+    D: Dispatch<ZwpTabletPadGroupV2, GroupData>
+     + Dispatch<ZwpTabletPadRingV2, RingData>
+     + Dispatch<ZwpTabletPadStripV2, StripData>
+     //+ GroupHandler
      + 'static,
 {
     event_created_child!(D, ZwpTabletPadV2, [
-        EVT_RING_OPCODE => (ZwpTabletPadRingV2, TabletPadRingData),
-        EVT_STRIP_OPCODE => (ZwpTabletPadStripV2, TabletPadStripData),
+        EVT_RING_OPCODE => (ZwpTabletPadRingV2, RingData),
+        EVT_STRIP_OPCODE => (ZwpTabletPadStripV2, StripData),
     ]);
 
     fn event(
         data: &mut D,
         group: &ZwpTabletPadGroupV2,
         event: zwp_tablet_pad_group_v2::Event,
-        udata: &TabletPadGroupData,
+        udata: &GroupData,
         conn: &Connection,
         qh: &QueueHandle<D>,
     ) {
@@ -94,17 +93,17 @@ where
     }
 }
 
-impl<D> Dispatch<ZwpTabletPadRingV2, TabletPadRingData, D>
-    for TabletState
+impl<D> Dispatch<ZwpTabletPadRingV2, RingData, D>
+    for super::TabletManager
 where
-    D: Dispatch<ZwpTabletPadRingV2, TabletPadRingData>
-     //+ TabletPadRingHandler,
+    D: Dispatch<ZwpTabletPadRingV2, RingData>
+     //+ RingHandler,
 {
     fn event(
         data: &mut D,
         ring: &ZwpTabletPadRingV2,
         event: zwp_tablet_pad_ring_v2::Event,
-        udata: &TabletPadRingData,
+        udata: &RingData,
         conn: &Connection,
         qh: &QueueHandle<D>,
     ) {
@@ -112,17 +111,17 @@ where
     }
 }
 
-impl<D> Dispatch<ZwpTabletPadStripV2, TabletPadStripData, D>
-    for TabletState
+impl<D> Dispatch<ZwpTabletPadStripV2, StripData, D>
+    for super::TabletManager
 where
-    D: Dispatch<ZwpTabletPadStripV2, TabletPadStripData>
-     //+ TabletPadStripHandler,
+    D: Dispatch<ZwpTabletPadStripV2, StripData>
+     //+ StripHandler,
 {
     fn event(
         data: &mut D,
         strip: &ZwpTabletPadStripV2,
         event: zwp_tablet_pad_strip_v2::Event,
-        udata: &TabletPadStripData,
+        udata: &StripData,
         conn: &Connection,
         qh: &QueueHandle<D>,
     ) {
@@ -140,7 +139,7 @@ where
 // Event: mode_switch
 #[doc(hidden)]
 #[derive(Debug)]
-pub struct TabletPadGroupData;
+pub struct GroupData;
 
 // zwp_tablet_pad_ring_v2
 // Request: set_feedback
@@ -152,7 +151,7 @@ pub struct TabletPadGroupData;
 // Enum: source
 #[doc(hidden)]
 #[derive(Debug)]
-pub struct TabletPadRingData;
+pub struct RingData;
 
 // zwp_tablet_pad_strip_v2
 // Request: set_feedback
@@ -164,4 +163,4 @@ pub struct TabletPadRingData;
 // Enum: source
 #[doc(hidden)]
 #[derive(Debug)]
-pub struct TabletPadStripData;
+pub struct StripData;
diff --git a/src/seat/tablet/seat.rs b/src/seat/tablet_seat.rs
similarity index 74%
rename from src/seat/tablet/seat.rs
rename to src/seat/tablet_seat.rs
index 952b9ed73..17ddde089 100644
--- a/src/seat/tablet/seat.rs
+++ b/src/seat/tablet_seat.rs
@@ -12,12 +12,7 @@ use wayland_protocols::wp::tablet::zv2::client::{
     zwp_tablet_pad_v2::ZwpTabletPadV2,
 };
 
-use super::TabletState;
-use super::tablet::TabletData;
-use super::tool::TabletToolData;
-use super::pad::TabletPadData;
-
-pub trait TabletSeatHandler: Sized {
+pub trait Handler: Sized {
     fn tablet_added(
         &mut self,
         conn: &Connection,
@@ -48,31 +43,31 @@ pub trait TabletSeatHandler: Sized {
 
 #[doc(hidden)]
 #[derive(Debug)]
-pub struct TabletSeatData {
+pub struct Data {
     pub(crate) wl_seat: WlSeat,
 }
 
-impl<D> Dispatch<ZwpTabletSeatV2, TabletSeatData, D>
-    for TabletState
+impl<D> Dispatch<ZwpTabletSeatV2, Data, D>
+    for super::TabletManager
 where
-    D: Dispatch<ZwpTabletSeatV2, TabletSeatData>
-     + Dispatch<ZwpTabletV2, TabletData>
-     + Dispatch<ZwpTabletToolV2, TabletToolData>
-     + Dispatch<ZwpTabletPadV2, TabletPadData>
-     + TabletSeatHandler
+    D: Dispatch<ZwpTabletSeatV2, Data>
+     + Dispatch<ZwpTabletV2, super::tablet::Data>
+     + Dispatch<ZwpTabletToolV2, super::tablet_tool::Data>
+     + Dispatch<ZwpTabletPadV2, super::tablet_pad::Data>
+     + Handler
      + 'static,
 {
     event_created_child!(D, ZwpTabletSeatV2, [
-        EVT_TABLET_ADDED_OPCODE => (ZwpTabletV2, TabletData::new()),
-        EVT_TOOL_ADDED_OPCODE => (ZwpTabletToolV2, TabletToolData::new()),
-        EVT_PAD_ADDED_OPCODE => (ZwpTabletPadV2, TabletPadData::new()),
+        EVT_TABLET_ADDED_OPCODE => (ZwpTabletV2, super::tablet::Data::new()),
+        EVT_TOOL_ADDED_OPCODE => (ZwpTabletToolV2, super::tablet_tool::Data::new()),
+        EVT_PAD_ADDED_OPCODE => (ZwpTabletPadV2, super::tablet_pad::Data::new()),
     ]);
 
     fn event(
         data: &mut D,
         tablet_seat: &ZwpTabletSeatV2,
         event: zwp_tablet_seat_v2::Event,
-        udata: &TabletSeatData,
+        udata: &Data,
         conn: &Connection,
         qh: &QueueHandle<D>,
     ) {
diff --git a/src/seat/tablet/tool.rs b/src/seat/tablet_tool.rs
similarity index 84%
rename from src/seat/tablet/tool.rs
rename to src/seat/tablet_tool.rs
index a0c1db2ca..aa281345a 100644
--- a/src/seat/tablet/tool.rs
+++ b/src/seat/tablet_tool.rs
@@ -17,13 +17,12 @@ use wayland_protocols::wp::tablet::zv2::client::{
     //zwp_tablet_pad_v2::{self, ZwpTabletPadV2},
 };
 
-use super::TabletState;
-pub use zwp_tablet_tool_v2::{Capability as ToolCapability, Type as ToolType};
+pub use zwp_tablet_tool_v2::{Capability, Type};
 
 #[derive(Debug)]
-pub enum TabletToolInitEvent {
+pub enum InitEvent {
     Type {
-        tool_type: ToolType,
+        tool_type: Type,
     },
     HardwareSerial {
         hardware_serial_hi: u32,
@@ -34,20 +33,20 @@ pub enum TabletToolInitEvent {
         hardware_id_lo: u32,
     },
     Capability {
-        capability: ToolCapability,
+        capability: Capability,
     },
 }
 
 #[derive(Debug)]
-pub struct TabletToolEventFrame {
+pub struct Frame {
     /// The time of the event with millisecond granularity
     pub time: u32,
     /// All the state changes that have occurred since the previous frame
-    pub events: TabletToolEventList,
+    pub events: EventList,
 }
 
 #[derive(Debug)]
-pub enum TabletToolEvent {
+pub enum Event {
     /// Notification that this tool is focused on a certain surface.
     ///
     /// This event can be received when the tool has moved from one surface to another,
@@ -175,7 +174,7 @@ pub enum TabletToolEvent {
     },
 }
 
-pub trait TabletToolHandler: Sized {
+pub trait Handler: Sized {
     /// This is fired at the time of the `zwp_tablet_tool_v2.done` event,
     /// and coalesces any `type`, `hardware_serial`, `hardware_serial_wacom` and `capability` events that precede it.
     fn init_done(
@@ -183,7 +182,7 @@ pub trait TabletToolHandler: Sized {
         conn: &Connection,
         qh: &QueueHandle<Self>,
         tablet: &ZwpTabletToolV2,
-        events: TabletToolInitEventList,
+        events: InitEventList,
     );
 
     /// Sent when the tablet has been removed from the system.
@@ -204,47 +203,47 @@ pub trait TabletToolHandler: Sized {
         conn: &Connection,
         qh: &QueueHandle<Self>,
         tablet: &ZwpTabletToolV2,
-        frame: TabletToolEventFrame,
+        frame: Frame,
     );
 }
 
 #[doc(hidden)]
 #[derive(Debug)]
-pub struct TabletToolData {
+pub struct Data {
     //seat: WlSeat,
     //tablet_seat: ZwpTabletToolSeatV2,
-    inner: Mutex<TabletToolDataInner>,
+    inner: Mutex<DataInner>,
 }
 
-impl TabletToolData {
+impl Data {
     pub fn new() -> Self {
         Self { inner: Default::default() }
     }
 }
 
-pub type TabletToolInitEventList = Vec<TabletToolInitEvent>;
-pub type TabletToolEventList = SmallVec<[TabletToolEvent; 3]>;
+pub type InitEventList = Vec<InitEvent>;
+pub type EventList = SmallVec<[Event; 3]>;
 
 #[derive(Debug, Default)]
-struct TabletToolDataInner {
+struct DataInner {
     /// List of pending init-time events, flushed when a `done` event comes in,
     /// after which it will be perpetually empty.
-    pending_init: TabletToolInitEventList,
+    pending_init: InitEventList,
 
     /// List of pending events, flushed when a `frame` event comes in.
-    pending_frame: TabletToolEventList,
+    pending_frame: EventList,
 }
 
-impl<D> Dispatch<ZwpTabletToolV2, TabletToolData, D>
-    for TabletState
+impl<D> Dispatch<ZwpTabletToolV2, Data, D>
+    for super::TabletManager
 where
-    D: Dispatch<ZwpTabletToolV2, TabletToolData> + TabletToolHandler,
+    D: Dispatch<ZwpTabletToolV2, Data> + Handler,
 {
     fn event(
         data: &mut D,
         tool: &ZwpTabletToolV2,
         event: zwp_tablet_tool_v2::Event,
-        udata: &TabletToolData,
+        udata: &Data,
         conn: &Connection,
         qh: &QueueHandle<D>,
     ) {
@@ -259,7 +258,7 @@ where
             // then finished with Done).
 
             zwp_tablet_tool_v2::Event::Type { tool_type } => {
-                guard.pending_init.push(TabletToolInitEvent::Type {
+                guard.pending_init.push(InitEvent::Type {
                     tool_type: match tool_type {
                         WEnum::Value(tool_type) => tool_type,
                         WEnum::Unknown(unknown) => {
@@ -270,13 +269,13 @@ where
                 });
             },
             zwp_tablet_tool_v2::Event::HardwareSerial { hardware_serial_hi, hardware_serial_lo } => {
-                guard.pending_init.push(TabletToolInitEvent::HardwareSerial { hardware_serial_hi, hardware_serial_lo });
+                guard.pending_init.push(InitEvent::HardwareSerial { hardware_serial_hi, hardware_serial_lo });
             },
             zwp_tablet_tool_v2::Event::HardwareIdWacom { hardware_id_hi, hardware_id_lo } => {
-                guard.pending_init.push(TabletToolInitEvent::HardwareIdWacom { hardware_id_hi, hardware_id_lo });
+                guard.pending_init.push(InitEvent::HardwareIdWacom { hardware_id_hi, hardware_id_lo });
             },
             zwp_tablet_tool_v2::Event::Capability { capability } => {
-                guard.pending_init.push(TabletToolInitEvent::Capability {
+                guard.pending_init.push(InitEvent::Capability {
                     capability: match capability {
                         WEnum::Value(capability) => capability,
                         WEnum::Unknown(unknown) => {
@@ -305,45 +304,45 @@ where
             // then finished with Frame).
 
             zwp_tablet_tool_v2::Event::ProximityIn { serial, tablet, surface } => {
-                guard.pending_frame.push(TabletToolEvent::ProximityIn { serial, tablet, surface });
+                guard.pending_frame.push(Event::ProximityIn { serial, tablet, surface });
             },
             zwp_tablet_tool_v2::Event::ProximityOut => {
-                guard.pending_frame.push(TabletToolEvent::ProximityOut);
+                guard.pending_frame.push(Event::ProximityOut);
             },
             zwp_tablet_tool_v2::Event::Down { serial } => {
-                guard.pending_frame.push(TabletToolEvent::Down { serial });
+                guard.pending_frame.push(Event::Down { serial });
             },
             zwp_tablet_tool_v2::Event::Up => {
-                guard.pending_frame.push(TabletToolEvent::Up);
+                guard.pending_frame.push(Event::Up);
             },
             zwp_tablet_tool_v2::Event::Motion { x, y } => {
-                guard.pending_frame.push(TabletToolEvent::Motion { x, y });
+                guard.pending_frame.push(Event::Motion { x, y });
             },
             zwp_tablet_tool_v2::Event::Pressure { pressure } => {
                 // “The value of this event is normalized to a value between 0 and 65535.”
                 // But the wayland Wire format only supports 32-bit integers, so we cast it.
                 // <https://wayland.freedesktop.org/docs/html/ch04.html#:~:text=xml.-,Wire%20Format>.
-                guard.pending_frame.push(TabletToolEvent::Pressure { pressure: pressure as u16 });
+                guard.pending_frame.push(Event::Pressure { pressure: pressure as u16 });
             },
             zwp_tablet_tool_v2::Event::Distance { distance } => {
                 // Same deal, “normalized to a value between 0 and 65535”.
-                guard.pending_frame.push(TabletToolEvent::Distance { distance: distance as u16 });
+                guard.pending_frame.push(Event::Distance { distance: distance as u16 });
             },
             zwp_tablet_tool_v2::Event::Tilt { tilt_x, tilt_y } => {
-                guard.pending_frame.push(TabletToolEvent::Tilt { tilt_x, tilt_y });
+                guard.pending_frame.push(Event::Tilt { tilt_x, tilt_y });
             },
             zwp_tablet_tool_v2::Event::Rotation { degrees } => {
-                guard.pending_frame.push(TabletToolEvent::Rotation { degrees });
+                guard.pending_frame.push(Event::Rotation { degrees });
             },
             zwp_tablet_tool_v2::Event::Slider { position } => {
                 // This one is “normalized between -65535 and 65535”, 17 bits, so it stays i32.
-                guard.pending_frame.push(TabletToolEvent::Slider { position });
+                guard.pending_frame.push(Event::Slider { position });
             },
             zwp_tablet_tool_v2::Event::Wheel { degrees, clicks } => {
-                guard.pending_frame.push(TabletToolEvent::Wheel { degrees, clicks });
+                guard.pending_frame.push(Event::Wheel { degrees, clicks });
             },
             zwp_tablet_tool_v2::Event::Button { serial, button, state } => {
-                guard.pending_frame.push(TabletToolEvent::Button {
+                guard.pending_frame.push(Event::Button {
                     serial,
                     button,
                     pressed: match state {
@@ -365,7 +364,7 @@ where
                 // The only issue is that it exposes SmallVec what is nicer an implementation type.
                 let events = mem::take(&mut guard.pending_frame);
                 drop(guard);
-                data.tablet_tool_frame(conn, qh, tool, TabletToolEventFrame {
+                data.tablet_tool_frame(conn, qh, tool, Frame {
                     time,
                     events,
                 });

From d6741e1f359fb36cd6de5b047d6638333cac5b31 Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Wed, 19 Mar 2025 15:13:48 +0530
Subject: [PATCH 08/27] Fiddle with tablet_tool::InitEvent naming
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This started because I didn’t like tool_type, and contemplated r#type.

I’m fed up with naming obvious single-field variants.
So much pointless duplication.
Type and Capability should clearly be tuple variants.

Then I realised I don’t like the hardware_serial_ and hardware_id_ duplication.
I kept the “hi” and “lo” names rather than going straight to (u32, u32);
the names are probably just sufficiently meaningful to retain them.
---
 examples/tablet.rs      | 20 ++++++++---------
 src/seat/tablet_tool.rs | 48 +++++++++++++++++------------------------
 2 files changed, 30 insertions(+), 38 deletions(-)

diff --git a/examples/tablet.rs b/examples/tablet.rs
index 67bf5f6fa..ec8c5049d 100644
--- a/examples/tablet.rs
+++ b/examples/tablet.rs
@@ -535,16 +535,16 @@ impl tablet_tool::Handler for SimpleWindow {
         };
         for event in events {
             match event {
-                tablet_tool::InitEvent::Type { tool_type: t } => tool_type = Some(t),
-                tablet_tool::InitEvent::HardwareSerial { hardware_serial_hi, hardware_serial_lo } => hardware_serial = Some((hardware_serial_hi, hardware_serial_lo)),
-                tablet_tool::InitEvent::HardwareIdWacom { hardware_id_hi, hardware_id_lo } => hardware_id_wacom = Some((hardware_id_hi, hardware_id_lo)),
-                tablet_tool::InitEvent::Capability { capability: tablet_tool::Capability::Tilt } => capabilities.tilt = true,
-                tablet_tool::InitEvent::Capability { capability: tablet_tool::Capability::Pressure } => capabilities.pressure = true,
-                tablet_tool::InitEvent::Capability { capability: tablet_tool::Capability::Distance } => capabilities.distance = true,
-                tablet_tool::InitEvent::Capability { capability: tablet_tool::Capability::Rotation } => capabilities.rotation = true,
-                tablet_tool::InitEvent::Capability { capability: tablet_tool::Capability::Slider } => capabilities.slider = true,
-                tablet_tool::InitEvent::Capability { capability: tablet_tool::Capability::Wheel } => capabilities.wheel = true,
-                tablet_tool::InitEvent::Capability { capability: _ } => (),
+                tablet_tool::InitEvent::Type(t) => tool_type = Some(t),
+                tablet_tool::InitEvent::HardwareSerial { hi, lo } => hardware_serial = Some((hi, lo)),
+                tablet_tool::InitEvent::HardwareIdWacom { hi, lo } => hardware_id_wacom = Some((hi, lo)),
+                tablet_tool::InitEvent::Capability(tablet_tool::Capability::Tilt) => capabilities.tilt = true,
+                tablet_tool::InitEvent::Capability(tablet_tool::Capability::Pressure) => capabilities.pressure = true,
+                tablet_tool::InitEvent::Capability(tablet_tool::Capability::Distance) => capabilities.distance = true,
+                tablet_tool::InitEvent::Capability(tablet_tool::Capability::Rotation) => capabilities.rotation = true,
+                tablet_tool::InitEvent::Capability(tablet_tool::Capability::Slider) => capabilities.slider = true,
+                tablet_tool::InitEvent::Capability(tablet_tool::Capability::Wheel) => capabilities.wheel = true,
+                tablet_tool::InitEvent::Capability(_) => (),
             }
         }
         let info = TabletToolInfo {
diff --git a/src/seat/tablet_tool.rs b/src/seat/tablet_tool.rs
index aa281345a..eed4391d5 100644
--- a/src/seat/tablet_tool.rs
+++ b/src/seat/tablet_tool.rs
@@ -21,20 +21,16 @@ pub use zwp_tablet_tool_v2::{Capability, Type};
 
 #[derive(Debug)]
 pub enum InitEvent {
-    Type {
-        tool_type: Type,
-    },
+    Type(Type),
     HardwareSerial {
-        hardware_serial_hi: u32,
-        hardware_serial_lo: u32,
+        hi: u32,
+        lo: u32,
     },
     HardwareIdWacom {
-        hardware_id_hi: u32,
-        hardware_id_lo: u32,
-    },
-    Capability {
-        capability: Capability,
+        hi: u32,
+        lo: u32,
     },
+    Capability(Capability),
 }
 
 #[derive(Debug)]
@@ -258,32 +254,28 @@ where
             // then finished with Done).
 
             zwp_tablet_tool_v2::Event::Type { tool_type } => {
-                guard.pending_init.push(InitEvent::Type {
-                    tool_type: match tool_type {
-                        WEnum::Value(tool_type) => tool_type,
-                        WEnum::Unknown(unknown) => {
-                            log::warn!(target: "sctk", "{}: invalid tablet tool type: {:x}", tool.id(), unknown);
-                            return;
-                        },
+                guard.pending_init.push(InitEvent::Type(match tool_type {
+                    WEnum::Value(tool_type) => tool_type,
+                    WEnum::Unknown(unknown) => {
+                        log::warn!(target: "sctk", "{}: invalid tablet tool type: {:x}", tool.id(), unknown);
+                        return;
                     },
-                });
+                }));
             },
             zwp_tablet_tool_v2::Event::HardwareSerial { hardware_serial_hi, hardware_serial_lo } => {
-                guard.pending_init.push(InitEvent::HardwareSerial { hardware_serial_hi, hardware_serial_lo });
+                guard.pending_init.push(InitEvent::HardwareSerial { hi: hardware_serial_hi, lo: hardware_serial_lo });
             },
             zwp_tablet_tool_v2::Event::HardwareIdWacom { hardware_id_hi, hardware_id_lo } => {
-                guard.pending_init.push(InitEvent::HardwareIdWacom { hardware_id_hi, hardware_id_lo });
+                guard.pending_init.push(InitEvent::HardwareIdWacom { hi: hardware_id_hi, lo: hardware_id_lo });
             },
             zwp_tablet_tool_v2::Event::Capability { capability } => {
-                guard.pending_init.push(InitEvent::Capability {
-                    capability: match capability {
-                        WEnum::Value(capability) => capability,
-                        WEnum::Unknown(unknown) => {
-                            log::warn!(target: "sctk", "{}: invalid tablet tool capability: {:x}", tool.id(), unknown);
-                            return;
-                        },
+                guard.pending_init.push(InitEvent::Capability(match capability {
+                    WEnum::Value(capability) => capability,
+                    WEnum::Unknown(unknown) => {
+                        log::warn!(target: "sctk", "{}: invalid tablet tool capability: {:x}", tool.id(), unknown);
+                        return;
                     },
-                });
+                }));
             },
             zwp_tablet_tool_v2::Event::Done => {
                 let events = mem::take(&mut guard.pending_init);

From a649d55ae8157bcdbd22767188822b1188c74bc2 Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Wed, 19 Mar 2025 15:58:47 +0530
Subject: [PATCH 09/27] Accumulate description for tablet tool handlers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Rather than giving the list of events,
do the accumulation ourselves.
This will normally be faster.

I didn’t just shift it from the example back into sctk,
I also got a bit carried away with stupid microoptimisation.
Without benchmarking, of course.
Ah well, it’s pretty self-contained, so it shouldn’t be too bad.
---
 examples/tablet.rs      |  62 ++----------------
 src/seat/tablet_tool.rs | 137 ++++++++++++++++++++++++++++++++++------
 2 files changed, 123 insertions(+), 76 deletions(-)

diff --git a/examples/tablet.rs b/examples/tablet.rs
index ec8c5049d..4f20b87e9 100644
--- a/examples/tablet.rs
+++ b/examples/tablet.rs
@@ -124,24 +124,6 @@ struct Button {
     button: u32,
 }
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
-struct TabletToolCapabilities {
-    tilt: bool,
-    pressure: bool,
-    distance: bool,
-    rotation: bool,
-    slider: bool,
-    wheel: bool,
-}
-
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
-struct TabletToolInfo {
-    tool_type: tablet_tool::Type,
-    hardware_serial: Option<(u32, u32)>,
-    hardware_id_wacom: Option<(u32, u32)>,
-    capabilities: TabletToolCapabilities,
-}
-
 /// The current state of the tool.
 ///
 /// This covers everything, and may, for some applications,
@@ -182,8 +164,7 @@ struct TabletToolState {
 }
 
 struct ToolInfoAndState {
-    /// Static info about the tool and its capabilities.
-    info: TabletToolInfo,
+    description: tablet_tool::Description,
     /// The time the last frame was sent,
     /// or zero if no frames have come yet.
     last_frame_time: u32,
@@ -196,7 +177,7 @@ impl ToolInfoAndState {
     /// scaled in the range \[0, 1\],
     /// and set to 0.5 when down if pressure isn’t supported.
     fn pressure_web(&self) -> f64 {
-        match (self.info.capabilities.pressure, &self.state) {
+        match (self.description.supports_pressure(), &self.state) {
             (true, &Some(TabletToolState { pressure, .. })) => pressure as f64 / 65535.0,
             (false, Some(TabletToolState { down: Some(_), .. })) => 0.5,
             _ => 0.0,
@@ -520,42 +501,11 @@ impl tablet_tool::Handler for SimpleWindow {
         _conn: &Connection,
         _qh: &QueueHandle<Self>,
         tablet_tool: &ZwpTabletToolV2,
-        events: tablet_tool::InitEventList,
+        description: tablet_tool::Description,
     ) {
-        let mut tool_type = None;
-        let mut hardware_serial = None;
-        let mut hardware_id_wacom = None;
-        let mut capabilities = TabletToolCapabilities {
-            tilt: false,
-            pressure: false,
-            distance: false,
-            rotation: false,
-            slider: false,
-            wheel: false,
-        };
-        for event in events {
-            match event {
-                tablet_tool::InitEvent::Type(t) => tool_type = Some(t),
-                tablet_tool::InitEvent::HardwareSerial { hi, lo } => hardware_serial = Some((hi, lo)),
-                tablet_tool::InitEvent::HardwareIdWacom { hi, lo } => hardware_id_wacom = Some((hi, lo)),
-                tablet_tool::InitEvent::Capability(tablet_tool::Capability::Tilt) => capabilities.tilt = true,
-                tablet_tool::InitEvent::Capability(tablet_tool::Capability::Pressure) => capabilities.pressure = true,
-                tablet_tool::InitEvent::Capability(tablet_tool::Capability::Distance) => capabilities.distance = true,
-                tablet_tool::InitEvent::Capability(tablet_tool::Capability::Rotation) => capabilities.rotation = true,
-                tablet_tool::InitEvent::Capability(tablet_tool::Capability::Slider) => capabilities.slider = true,
-                tablet_tool::InitEvent::Capability(tablet_tool::Capability::Wheel) => capabilities.wheel = true,
-                tablet_tool::InitEvent::Capability(_) => (),
-            }
-        }
-        let info = TabletToolInfo {
-            tool_type: tool_type.expect("zwp_tablet_tool_v2.type event missing"),
-            hardware_serial,
-            hardware_id_wacom,
-            capabilities,
-        };
-        println!("Tablet tool {} initialised: {:#?}", tablet_tool.id(), info);
+        println!("Tablet tool {} initialised: {:#?}", tablet_tool.id(), description);
         self.tools.insert(tablet_tool.clone(), ToolInfoAndState {
-            info,
+            description,
             last_frame_time: 0,
             state: None,
         });
@@ -847,7 +797,7 @@ impl SimpleWindow {
                         r: (state.tilt_x + 90.0 / 180.0 * 255.0) as u8,
                         g: (state.tilt_y + 90.0 / 180.0 * 255.0) as u8,
                         b: (state.rotation_degrees / 360.0 * 255.0 % 255.0) as u8,
-                        a: if tool.info.capabilities.slider {
+                        a: if tool.description.supports_slider() {
                             ((state.slider_position + 65535) as f64 / 131071.0 * 255.0) as u8
                         } else {
                             // Sure, 0 is the neutraal position and all that,
diff --git a/src/seat/tablet_tool.rs b/src/seat/tablet_tool.rs
index eed4391d5..afebcd4ac 100644
--- a/src/seat/tablet_tool.rs
+++ b/src/seat/tablet_tool.rs
@@ -33,6 +33,87 @@ pub enum InitEvent {
     Capability(Capability),
 }
 
+// Just a named tuple.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct HardwareSerialOrId {
+    pub hi: u32,
+    pub lo: u32,
+}
+
+/// Static information about the tool and its capabilities.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Description {
+    // Wish this was #[repr(u8)]… it’s wasting four bytes.
+    r#type: Type,
+    // These are really Option<_>, but I squeezed their None discriminant into capabilities,
+    // as it had two spare bits. This saves eight bytes. You’re welcome. 😛
+    hardware_serial: HardwareSerialOrId,
+    hardware_id_wacom: HardwareSerialOrId,
+    // Could have used bitflags here—it is already a dep—but we don’t need its complexity.
+    // Only real loss from this simplicity is meaningful Debug.
+    capabilities: u8,
+}
+
+impl Default for Description {
+    fn default() -> Description {
+        Description {
+            // I get the impression type is mandatory,
+            // so this should be overwritten with the correct value.
+            // But if not… meh, Pen would be the default anyway.
+            r#type: Type::Pen,
+            hardware_serial: HardwareSerialOrId { hi: 0, lo: 0 },
+            hardware_id_wacom: HardwareSerialOrId { hi: 0, lo: 0 },
+            capabilities: 0,
+        }
+    }
+}
+
+const TILT:              u8 = 0b00000001;
+const PRESSURE:          u8 = 0b00000010;
+const DISTANCE:          u8 = 0b00000100;
+const ROTATION:          u8 = 0b00001000;
+const SLIDER:            u8 = 0b00010000;
+const WHEEL:             u8 = 0b00100000;
+
+const HARDWARE_SERIAL:   u8 = 0b01000000;
+const HARDWARE_ID_WACOM: u8 = 0b10000000;
+
+impl Description {
+    /// The type of tool.
+    pub fn r#type(&self) -> Type { self.r#type }
+
+    /// What the hardware serial number of the tool is, if any.
+    pub fn hardware_serial(&self) -> Option<HardwareSerialOrId> {
+        if self.capabilities & HARDWARE_SERIAL != 0 {
+            Some(self.hardware_serial)
+        } else {
+            None
+        }
+    }
+
+    /// What the Wacom hardware ID of the tool is, if any.
+    pub fn hardware_id_wacom(&self) -> Option<HardwareSerialOrId> {
+        if self.capabilities & HARDWARE_ID_WACOM != 0 {
+            Some(self.hardware_id_wacom)
+        } else {
+            None
+        }
+    }
+
+    /// Whether the tool supports tilt.
+    pub fn supports_tilt(&self)     -> bool { self.capabilities & TILT     != 0 }
+    /// Whether the tool supports pressure.
+    pub fn supports_pressure(&self) -> bool { self.capabilities & PRESSURE != 0 }
+    /// Whether the tool can track its distance from the surface.
+    pub fn supports_distance(&self) -> bool { self.capabilities & DISTANCE != 0 }
+    /// Whether the tool can measure z-axis rotation.
+    pub fn supports_rotation(&self) -> bool { self.capabilities & ROTATION != 0 }
+    /// Whether the tool has a slider.
+    pub fn supports_slider(&self)   -> bool { self.capabilities & SLIDER   != 0 }
+    /// Whether the tool has a wheel.
+    pub fn supports_wheel(&self)    -> bool { self.capabilities & WHEEL    != 0 }
+}
+
 #[derive(Debug)]
 pub struct Frame {
     /// The time of the event with millisecond granularity
@@ -178,7 +259,7 @@ pub trait Handler: Sized {
         conn: &Connection,
         qh: &QueueHandle<Self>,
         tablet: &ZwpTabletToolV2,
-        events: InitEventList,
+        description: Description,
     );
 
     /// Sent when the tablet has been removed from the system.
@@ -222,9 +303,9 @@ pub type EventList = SmallVec<[Event; 3]>;
 
 #[derive(Debug, Default)]
 struct DataInner {
-    /// List of pending init-time events, flushed when a `done` event comes in,
+    /// An accumulation of pending init-time events, flushed when a `done` event comes in,
     /// after which it will be perpetually empty.
-    pending_init: InitEventList,
+    description: Description,
 
     /// List of pending events, flushed when a `frame` event comes in.
     pending_frame: EventList,
@@ -244,6 +325,7 @@ where
         qh: &QueueHandle<D>,
     ) {
         let mut guard = udata.inner.lock().unwrap();
+
         match event {
 
             // Initial burst of static description events
@@ -252,35 +334,50 @@ where
             // zero or one HardwareIdWacom,
             // zero or more Capability,
             // then finished with Done).
-
             zwp_tablet_tool_v2::Event::Type { tool_type } => {
-                guard.pending_init.push(InitEvent::Type(match tool_type {
+                guard.description.r#type = match tool_type {
                     WEnum::Value(tool_type) => tool_type,
                     WEnum::Unknown(unknown) => {
                         log::warn!(target: "sctk", "{}: invalid tablet tool type: {:x}", tool.id(), unknown);
                         return;
                     },
-                }));
+                };
             },
-            zwp_tablet_tool_v2::Event::HardwareSerial { hardware_serial_hi, hardware_serial_lo } => {
-                guard.pending_init.push(InitEvent::HardwareSerial { hi: hardware_serial_hi, lo: hardware_serial_lo });
+            zwp_tablet_tool_v2::Event::HardwareSerial { hardware_serial_hi: hi, hardware_serial_lo: lo } => {
+                guard.description.hardware_serial = HardwareSerialOrId { hi, lo };
+                guard.description.capabilities |= HARDWARE_SERIAL;
             },
-            zwp_tablet_tool_v2::Event::HardwareIdWacom { hardware_id_hi, hardware_id_lo } => {
-                guard.pending_init.push(InitEvent::HardwareIdWacom { hi: hardware_id_hi, lo: hardware_id_lo });
+            zwp_tablet_tool_v2::Event::HardwareIdWacom { hardware_id_hi: hi, hardware_id_lo: lo } => {
+                guard.description.hardware_id_wacom = HardwareSerialOrId { hi, lo };
+                guard.description.capabilities |= HARDWARE_ID_WACOM;
             },
-            zwp_tablet_tool_v2::Event::Capability { capability } => {
-                guard.pending_init.push(InitEvent::Capability(match capability {
-                    WEnum::Value(capability) => capability,
-                    WEnum::Unknown(unknown) => {
-                        log::warn!(target: "sctk", "{}: invalid tablet tool capability: {:x}", tool.id(), unknown);
-                        return;
-                    },
-                }));
+            zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(Capability::Tilt) } => {
+                guard.description.capabilities |= TILT;
+            },
+            zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(Capability::Pressure) } => {
+                guard.description.capabilities |= PRESSURE;
+            },
+            zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(Capability::Distance) } => {
+                guard.description.capabilities |= DISTANCE;
+            },
+            zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(Capability::Rotation) } => {
+                guard.description.capabilities |= ROTATION;
+            },
+            zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(Capability::Slider) } => {
+                guard.description.capabilities |= SLIDER;
+            },
+            zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(Capability::Wheel) } => {
+                guard.description.capabilities |= WHEEL;
+            },
+            zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(_) } => (),
+            zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Unknown(unknown) } => {
+                log::warn!(target: "sctk", "{}: invalid tablet tool type: {:x}", tool.id(), unknown);
+                return;
             },
             zwp_tablet_tool_v2::Event::Done => {
-                let events = mem::take(&mut guard.pending_init);
+                let description = mem::take(&mut guard.description);
                 drop(guard);
-                data.init_done(conn, qh, tool, events);
+                data.init_done(conn, qh, tool, description);
             },
 
             // Destruction

From 29b63c48a629c0aa1c83f87e57ebca4d17ed04fb Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Wed, 19 Mar 2025 16:34:39 +0530
Subject: [PATCH 10/27] Use bitflags for tool capabilities

OK, OK, you win, possibly-saner side of self.

I dunno, though, makes things heavier for dubious gain.
---
 src/seat/tablet_tool.rs | 87 ++++++++++++++++++++++++++++-------------
 1 file changed, 59 insertions(+), 28 deletions(-)

diff --git a/src/seat/tablet_tool.rs b/src/seat/tablet_tool.rs
index afebcd4ac..5a8ead5a3 100644
--- a/src/seat/tablet_tool.rs
+++ b/src/seat/tablet_tool.rs
@@ -1,3 +1,4 @@
+use std::fmt;
 use std::mem;
 use std::sync::Mutex;
 
@@ -40,8 +41,33 @@ pub struct HardwareSerialOrId {
     pub lo: u32,
 }
 
+bitflags::bitflags! {
+    /// What the tool is capable of, beyond basic X/Y coordinates.
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub struct Capabilities: u8 {
+        /// Whether the tool supports tilt.
+        const TILT     = 0b00000001;
+        /// Whether the tool supports pressure.
+        const PRESSURE = 0b00000010;
+        /// Whether the tool can track its distance from the surface.
+        const DISTANCE = 0b00000100;
+        /// Whether the tool can measure z-axis rotation.
+        const ROTATION = 0b00001000;
+        /// Whether the tool has a slider.
+        const SLIDER   = 0b00010000;
+        /// Whether the tool has a wheel.
+        const WHEEL    = 0b00100000;
+
+        // Reserve them, but don’t make them part of the public interface.
+        const _        = 0b01000000;
+        const _        = 0b10000000;
+    }
+}
+const HARDWARE_SERIAL:   Capabilities = Capabilities::from_bits_retain(0b01000000);
+const HARDWARE_ID_WACOM: Capabilities = Capabilities::from_bits_retain(0b10000000);
+
 /// Static information about the tool and its capabilities.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq)]
 pub struct Description {
     // Wish this was #[repr(u8)]… it’s wasting four bytes.
     r#type: Type,
@@ -51,7 +77,19 @@ pub struct Description {
     hardware_id_wacom: HardwareSerialOrId,
     // Could have used bitflags here—it is already a dep—but we don’t need its complexity.
     // Only real loss from this simplicity is meaningful Debug.
-    capabilities: u8,
+    capabilities: Capabilities,
+}
+
+// Manual to Option<…> hardware_serial and hardware_id_wacom.
+impl fmt::Debug for Description {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Description")
+            .field("r#type", &self.r#type)
+            .field("hardware_serial", &self.hardware_serial())
+            .field("hardware_id_wacom", &self.hardware_id_wacom())
+            .field("capabilities", &self.capabilities)
+            .finish()
+    }
 }
 
 impl Default for Description {
@@ -63,28 +101,18 @@ impl Default for Description {
             r#type: Type::Pen,
             hardware_serial: HardwareSerialOrId { hi: 0, lo: 0 },
             hardware_id_wacom: HardwareSerialOrId { hi: 0, lo: 0 },
-            capabilities: 0,
+            capabilities: Capabilities::empty(),
         }
     }
 }
 
-const TILT:              u8 = 0b00000001;
-const PRESSURE:          u8 = 0b00000010;
-const DISTANCE:          u8 = 0b00000100;
-const ROTATION:          u8 = 0b00001000;
-const SLIDER:            u8 = 0b00010000;
-const WHEEL:             u8 = 0b00100000;
-
-const HARDWARE_SERIAL:   u8 = 0b01000000;
-const HARDWARE_ID_WACOM: u8 = 0b10000000;
-
 impl Description {
     /// The type of tool.
     pub fn r#type(&self) -> Type { self.r#type }
 
     /// What the hardware serial number of the tool is, if any.
     pub fn hardware_serial(&self) -> Option<HardwareSerialOrId> {
-        if self.capabilities & HARDWARE_SERIAL != 0 {
+        if self.capabilities.contains(HARDWARE_SERIAL) {
             Some(self.hardware_serial)
         } else {
             None
@@ -93,25 +121,27 @@ impl Description {
 
     /// What the Wacom hardware ID of the tool is, if any.
     pub fn hardware_id_wacom(&self) -> Option<HardwareSerialOrId> {
-        if self.capabilities & HARDWARE_ID_WACOM != 0 {
+        if self.capabilities.contains(HARDWARE_ID_WACOM) {
             Some(self.hardware_id_wacom)
         } else {
             None
         }
     }
 
+    /// What the tool is capable of, beyond basic X/Y coordinates.
+    pub fn capabilities(&self) -> Capabilities { self.capabilities.clone() }
     /// Whether the tool supports tilt.
-    pub fn supports_tilt(&self)     -> bool { self.capabilities & TILT     != 0 }
+    pub fn supports_tilt(&self)     -> bool { self.capabilities.contains(Capabilities::TILT) }
     /// Whether the tool supports pressure.
-    pub fn supports_pressure(&self) -> bool { self.capabilities & PRESSURE != 0 }
+    pub fn supports_pressure(&self) -> bool { self.capabilities.contains(Capabilities::PRESSURE) }
     /// Whether the tool can track its distance from the surface.
-    pub fn supports_distance(&self) -> bool { self.capabilities & DISTANCE != 0 }
+    pub fn supports_distance(&self) -> bool { self.capabilities.contains(Capabilities::DISTANCE) }
     /// Whether the tool can measure z-axis rotation.
-    pub fn supports_rotation(&self) -> bool { self.capabilities & ROTATION != 0 }
+    pub fn supports_rotation(&self) -> bool { self.capabilities.contains(Capabilities::ROTATION) }
     /// Whether the tool has a slider.
-    pub fn supports_slider(&self)   -> bool { self.capabilities & SLIDER   != 0 }
+    pub fn supports_slider(&self)   -> bool { self.capabilities.contains(Capabilities::SLIDER) }
     /// Whether the tool has a wheel.
-    pub fn supports_wheel(&self)    -> bool { self.capabilities & WHEEL    != 0 }
+    pub fn supports_wheel(&self)    -> bool { self.capabilities.contains(Capabilities::WHEEL) }
 }
 
 #[derive(Debug)]
@@ -253,7 +283,8 @@ pub enum Event {
 
 pub trait Handler: Sized {
     /// This is fired at the time of the `zwp_tablet_tool_v2.done` event,
-    /// and coalesces any `type`, `hardware_serial`, `hardware_serial_wacom` and `capability` events that precede it.
+    /// and collects any preceding `name`, `id` and `path` `type`, `hardware_serial`,
+    /// `hardware_serial_wacom` and `capability` events into a [`Description`].
     fn init_done(
         &mut self,
         conn: &Connection,
@@ -352,22 +383,22 @@ where
                 guard.description.capabilities |= HARDWARE_ID_WACOM;
             },
             zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(Capability::Tilt) } => {
-                guard.description.capabilities |= TILT;
+                guard.description.capabilities |= Capabilities::TILT;
             },
             zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(Capability::Pressure) } => {
-                guard.description.capabilities |= PRESSURE;
+                guard.description.capabilities |= Capabilities::PRESSURE;
             },
             zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(Capability::Distance) } => {
-                guard.description.capabilities |= DISTANCE;
+                guard.description.capabilities |= Capabilities::DISTANCE;
             },
             zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(Capability::Rotation) } => {
-                guard.description.capabilities |= ROTATION;
+                guard.description.capabilities |= Capabilities::ROTATION;
             },
             zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(Capability::Slider) } => {
-                guard.description.capabilities |= SLIDER;
+                guard.description.capabilities |= Capabilities::SLIDER;
             },
             zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(Capability::Wheel) } => {
-                guard.description.capabilities |= WHEEL;
+                guard.description.capabilities |= Capabilities::WHEEL;
             },
             zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(_) } => (),
             zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Unknown(unknown) } => {

From efdd0b4fbb4181f176c455949a8dc1ee6be49017 Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Wed, 26 Mar 2025 13:14:45 +0530
Subject: [PATCH 11/27] Quite a bit of poorly-separated work
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

 1. Improved the example a lot:
      • Draws for all stylus positions, not just one per rendered frame;
      • Can finally reuse buffers, as I figured out what was going on,
        why the buffers were still active.
        (Answer: accidentally make N frame requests within a frame,
        get N callbacks. I was rendering three times per frame.)

    Computers are fast.
    My code was doing such stupid things,
    and yet there was no lag because of iit.

 2. Changed tablet_tool quite a bit:
      • Now just using the upstream Event enum for state events.
	Less code, potentially more future-compatible,
      • Guidance on stylus buttons now present.
      • Started moving a couple more bits from the example into sctk,
	with some modifications and fixes: the state accumulator,
	and the tools info/state collection.
	Not yet entirely sure how to handle it, but getting somewhere.
---
 examples/tablet.rs      | 616 ++++++++++++++--------------------------
 src/seat/tablet_tool.rs | 587 ++++++++++++++++++++++++++------------
 2 files changed, 615 insertions(+), 588 deletions(-)

diff --git a/examples/tablet.rs b/examples/tablet.rs
index 4f20b87e9..6799a89b9 100644
--- a/examples/tablet.rs
+++ b/examples/tablet.rs
@@ -1,9 +1,9 @@
 //! An example demonstrating tablets
 
-use std::collections::{HashSet, HashMap};
+use std::collections::HashMap;
 
 use smithay_client_toolkit::{
-    compositor::{CompositorHandler, CompositorState},
+    compositor::{CompositorHandler, CompositorState, Surface},
     delegate_compositor, delegate_output, delegate_keyboard,
     delegate_registry, delegate_tablet, delegate_seat, delegate_shm, delegate_xdg_shell,
     delegate_xdg_window,
@@ -43,6 +43,8 @@ use wayland_protocols::wp::tablet::zv2::client::{
     // zwp_tablet_pad_strip_v2::ZwpTabletPadStripV2,
 };
 
+const TWO_PI: f32 = 2. * std::f32::consts::PI;
+
 const RED: raqote::SolidSource = raqote::SolidSource { r: 221, g: 0, b: 0, a: 255 };
 const GREEN: raqote::SolidSource = raqote::SolidSource { r: 0, g: 170, b: 0, a: 255 };
 const SOLID_RED: raqote::Source = raqote::Source::Solid(RED);
@@ -78,7 +80,7 @@ fn main() {
 
     let window = xdg_shell_state.create_window(surface, WindowDecorations::ServerDefault, &qh);
 
-    window.set_title("A wayland window");
+    window.set_title("Tablet drawing");
     window.set_app_id("io.github.smithay.client-toolkit.Tablet");
     window.set_min_size(Some((256, 256)));
 
@@ -107,9 +109,11 @@ fn main() {
         keyboard_focus: false,
         tablet_seat: None,
         tablets: HashMap::new(),
-        tools: HashMap::new(),
+        tools: tablet_tool::Tools::new(),
+        buffer: None,
+        queued_circles: Vec::new(),
+        redraw_queued: false,
         pool,
-        mode: Mode::Points,
         font,
     };
 
@@ -118,73 +122,6 @@ fn main() {
     }
 }
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-struct Button {
-    serial: u32,
-    button: u32,
-}
-
-/// The current state of the tool.
-///
-/// This covers everything, and may, for some applications,
-/// be the most practical way of perceiving it;
-/// but button is more likely to be desired as events,
-/// and wheel is fundamentally a delta thing,
-/// so for at least them you probably want to consume the events.
-///
-/// Also you won’t get the last frame’s time, if you view it this way,
-/// as a proximity_out event deletes the state.
-#[derive(Debug)]
-struct TabletToolState {
-    // ProximityIn
-    serial: u32,
-    tablet: ZwpTabletV2,
-    surface: wl_surface::WlSurface,
-    // Down (cleared on Up), stores serial
-    down: Option<u32>,
-    // Motion
-    x: f64,
-    y: f64,
-    // Pressure
-    pressure: u16,
-    // Distance
-    distance: u16,
-    // Tilt
-    tilt_x: f64,
-    tilt_y: f64,
-    // Rotation
-    rotation_degrees: f64,
-    // Slider
-    slider_position: i32,
-    // Wheel
-    wheel_degrees: f64,
-    wheel_clicks: i32,
-    // Button
-    buttons: HashSet<Button>,
-}
-
-struct ToolInfoAndState {
-    description: tablet_tool::Description,
-    /// The time the last frame was sent,
-    /// or zero if no frames have come yet.
-    last_frame_time: u32,
-    /// The current state of the tool, if in proximity.
-    state: Option<TabletToolState>,
-}
-
-impl ToolInfoAndState {
-    /// Get the pressure according to the Web Pointer Events API:
-    /// scaled in the range \[0, 1\],
-    /// and set to 0.5 when down if pressure isn’t supported.
-    fn pressure_web(&self) -> f64 {
-        match (self.description.supports_pressure(), &self.state) {
-            (true, &Some(TabletToolState { pressure, .. })) => pressure as f64 / 65535.0,
-            (false, Some(TabletToolState { down: Some(_), .. })) => 0.5,
-            _ => 0.0,
-        }
-    }
-}
-
 struct SimpleWindow {
     registry_state: RegistryState,
     seat_state: SeatState,
@@ -202,13 +139,22 @@ struct SimpleWindow {
     keyboard_focus: bool,
     tablet_seat: Option<ZwpTabletSeatV2>,
     tablets: HashMap<ZwpTabletV2, tablet::Description>,
-    tools: HashMap<ZwpTabletToolV2, ToolInfoAndState>,
+    tools: tablet_tool::Tools,
     pool: SlotPool,
-    mode: Mode,
+    buffer: Option<Buffer>,
+    queued_circles: Vec<Circle>,
+    redraw_queued: bool,
 
     font: font_kit::loaders::freetype::Font,
 }
 
+struct Circle {
+    x: f32,
+    y: f32,
+    radius: f32,
+    color: raqote::SolidSource,
+}
+
 impl CompositorHandler for SimpleWindow {
     fn scale_factor_changed(
         &mut self,
@@ -234,10 +180,14 @@ impl CompositorHandler for SimpleWindow {
         &mut self,
         conn: &Connection,
         qh: &QueueHandle<Self>,
-        _surface: &wl_surface::WlSurface,
+        surface: &wl_surface::WlSurface,
         _time: u32,
     ) {
-        self.draw(conn, qh);
+        println!("t={_time} DRAWING FRAME, got {} pending circles", self.queued_circles.len());
+        if surface == self.window.wl_surface() {
+            self.redraw_queued = false;
+            self.draw(conn, qh, false);
+        }
     }
 
     fn surface_enter(
@@ -304,12 +254,14 @@ impl WindowHandler for SimpleWindow {
         configure: WindowConfigure,
         _serial: u32,
     ) {
-        self.width = configure.new_size.0.map(|v| v.get()).unwrap_or(256);
-        self.height = configure.new_size.1.map(|v| v.get()).unwrap_or(256);
-        if self.mode.is_sketch() {
-            self.reset_sketch_mode();
+        let new_width = configure.new_size.0.map(|v| v.get()).unwrap_or(256);
+        let new_height = configure.new_size.1.map(|v| v.get()).unwrap_or(256);
+        if self.width != new_width || self.height != new_height || self.buffer.is_none() {
+            self.width = new_width;
+            self.height = new_height;
+            self.init_canvas();
         }
-        self.draw(conn, qh);
+        self.draw(conn, qh, true);
     }
 }
 
@@ -345,6 +297,8 @@ impl SeatHandler for SimpleWindow {
 
             self.keyboard = Some(keyboard);
         }
+        // FIXME: this doesn’t seem like the right place to put this.
+        // Where *should* it go?
         if self.tablet_seat.is_none() {
             let tablet_seat = self.tablet_manager.get_tablet_seat(&seat, qh).ok();
             if tablet_seat.is_some() {
@@ -408,8 +362,15 @@ impl KeyboardHandler for SimpleWindow {
         event: KeyEvent,
     ) {
         match event.keysym {
-            Keysym::n => self.toggle_mode(),
-            Keysym::r if self.mode.is_sketch() => self.reset_sketch_mode(),
+            Keysym::Delete => {
+                self.clear_canvas();
+                self.queued_circles.clear();
+                if let Some(buffer) = &self.buffer {
+                    let surface = self.window.wl_surface();
+                    buffer.attach_to(surface).expect("buffer attach");
+                    surface.commit();
+                }
+            },
             _ => (),
         }
     }
@@ -500,127 +461,126 @@ impl tablet_tool::Handler for SimpleWindow {
         &mut self,
         _conn: &Connection,
         _qh: &QueueHandle<Self>,
-        tablet_tool: &ZwpTabletToolV2,
+        tool: &ZwpTabletToolV2,
         description: tablet_tool::Description,
     ) {
-        println!("Tablet tool {} initialised: {:#?}", tablet_tool.id(), description);
-        self.tools.insert(tablet_tool.clone(), ToolInfoAndState {
-            description,
-            last_frame_time: 0,
-            state: None,
-        });
+        println!("Tablet tool {} initialised: {:#?}", tool.id(), description);
+        self.tools.add(tool.clone(), description);
     }
 
     fn removed(
         &mut self,
         _conn: &Connection,
         _qh: &QueueHandle<Self>,
-        tablet_tool: &ZwpTabletToolV2,
+        tool: &ZwpTabletToolV2,
     ) {
-        println!("Tablet tool {} removed", tablet_tool.id());
+        println!("Tablet tool {} removed", tool.id());
+        self.tools.remove(tool);
     }
 
     fn tablet_tool_frame(
         &mut self,
         _conn: &Connection,
-        _qh: &QueueHandle<Self>,
-        tablet_tool: &ZwpTabletToolV2,
-        frame: tablet_tool::Frame,
+        qh: &QueueHandle<Self>,
+        tool: &ZwpTabletToolV2,
+        events: &[tablet_tool::Event],
     ) {
-        println!("Tablet tool {} frame: {:#?}", tablet_tool.id(), frame);
-        let tablet_tool::Frame { time, events } = frame;
-        let mut events = events.into_iter();
-        let tias = self.tools.get_mut(tablet_tool).unwrap();
-        let state = tias.state.get_or_insert_with(|| {
-            let Some(tablet_tool::Event::ProximityIn { serial, tablet, surface }) = events.next()
-            else {
-                panic!("First zwp_tablet_tool_v2 frame didn’t start with a proximity_in event");
-            };
-            TabletToolState {
-                // ProximityIn
-                serial,
-                tablet,
-                surface,
-                // Down (cleared on Up)
-                down: None,
-                // Motion
-                x: 0.0,
-                y: 0.0,
-                // Pressure
-                pressure: 0,
-                // Distance
-                distance: 0,
-                // Tilt
-                tilt_x: 0.0,
-                tilt_y: 0.0,
-                // Rotation
-                rotation_degrees: 0.0,
-                // Slider
-                slider_position: 0,
-                // Wheel
-                wheel_degrees: 0.0,
-                wheel_clicks: 0,
-                // Button
-                buttons: HashSet::new(),
+        //println!("Tablet tool {} frame: {:#?}", tool.id(), events);
+        let tias = self.tools.ingest_frame(tool, &events);
+
+        if let Some(state) = &tias.state {
+            if state.is_down() {
+                let pressure = tias.pressure_web();
+                let radius = 2.0 * pressure as f32;
+                self.queued_circles.push(Circle {
+                    x: state.x as f32,
+                    y: state.y as f32,
+                    radius,
+                    color: raqote::SolidSource {
+                        r: (state.tilt_x + 90.0 / 180.0 * 255.0) as u8,
+                        g: (state.tilt_y + 90.0 / 180.0 * 255.0) as u8,
+                        b: (state.rotation_degrees / 360.0 * 255.0 % 255.0) as u8,
+                        a: if tias.description.supports_slider() {
+                            ((state.slider_position + 65535) as f64 / 131071.0 * 255.0) as u8
+                        } else {
+                            // Sure, 0 is the neutraal position and all that,
+                            // but semitransparent looks a bit odd,
+                            // so sans slider support, we’ll just go opaque.
+                            // (b being 0 if rotation is not supported is fine.)
+                            255
+                        },
+                    },
+                });
+            }
+
+            /*
+            let width = 32;
+            let height = 32;
+            let (buffer, canvas) = self.pool.create_buffer(
+                width as i32,
+                height as i32,
+                width as i32 * 4,
+                wl_shm::Format::Argb8888
+            ).expect("create buffer");
+            // https://github.com/Smithay/client-toolkit/issues/488 workaround.
+            let canvas = &mut canvas[..width as usize * height as usize * 4];
+
+            let radius = 6.0;
+            let mut dt = raqote::DrawTarget::from_backing(
+                width as i32,
+                height as i32,
+                bytemuck::cast_slice_mut(canvas),
+            );
+            let mut pb = raqote::PathBuilder::new();
+            pb.arc(width as f32 / 2.0, height as f32 / 2.0, radius, 0., TWO_PI);
+            dt.fill(&pb.finish(), &SOLID_RED, &raqote::DrawOptions::new());
+
+            // TODO: text.
+
+            let cursor_surface = Surface::new(&self.compositor_state, qh).unwrap();
+            let cursor_wl_surface = cursor_surface.wl_surface();
+            tool.set_cursor(state.proximity_in_serial, Some(cursor_wl_surface), width / 2, height / 2);
+            buffer.attach_to(cursor_wl_surface).expect("buffer attach");
+            cursor_wl_surface.damage_buffer(0, 0, width as i32, height as i32);
+            cursor_wl_surface.commit();
+            */
+
+            print!("t={} {} x={:7.2} y={:7.2}",
+                tias.last_frame_time,
+                if state.is_down() { "down" } else { " up " },
+                state.x,
+                state.y);
+            if tias.description.supports_pressure() {
+                print!(" pressure={:5}", state.pressure);
+            }
+            if tias.description.supports_tilt() {
+                print!(" tilt_x={:5.2} tilt_y={:5.2}", state.tilt_x, state.tilt_y);
             }
-        });
-        tias.last_frame_time = time;
-
-        for event in events {
-            match event {
-                tablet_tool::Event::ProximityIn { serial, tablet, surface } => {
-                    state.serial = serial;
-                    state.tablet = tablet;
-                    state.surface = surface;
-                },
-                tablet_tool::Event::ProximityOut => {
-                    tias.state = None;
-                    // Given that a frame is supposed to represent a single hardware event,
-                    // I think you can fairly say it’d be mad to proximity_out and
-                    // immediately proximity_in in the same frame.
-                    // So I think we’re OK to just break.
-                    break;
-                },
-                tablet_tool::Event::Down { serial } => {
-                    state.down = Some(serial);
-                },
-                tablet_tool::Event::Up => {
-                    state.down = None;
-                },
-                tablet_tool::Event::Motion { x, y } => {
-                    state.x = x;
-                    state.y = y;
-                },
-                tablet_tool::Event::Pressure { pressure } => {
-                    state.pressure = pressure;
-                },
-                tablet_tool::Event::Distance { distance } => {
-                    state.distance = distance;
-                },
-                tablet_tool::Event::Tilt { tilt_x, tilt_y } => {
-                    state.tilt_x = tilt_x;
-                    state.tilt_y = tilt_y;
-                },
-                tablet_tool::Event::Rotation { degrees } => {
-                    state.rotation_degrees = degrees;
-                },
-                tablet_tool::Event::Slider { position } => {
-                    state.slider_position = position;
-                },
-                tablet_tool::Event::Wheel { degrees, clicks } => {
-                    // These ones use += because they’re deltas, unlike the rest.
-                    state.wheel_degrees += degrees;
-                    state.wheel_clicks += clicks;
-                },
-                tablet_tool::Event::Button { serial, button, pressed } => {
-                    if pressed {
-                        state.buttons.insert(Button { serial, button });
-                    } else {
-                        state.buttons.remove(&Button { serial, button });
-                    }
-                },
+            if tias.description.supports_distance() {
+                print!(" distance={:5}", state.distance);
             }
+            if tias.description.supports_rotation() {
+                print!(" rotation={:6.2}", state.rotation_degrees);
+            }
+            if tias.description.supports_slider() {
+                print!(" slider={:6}", state.slider_position);
+            }
+            if tias.description.supports_wheel() {
+                print!(" wheel={:6.2}", state.wheel_degrees);
+            }
+            if state.stylus_button_1_pressed {
+                print!(" button:1");
+            }
+            if state.stylus_button_2_pressed {
+                print!(" button:2");
+            }
+            if state.stylus_button_3_pressed {
+                print!(" button:3");
+            }
+            println!();
         }
+
+        self.queue_redraw_if_needed(qh);
     }
 }
 
@@ -631,252 +591,106 @@ impl ShmHandler for SimpleWindow {
 }
 
 impl SimpleWindow {
-    pub fn draw(&mut self, conn: &Connection, qh: &QueueHandle<Self>) {
-        match self.mode {
-            Mode::Points => self.draw_point(conn, qh),
-            Mode::Sketch { .. } => self.draw_sketch(conn, qh),
+    fn queue_redraw_if_needed(&mut self, qh: &QueueHandle<Self>) {
+        if !self.redraw_queued {
+            if !self.queued_circles.is_empty() {
+                self.queue_redraw(qh);
+            }
         }
     }
 
-    pub fn draw_point(&mut self, _conn: &Connection, qh: &QueueHandle<Self>) {
-        let width = self.width;
-        let height = self.height;
-        let stride = self.width as i32 * 4;
-
-        let buffer = self.pool
-            .create_buffer(width as i32, height as i32, stride, wl_shm::Format::Xrgb8888)
-            .expect("create buffer")
-            .0;
-
-        let mut dt = raqote::DrawTarget::from_backing(
-            width as i32,
-            height as i32,
-            bytemuck::cast_slice_mut(self.pool.canvas(&buffer).unwrap()),
-        );
-        dt.clear(WHITE);
-        let mut y = 16.;
-        if self.tablets.is_empty() {
-            dt.draw_text(
-                &self.font,
-                14.,
-                "No tablets found",
-                raqote::Point::new(2., y),
-                &SOLID_RED,
-                &raqote::DrawOptions::new(),
-            );
-        } else {
-            for (tablet, description) in &self.tablets {
-                let text = match &description.name {
-                    Some(name) => name,
-                    None => &*tablet.id().to_string(),
-                };
-                dt.draw_text(
-                    &self.font,
-                    14.,
-                    text,
-                    raqote::Point::new(2., y),
-                    &SOLID_BLACK,
-                    &raqote::DrawOptions::new(),
-                );
-                y += 16.0;
-            }
+    fn queue_redraw(&mut self, qh: &QueueHandle<Self>) {
+        if !self.redraw_queued {
+            println!("   → Queueing redraw");
+            let surface = self.window.wl_surface();
+            surface.frame(qh, surface.clone());
+            // Have to commit to make the frame request.
+            surface.commit();
+            self.redraw_queued = true;
         }
+    }
 
-        for tias in self.tools.values() {
-            if let Some(state) = &tias.state {
-                let mut pb = raqote::PathBuilder::new();
-                let pressure = tias.pressure_web();
-                pb.arc(
-                    state.x as f32,// * self.width as f32,
-                    state.y as f32,// * self.height as f32,
-                    10.0 + 30.0 * pressure as f32,
-                    0.,
-                    2. * std::f32::consts::PI,
-                );
-                pb.close();
-                dt.fill(
-                    &pb.finish(),
-                    &if state.down.is_some() { SOLID_GREEN } else { SOLID_RED },
-                    &raqote::DrawOptions::new(),
-                );
-            }
+    pub fn draw(&mut self, _conn: &Connection, _qh: &QueueHandle<Self>, force: bool) {
+        if self.queued_circles.is_empty() && !force {
+            println!("Draw called with nothing to do!");
+            // False alarm, we don’t actually have anything to draw.
+            // Nothing to draw, wait until we have something to draw.
+            return;
         }
 
-        // Damage the entire window
-        let surface = self.window.wl_surface();
-        surface.damage_buffer(0, 0, self.width as i32, self.height as i32);
-
-        // Request our next frame
-        surface.frame(qh, surface.clone());
-
-        // Attach and commit to present.
-        buffer.attach_to(surface).expect("buffer attach");
-        surface.commit();
-    }
-
-    fn draw_sketch(&mut self, _conn: &Connection, qh: &QueueHandle<Self>) {
-        let Mode::Sketch { buffer, busy_buffer } = &mut self.mode
-        else { unreachable!() };
-
-        println!("draw_sketch");
-        let canvas = match self.pool.canvas(buffer) {
-            Some(canvas) => canvas,
-            None => {
-                // I don’t know if I’m using this wrong,
-                // but I want to copy from one buffer to another buffer,
-                // which I understand is allowed (see below),
-                // and I suppose they should both go in the same SlotPool,
-                // but the use of &mut prevents me accessing both at once,
-                // and… and… and… meh, I’m just going to do something stupid for now.
-                // TODO find out from someone who actually knows what they’re doing,
-                // what the appropriate solution is.
-                let old_canvas = unsafe {
-                    std::mem::transmute::<&'_ mut [u8], &'static [u8]>(
-                        self.pool.raw_data_mut(&buffer.slot())
-                    )
-                };
-
-                // This should be rare
-                // (TODO: the rest of this ssentence is found in other examples here,
-                // but I seem to hit it immediatley in Sway, so I dunno if it’s even true),
-                // but if the compositor has not released the previous
-                // buffer, we need double-buffering.
-                let (mut second_buffer, canvas) = self
-                    .pool
-                    .create_buffer(
-                        self.width as i32,
-                        self.height as i32,
-                        self.width as i32 * 4,
-                        wl_shm::Format::Xrgb8888,
-                    )
-                    .expect("create buffer");
-                // Now, we copy from the busy buffer to the new one.
-                // <https://lists.freedesktop.org/archives/wayland-devel/2020-June/041490.html#:~:text=you%20can%20play%20tricks,readbacks%20may%20have%20issues>
-                // tells me that this is safe, but that there may be issues.
-                // I’m out of my depth here.
-                // Maybe that’s why there isn’t a &Buffer → &[u8] method?
-                // Anyway, for now I’ll just do this and hope for the best.
-                canvas.copy_from_slice(old_canvas);
-                // And we swap them. We’ll later need to mark the damage
-                // regions that the busy buffer needs to copy back from this one.
-                std::mem::swap(buffer, &mut second_buffer);
-                *busy_buffer = Some((second_buffer, vec![]));
-                // … but y’know what? For now I’m just going to trash it,
-                // instead of implementing that.
-                // Consider this a stub for a possibly bad idea.
-                *busy_buffer = None;
-                canvas
-            }
-        };
+        let buffer = self.buffer.as_ref().unwrap();
+        let canvas = self.pool.canvas(buffer).expect("buffer is still active");
         let mut dt = raqote::DrawTarget::from_backing(
             self.width as i32,
             self.height as i32,
-            //bytemuck::cast_slice_mut(self.pool.canvas(&buffer).unwrap()),
             bytemuck::cast_slice_mut(canvas),
         );
 
-        let surface = self.window.wl_surface();
-
-        for tool in self.tools.values() {
-            if let Some(state @ TabletToolState { down: Some(_), .. }) = &tool.state {
-                let mut pb = raqote::PathBuilder::new();
-                let pressure = tool.pressure_web();
-
-                let radius = 10.0 * pressure as f32;
-                pb.arc(
-                    state.x as f32,
-                    state.y as f32,
-                    radius,
-                    0.,
-                    2. * std::f32::consts::PI,
-                );
-                pb.close();
-                dt.fill(
-                    &pb.finish(),
-                    &raqote::Source::Solid(raqote::SolidSource {
-                        r: (state.tilt_x + 90.0 / 180.0 * 255.0) as u8,
-                        g: (state.tilt_y + 90.0 / 180.0 * 255.0) as u8,
-                        b: (state.rotation_degrees / 360.0 * 255.0 % 255.0) as u8,
-                        a: if tool.description.supports_slider() {
-                            ((state.slider_position + 65535) as f64 / 131071.0 * 255.0) as u8
-                        } else {
-                            // Sure, 0 is the neutraal position and all that,
-                            // but semitransparent looks a bit odd,
-                            // so sans slider support, we’ll just go opaque.
-                            // (b being 0 if rotation is not supported is fine.)
-                            255
-                        },
-                    }),
-                    &raqote::DrawOptions::new(),
-                );
-
-                surface.damage_buffer(
-                    ((state.x as f32) - radius).floor() as i32,
-                    ((state.y as f32) - radius).floor() as i32,
-                    ((state.x as f32) + radius).ceil() as i32,
-                    ((state.y as f32) + radius).ceil() as i32,
-                );
-            }
+        let mut min_x = i32::MAX;
+        let mut min_y = i32::MAX;
+        let mut max_x = i32::MIN;
+        let mut max_y = i32::MIN;
+        for circle in self.queued_circles.drain(..) {
+            let mut pb = raqote::PathBuilder::new();
+            pb.arc(
+                circle.x,
+                circle.y,
+                circle.radius,
+                0.,
+                TWO_PI,
+            );
+            pb.close();
+            dt.fill(
+                &pb.finish(),
+                &raqote::Source::Solid(circle.color),
+                &raqote::DrawOptions::new(),
+            );
+            min_x = min_x.min((circle.x - circle.radius).floor() as i32);
+            min_y = min_y.min((circle.y - circle.radius).floor() as i32);
+            max_x = max_x.max((circle.x + circle.radius).ceil() as i32);
+            max_y = max_y.max((circle.y + circle.radius).ceil() as i32);
         }
 
-        // Request our next frame
-        surface.frame(qh, surface.clone());
-
-        // Attach and commit to present.
+        let surface = self.window.wl_surface();
+        if let (Some(width), Some(height)) = (max_x.checked_sub(min_x), max_y.checked_sub(min_y)) {
+            surface.damage_buffer(min_x, min_y, width, height);
+        }
         buffer.attach_to(surface).expect("buffer attach");
         surface.commit();
+        println!("Finished drawing frame.");
     }
 
-    fn reset_sketch_mode(&mut self) {
-        let buffer = self.pool
+    /// Initialise the canvas buffer, damaging but not attaching/committing.
+    ///
+    /// This should be called whenever the window is resized, too.
+    fn init_canvas(&mut self) {
+        let (buffer, canvas) = self.pool
             .create_buffer(
                 self.width as i32,
                 self.height as i32,
                 self.width as i32 * 4,
                 wl_shm::Format::Xrgb8888,
             )
-            .expect("create buffer")
-            .0;
-
-        // Now we actually clear the buffer, making everything opaque white.
-        for x in buffer.canvas(&mut self.pool).unwrap() {
-            *x = 255;
-        }
-        self.window.wl_surface().damage_buffer(0, 0, i32::MAX, i32::MAX);
-        self.mode = Mode::Sketch { buffer, busy_buffer: None };
+            .expect("create buffer");
+        // Make everything white.
+        canvas.fill(0xff);
+        self.buffer = Some(buffer);
+        let surface = self.window.wl_surface();
+        surface.damage_buffer(0, 0, i32::MAX, i32::MAX);
     }
 
-    fn toggle_mode(&mut self) {
-        println!("Switching mode to {:?}", self.mode);
-        match self.mode {
-            Mode::Points => self.reset_sketch_mode(),
-            Mode::Sketch { .. } => self.mode = Mode::Points,
+    /// Clear the canvas to white, damaging but not attaching/committing.
+    fn clear_canvas(&mut self) {
+        if let Some(buffer) = &self.buffer {
+            let canvas = self.pool.canvas(buffer).expect("buffer is still active");
+            // Make everything white.
+            canvas.fill(0xff);
+            let surface = self.window.wl_surface();
+            surface.damage_buffer(0, 0, i32::MAX, i32::MAX);
         }
     }
 }
 
-#[derive(Debug)]
-pub enum Mode {
-    Points,
-    Sketch {
-        /// The buffer that gets drawn to and attached to the surface.
-        buffer: Buffer,
-        /// If the first buffer is not released, we swap to this buffer.
-        /// The buffer that gets copied to after drawing, and 
-        busy_buffer: Option<(Buffer, Vec<(i32, i32, i32, i32)>)>,
-    },
-}
-
-impl Mode {
-    fn is_points(&self) -> bool {
-        matches!(self, Mode::Points)
-    }
-
-    fn is_sketch(&self) -> bool {
-        matches!(self, Mode::Sketch { .. })
-    }
-}
-
 delegate_compositor!(SimpleWindow);
 delegate_output!(SimpleWindow);
 delegate_shm!(SimpleWindow);
diff --git a/src/seat/tablet_tool.rs b/src/seat/tablet_tool.rs
index 5a8ead5a3..791d1d13a 100644
--- a/src/seat/tablet_tool.rs
+++ b/src/seat/tablet_tool.rs
@@ -1,3 +1,4 @@
+use std::collections::{hash_map, HashMap};
 use std::fmt;
 use std::mem;
 use std::sync::Mutex;
@@ -18,7 +19,7 @@ use wayland_protocols::wp::tablet::zv2::client::{
     //zwp_tablet_pad_v2::{self, ZwpTabletPadV2},
 };
 
-pub use zwp_tablet_tool_v2::{Capability, Type};
+pub use zwp_tablet_tool_v2::{Capability, Type, Event};
 
 #[derive(Debug)]
 pub enum InitEvent {
@@ -35,6 +36,7 @@ pub enum InitEvent {
 }
 
 // Just a named tuple.
+/// A hardware identifier, just two `u32`s with names `hi` and `lo`.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub struct HardwareSerialOrId {
     pub hi: u32,
@@ -145,142 +147,388 @@ impl Description {
 }
 
 #[derive(Debug)]
-pub struct Frame {
-    /// The time of the event with millisecond granularity
-    pub time: u32,
-    /// All the state changes that have occurred since the previous frame
-    pub events: EventList,
+pub struct InfoAndState {
+    pub description: Description,
+    /// The time the last frame was sent,
+    /// or zero if no frames have come yet.
+    pub last_frame_time: u32,
+    /// The current state of the tool, if in proximity.
+    pub state: Option<State>,
 }
 
-#[derive(Debug)]
-pub enum Event {
-    /// Notification that this tool is focused on a certain surface.
-    ///
-    /// This event can be received when the tool has moved from one surface to another,
-    /// or when the tool has come back into proximity above the surface.
-    ///
-    /// If any button is logically down when the tool comes into proximity,
-    /// the respective `Button` event is sent after the `ProximityIn` event but within the same frame.
-    ProximityIn {
-        serial: u32,
-        tablet: ZwpTabletV2,
-        surface: WlSurface,
-    },
+impl InfoAndState {
+    /// Get the pressure according to the web’s Pointer Events API:
+    /// scaled in the range \[0, 1\],
+    /// and set to 0.5 when down if pressure isn’t supported.
+    pub fn pressure_web(&self) -> f64 {
+        match (self.description.supports_pressure(), &self.state) {
+            (true, &Some(State { pressure, .. })) => pressure as f64 / 65535.0,
+            (false, Some(State { down_serial: Some(_), .. })) => 0.5,
+            _ => 0.0,
+        }
+    }
+}
 
-    /// Notification that this tool has either left proximity,
-    /// or is no longer focused on a certain surface.
-    ///
-    /// When the tablet tool leaves proximity of the tablet,
-    /// button release events are sent for each button that was held down at the time of leaving proximity.
-    /// These events are sent before the `ProximityOut` event but within the same frame.
-    ///
-    /// If the tool stays within proximity of the tablet,
-    /// but the focus changes from one surface to another,
-    /// a button release event may not be sent until the button is actually released or the tool leaves the proximity of the tablet.
-    ProximityOut,
+impl From<Description> for InfoAndState {
+    fn from(description: Description) -> InfoAndState {
+        InfoAndState {
+            description,
+            last_frame_time: 0,
+            state: None,
+        }
+    }
+}
 
-    /// Sent whenever the tablet tool comes in contact with the surface of the tablet.
-    ///
-    /// If the tool is already in contact with the tablet when entering the input region,
-    /// the client owning said region will receive a `ProximityIn` event,
-    /// followed by a `Down` event in the same frame.
-    ///
-    /// Note that this event describes logical contact, not physical contact.
-    /// On some devices, a compositor may not consider a tool in logical contact until a minimum physical pressure threshold is exceeded.
-    Down {
-        serial: u32,
-    },
+#[derive(Debug, Default)]
+pub struct Tools {
+    map: HashMap<ZwpTabletToolV2, InfoAndState>,
+}
 
-    /// Sent whenever the tablet tool stops making contact with the surface of the tablet,
-    /// or when the tablet tool moves out of the input region and the compositor grab (if any) is dismissed.
-    ///
-    /// If the tablet tool moves out of the input region while in contact with the surface of the tablet and the compositor does not have an ongoing grab on the surface,
-    /// the client owning said region will receive an `Up` event,
-    /// followed by a `ProximityOut` event in the same frame.
-    /// If the compositor has an ongoing grab on this device,
-    /// this event sequence is sent whenever the grab is dismissed in the future.
-    ///
-    /// Note that this event describes logical contact, not physical contact.
-    /// On some devices, a compositor may not consider a tool out of logical contact until physical pressure falls below a specific threshold.
-    Up,
-
-    /// Sent whenever a tablet tool moves.
-    Motion {
-        x: f64,
-        y: f64,
-    },
+impl Tools {
+    pub fn new() -> Tools {
+        Tools::default()
+    }
 
-    /// Sent whenever the pressure axis on a tool changes.
-    /// The value of this event is normalized to a value between 0 and 65535.
-    ///
-    /// Note that pressure may be nonzero even when a tool is not in logical contact.
-    /// See the Down and Up events for more details.
-    Pressure {
-        pressure: u16,
-    },
+    pub fn get(&self, tool: &ZwpTabletToolV2) -> Option<&InfoAndState> {
+        self.map.get(tool)
+    }
 
-    /// Sent whenever the distance axis on a tool changes.
-    /// The value of this event is normalized to a value between 0 and 65535.
+    pub fn get_mut(&mut self, tool: &ZwpTabletToolV2) -> Option<&mut InfoAndState> {
+        self.map.get_mut(tool)
+    }
+
+    pub fn add(&mut self, tool: ZwpTabletToolV2, description: Description) {
+        self.map.insert(tool.clone(), InfoAndState {
+            description,
+            last_frame_time: 0,
+            state: None,
+        });
+    }
+
+    pub fn remove(&mut self, tool: &ZwpTabletToolV2) {
+        self.map.remove(tool);
+    }
+
+    /// Apply the events to the record state.
     ///
-    /// Note that distance may be nonzero even when a tool is not in logical contact.
-    /// See the Down and Up events for more details.
-    Distance {
-        distance: u16,
-    },
+    /// Returns it in order to save a superfluous [`.get()`](Self::get) call.
+    pub fn ingest_frame(&mut self, tool: &ZwpTabletToolV2, events: &[Event]) -> &InfoAndState {
+        let mut events = events.into_iter();
+        let ias = self.map.get_mut(tool).unwrap();
+        let state = ias.state.get_or_insert_with(|| {
+            let Some(Event::ProximityIn { serial, tablet, surface }) = events.next()
+            else {
+                panic!("First zwp_tablet_tool_v2 frame didn’t start with a proximity_in event");
+            };
+            State::from_proximity_in(*serial, tablet.clone(), surface.clone())
+        });
+        let Some(Event::Frame { time }) = events.next_back() else { unreachable!() };
+        ias.last_frame_time = *time;
+
+        for event in events {
+            state.apply_event(&event);
+            if let Event::ProximityOut = event {
+                ias.state = None;
+                // Given that a frame is supposed to represent a single hardware event,
+                // I think you can fairly say it’d be mad to proximity_out and
+                // immediately proximity_in in the same frame.
+                // So I think we’re OK to just break.
+                break;
+            }
+        }
+        &*ias
+    }
 
-    /// Sent whenever one or both of the tilt axes on a tool change.
-    /// Each tilt value is in degrees, relative to the z-axis of the tablet.
-    /// The angle is positive when the top of a tool tilts along the positive x or y axis.
-    Tilt {
-        tilt_x: f64,
-        tilt_y: f64,
-    },
+    pub fn values(&self) -> hash_map::Values<'_, ZwpTabletToolV2, InfoAndState> {
+        self.map.values()
+    }
+}
+
+impl<'a> IntoIterator for &'a Tools {
+    type Item = (&'a ZwpTabletToolV2, &'a InfoAndState);
+    type IntoIter = hash_map::Iter<'a, ZwpTabletToolV2, InfoAndState>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.map.iter()
+    }
+}
+
+// TODO: this isn’t the way, but what is?
+impl Handler for Tools {
+    fn init_done(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        tool: &ZwpTabletToolV2,
+        description: Description,
+    ) {
+        self.add(tool.clone(), description);
+    }
 
-    /// Sent whenever the z-rotation axis on the tool changes.
+    fn removed(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        tool: &ZwpTabletToolV2,
+    ) {
+        self.map.remove(tool);
+    }
+
+    fn tablet_tool_frame(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        tool: &ZwpTabletToolV2,
+        events: &[Event],
+    ) {
+        self.ingest_frame(tool, &events);
+    }
+}
+
+/// The current state of the tool, while in proximity.
+///
+/// For many applications, when you receive a frame,
+/// you don’t so much care about the events,
+/// as about capturing the tool’s current total state.
+///
+/// This lets you do that.
+///
+/// Caveats:
+///
+/// - Although the wheel information is captured as completely as possible here,
+///   it should probably be perceived through the event stream;
+///   tablet tool wheels are inherently delta-based,
+///   so error would accumulate if you try to treat them absolutely.
+///
+/// - This only gives a limited view of buttons,
+///   only capturing BTN_STYLUS, BTN_STYLUS2 and BTN_STYLUS3 pressed state,
+///   not serials or even whether they’ve ever been seen.
+///   This is because it makes the interface a good deal nicer,
+///   takes less effort to implement efficiently,
+///   other buttons are extremely improbable
+///   (nothing but stylus inputs have been available since the early-/mid-2010s),
+///   and if you care about serials or other buttons you will surely prefer events.
+//
+// At 176 bytes on a 64-bit platform, this is much larger than it fundamentally *need* be.
+// With effort, you could losslessly encode all but wheel in less than 37 bytes,
+// and with negligible loss you could shrink it to 29 bytes.
+// But we’re trying to make it usefully accessible, not packed ultra-tight.
+// So it’s mildly painfully wasteful instead.
+#[derive(Debug, Clone)]
+pub struct State {
+    // ProximityIn
+    /// The `Event::ProximityIn.serial` value,
+    /// needed for [`ZwpTabletToolV2::set_cursor`] requests.
+    pub proximity_in_serial: u32,
+    pub tablet: ZwpTabletV2,
+    pub surface: WlSurface,
+
+    // Down, Up
+    /// Whether the tool is in logical contact or not.
+    ///
+    /// When down, it carries the serial of the last down event.
+    pub down_serial: Option<u32>,
+
+    // Motion
+    /// The horizontal position, in surface coordinates.
+    pub x: f64,
+    /// The vertical position, in surface coordinates.
+    pub y: f64,
+
+    // Pressure
+    /// The pressure, scaled from 0–65535, if capable (else 0).
+    pub pressure: u16,
+
+    // Distance
+    /// The pressure, scaled from 0–65535, if capable (else 0).
+    pub distance: u16,
+
+    // Tilt
+    /// The pen’s tilt in the positive X axis, in degrees (−90 to 90), if capable.
+    pub tilt_x: f64,
+    /// The pen’s tilt in the positive X axis, in degrees (−90 to 90), if capable.
+    pub tilt_y: f64,
+
+    // Rotation
+    /// The z-axis rotation of the tool, if capable (else 0.0).
     /// The rotation value is in degrees clockwise from the tool's logical neutral position.
-    Rotation {
-        degrees: f64,
-    },
+    pub rotation_degrees: f64,
 
-    /// Sent whenever the slider position on the tool changes.
+    // Slider
+    /// The slider position, if capable (else 0).
     /// The value is normalized between -65535 and 65535,
     /// with 0 as the logical neutral position of the slider.
-    Slider {
-        position: i32,
-    },
+    pub slider_position: i32,
 
-    /// Sent whenever the wheel on the tool emits an event.
-    /// This event contains two values for the same axis change.
+    // Wheel
+    /// The wheel delta in degrees.
     ///
-    /// Clients should choose either value and avoid mixing degrees and clicks.
-    /// The compositor may accumulate values smaller than a logical click and emulate click events when a certain threshold is met.
-    /// Thus, wheel events with non-zero `clicks` values may have different `degrees` values.
-    Wheel {
-        /// The wheel delta in degrees.
-        ///
-        /// This value is in the same orientation as the `wl_pointer.vertical_scroll` axis.
-        degrees: f64,
-        /// The wheel delta in discrete clicks.
-        ///
-        /// This value is in discrete logical clicks of the mouse wheel,
-        /// and may be zero if the movement of the wheel was less than one logical click.
-        clicks: i32,
-    },
+    /// See [Event::Wheel] for more information,
+    /// and guidance on using wheel values.
+    ///
+    /// You will probably prefer to consume events,
+    /// rather than consuming this value.
+    pub wheel_degrees: f64,
+    /// The wheel delta in discrete clicks.
+    ///
+    /// See [Event::Wheel] for more information,
+    /// and guidance on using wheel values.
+    ///
+    /// You will probably prefer to consume events,
+    /// rather than consuming this value.
+    pub wheel_clicks: i32,
+
+    // Button
+    /// Whether [`BTN_STYLUS`] is pressed.
+    pub stylus_button_1_pressed: bool,
+    /// Whether [`BTN_STYLUS2`] is pressed.
+    pub stylus_button_2_pressed: bool,
+    /// Whether [`BTN_STYLUS3`] is pressed.
+    pub stylus_button_3_pressed: bool,
+}
 
-    /// Sent whenever a button on the tool is pressed or released.
+impl State {
+    pub fn is_down(&self) -> bool {
+        self.down_serial.is_some()
+    }
+}
+
+pub fn button_state_to_bool(state: WEnum<zwp_tablet_tool_v2::ButtonState>) -> bool {
+    matches!(state, WEnum::Value(zwp_tablet_tool_v2::ButtonState::Pressed))
+}
+
+impl State {
+    pub fn from_proximity_in(serial: u32, tablet: ZwpTabletV2, surface: WlSurface) -> State {
+        State {
+            proximity_in_serial: serial,
+            tablet,
+            surface,
+            // Initialise the rest to the most meaningful values possible.
+            down_serial: None,
+            x: 0.0,
+            y: 0.0,
+            pressure: 0,
+            distance: 0,
+            tilt_x: 0.0,
+            tilt_y: 0.0,
+            rotation_degrees: 0.0,
+            slider_position: 0,
+            wheel_degrees: 0.0,
+            wheel_clicks: 0,
+            stylus_button_1_pressed: false,
+            stylus_button_2_pressed: false,
+            stylus_button_3_pressed: false,
+        }
+    }
+
+    /// Apply the change described in an event to this state.
     ///
-    /// If a button is held down when the tool moves in or out of proximity,
-    /// button events are generated by the compositor.
-    /// See `ProximityIn` and `ProximityOut` for details.
-    Button {
-        serial: u32,
-        /// The button whose state has changed
-        button: u32,
-        /// Whether the button was pressed (`true`) or released (`false`)
-        pressed: bool,
-    },
+    /// Certain events are ignored:
+    ///
+    /// - Static description events (e.g. `Type` and `Done`) aren’t applicable.
+    /// - `ProximityOut` invalidates this entirely and needs to be applied at a higher level.
+    /// - `ProximityIn` should already have been consumed by the caller
+    ///   (it was what led to creating this object).
+    /// - `Frame` should be consumed by the caller
+    ///   (you can’t store frame time inside here,
+    ///   since it will be deleted by `ProximityOut`,
+    ///   but you might still care about its frame time).
+    ///
+    /// For clarity:
+    /// `ProximityOut` is expected to be passed here (at present), though it’s no-op,
+    /// but `ProximityIn` and `Frame` should both have been consumed.
+    ///
+    /// Also, `Button` is ignored for anything other than the stylus buttons,
+    /// and button serials are discarded.
+    pub fn apply_event(&mut self, event: &Event) {
+        match *event {
+            Event::ProximityOut => {
+                // This invalidates `self`, and must be handled by the caller.
+            },
+            Event::Down { serial } => {
+                self.down_serial = Some(serial);
+            },
+            Event::Up => {
+                self.down_serial = None;
+            },
+            Event::Motion { x, y } => {
+                self.x = x;
+                self.y = y;
+            },
+            Event::Pressure { pressure } => {
+                // “The value of this event is normalized to a value between 0 and 65535.”
+                // But the Wayland wire format only supports 32-bit integers,
+                // so we cast it here. We might as well, I reckon.
+                self.pressure = pressure as u16;
+            },
+            Event::Distance { distance } => {
+                // Same deal, “normalized to a value between 0 and 65535”.
+                self.distance = distance as u16;
+            },
+            Event::Tilt { tilt_x, tilt_y } => {
+                self.tilt_x = tilt_x;
+                self.tilt_y = tilt_y;
+            },
+            Event::Rotation { degrees } => {
+                self.rotation_degrees = degrees;
+            },
+            Event::Slider { position } => {
+                // This one is “normalized between -65535 and 65535”, 17 bits, so it stays i32.
+                self.slider_position = position;
+            },
+            Event::Wheel { degrees, clicks } => {
+                // These ones use += because they’re deltas, unlike the rest.
+                self.wheel_degrees += degrees;
+                self.wheel_clicks += clicks;
+            },
+            Event::Button { serial: _, button: BTN_STYLUS, state } => {
+                self.stylus_button_1_pressed = button_state_to_bool(state);
+            },
+            Event::Button { serial: _, button: BTN_STYLUS2, state } => {
+                self.stylus_button_2_pressed = button_state_to_bool(state);
+            },
+            Event::Button { serial: _, button: BTN_STYLUS3, state } => {
+                self.stylus_button_3_pressed = button_state_to_bool(state);
+            },
+            Event::Button { .. } => {
+                // Ignored; see doc comment.
+            },
+            Event::ProximityIn { .. } | Event::Frame { .. } | _ => {
+                // Should be unreachable; see doc comment.
+            },
+        }
+    }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Button {
+    /// Button state: `true` if pressed, `false` if released.
+    pub pressed: bool,
+    /// The serial for the most recent state change.
+    pub serial: u32,
+}
+
+// From linux/input-event-codes.h.
+// There isn’t a good definition of which buttons tablet tools might use,
+// which I think is why it wasn’t made an enum like type was.
+// (The mailing list thread about this stuff seems a bit inconclusive;
+// I should ask follow-up questions.
+// <https://lists.freedesktop.org/archives/wayland-devel/2016-November/031734.html>)
+//
+// Most tools are stylus variants, and are likely to use these if they have buttons:
+/// The first button on a stylus.
+pub const BTN_STYLUS: u32 = 0x14b;
+/// The second button on a stylus.
+pub const BTN_STYLUS2: u32 = 0x14c;
+/// The third button on a stylus.
+pub const BTN_STYLUS3: u32 = 0x149;
+//
+// Mouse toools will use BTN_LEFT et al.; but they’re already exported from crate::seat::pointer,
+// and do mouse tools even exist any more?
+// Finger, I have no idea, and I bet they just come through as touchscreen anyway.
+// (Seriously, pen and eraser are probably the only two types of tool that will ever be used.)
+// BTN_0 to BTN_9, I don’t particularly expect such things, that sounds like a pad, not a tool.
+// So, I’ll leave it at just these three stylus constants.
+
 pub trait Handler: Sized {
     /// This is fired at the time of the `zwp_tablet_tool_v2.done` event,
     /// and collects any preceding `name`, `id` and `path` `type`, `hardware_serial`,
@@ -306,12 +554,14 @@ pub trait Handler: Sized {
 
     /// A series of axis and/or button updates have been received from the tablet.
     /// All the events within this frame should be considered one hardware event.
+    /// The last event in the list passed will always be a `Frame` event,
+    /// and there will only be that one frame.
     fn tablet_tool_frame(
         &mut self,
         conn: &Connection,
         qh: &QueueHandle<Self>,
         tablet: &ZwpTabletToolV2,
-        frame: Frame,
+        events: &[Event],
     );
 }
 
@@ -329,9 +579,6 @@ impl Data {
     }
 }
 
-pub type InitEventList = Vec<InitEvent>;
-pub type EventList = SmallVec<[Event; 3]>;
-
 #[derive(Debug, Default)]
 struct DataInner {
     /// An accumulation of pending init-time events, flushed when a `done` event comes in,
@@ -339,9 +586,30 @@ struct DataInner {
     description: Description,
 
     /// List of pending events, flushed when a `frame` event comes in.
-    pending_frame: EventList,
+    pending: EventList,
 }
 
+/// A list of data frame events.
+//
+// Whereas PointerHandler gets given &[PointerEvent],
+// I’ve chosen to expose SmallVec here for practicality,
+// and to skip unnecessary potential clones of `ProximityIn`’s tablet and surface.
+// If we wanted to keep this but not expose SmallVec,
+// we’d newtype smallvec::Drain, duplicating all its surface area.
+// I might have done that, but when it doesn’t implement as_slice like Vec’s,
+// I become less enthusiastic.
+// I’m not convinced it’s worth the bother.
+//
+// Explanation on chosen sizing:
+//  • There will always be at least two events: one axis change, and a Frame.
+//  • Three is fundamentally common, when you have proximity and tip events.
+//  • Pressure will be almost ubiquitous, so add one for that.
+//  • Tilt will be very common too.
+// My opinion, unmeasured save by eyeballing an event stream on a tilt+pressure-capable pen,
+// is that four is probably the sweet spot.
+// Ability to tweak that number would be a good reason to encapsulate this…!
+pub type EventList = SmallVec<[Event; 4]>;
+
 impl<D> Dispatch<ZwpTabletToolV2, Data, D>
     for super::TabletManager
 where
@@ -423,73 +691,18 @@ where
             // with some restrictions on ordering and such;
             // then finished with Frame).
 
-            zwp_tablet_tool_v2::Event::ProximityIn { serial, tablet, surface } => {
-                guard.pending_frame.push(Event::ProximityIn { serial, tablet, surface });
-            },
-            zwp_tablet_tool_v2::Event::ProximityOut => {
-                guard.pending_frame.push(Event::ProximityOut);
-            },
-            zwp_tablet_tool_v2::Event::Down { serial } => {
-                guard.pending_frame.push(Event::Down { serial });
-            },
-            zwp_tablet_tool_v2::Event::Up => {
-                guard.pending_frame.push(Event::Up);
-            },
-            zwp_tablet_tool_v2::Event::Motion { x, y } => {
-                guard.pending_frame.push(Event::Motion { x, y });
-            },
-            zwp_tablet_tool_v2::Event::Pressure { pressure } => {
-                // “The value of this event is normalized to a value between 0 and 65535.”
-                // But the wayland Wire format only supports 32-bit integers, so we cast it.
-                // <https://wayland.freedesktop.org/docs/html/ch04.html#:~:text=xml.-,Wire%20Format>.
-                guard.pending_frame.push(Event::Pressure { pressure: pressure as u16 });
-            },
-            zwp_tablet_tool_v2::Event::Distance { distance } => {
-                // Same deal, “normalized to a value between 0 and 65535”.
-                guard.pending_frame.push(Event::Distance { distance: distance as u16 });
-            },
-            zwp_tablet_tool_v2::Event::Tilt { tilt_x, tilt_y } => {
-                guard.pending_frame.push(Event::Tilt { tilt_x, tilt_y });
-            },
-            zwp_tablet_tool_v2::Event::Rotation { degrees } => {
-                guard.pending_frame.push(Event::Rotation { degrees });
-            },
-            zwp_tablet_tool_v2::Event::Slider { position } => {
-                // This one is “normalized between -65535 and 65535”, 17 bits, so it stays i32.
-                guard.pending_frame.push(Event::Slider { position });
-            },
-            zwp_tablet_tool_v2::Event::Wheel { degrees, clicks } => {
-                guard.pending_frame.push(Event::Wheel { degrees, clicks });
-            },
-            zwp_tablet_tool_v2::Event::Button { serial, button, state } => {
-                guard.pending_frame.push(Event::Button {
-                    serial,
-                    button,
-                    pressed: match state {
-                        WEnum::Value(zwp_tablet_tool_v2::ButtonState::Pressed) => true,
-                        WEnum::Value(zwp_tablet_tool_v2::ButtonState::Released) => false,
-                        WEnum::Value(_) => unreachable!(),
-                        WEnum::Unknown(unknown) => {
-                            log::warn!(target: "sctk", "{}: invalid tablet tool button state: {:x}", tool.id(), unknown);
-                            return;
-                        },
-                    },
-                });
-            },
-            zwp_tablet_tool_v2::Event::Frame { time } => {
-                // TODO: pass ownership of the events list.
-                // I was copying what something else did around here,
-                // but since we don’t do anything more with them,
-                // it would be better to cede ownership.
-                // The only issue is that it exposes SmallVec what is nicer an implementation type.
-                let events = mem::take(&mut guard.pending_frame);
+            zwp_tablet_tool_v2::Event::Frame { .. } => {
+                let mut events = mem::take(&mut guard.pending);
                 drop(guard);
-                data.tablet_tool_frame(conn, qh, tool, Frame {
-                    time,
-                    events,
-                });
+                events.push(event);
+                data.tablet_tool_frame(conn, qh, tool, &events);
             },
-            _ => unreachable!(),
+            // Could enumerate all the events,
+            // but honestly it’s just easier to do this,
+            // since we’re passing it through,
+            // not reframing in any way.
+            _ => guard.pending.push(event),
+
         }
     }
 }

From 0004673296a71368317bfe3a02facf11d2fd932d Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Wed, 26 Mar 2025 15:20:28 +0530
Subject: [PATCH 12/27] Remove dead code
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This should have been deleted a while ago,
but I can’t be bothered editing the history because of restructurings.
---
 src/seat/tablet.rs | 19 -------------------
 1 file changed, 19 deletions(-)

diff --git a/src/seat/tablet.rs b/src/seat/tablet.rs
index 716e2d623..70f269a08 100644
--- a/src/seat/tablet.rs
+++ b/src/seat/tablet.rs
@@ -8,25 +8,6 @@ use wayland_client::{
 };
 use wayland_protocols::wp::tablet::zv2::client::zwp_tablet_v2::{self, ZwpTabletV2};
 
-#[derive(Debug)]
-pub enum Event {
-    /// The descriptive name of the tablet device
-    Name {
-        name: String,
-    },
-    /// The USB vendor and product IDs for the tablet device
-    Id {
-        vid: u32,
-        pid: u32,
-    },
-    /// System-specific device paths for the tablet.
-    ///
-    /// Path format is unspecified. Clients must figure out what to do with them, if they care.
-    Path {
-        path: String,
-    },
-}
-
 pub trait Handler: Sized {
     /// This is fired at the time of the `zwp_tablet_v2.done` event,
     /// and collects any preceding `name`, `id` and `path` events into a [`Description`].

From 666c52c441c50122e6ef7c5127d509036252090a Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Wed, 26 Mar 2025 16:59:45 +0530
Subject: [PATCH 13/27] Revise some tablet naming
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

  • description → info, because I found another part of sctk using that,
    which tips the balance enough for me
    (wasn’t fond of “description”’s length, anyway).

  • init_done → info, for feeling consistent, maybe

  • tablet_tool_frame → frame, for feeling consistent, maybe
---
 examples/tablet.rs      | 34 +++++++++----------
 src/seat/tablet.rs      | 18 +++++-----
 src/seat/tablet_tool.rs | 74 ++++++++++++++++++++---------------------
 3 files changed, 63 insertions(+), 63 deletions(-)

diff --git a/examples/tablet.rs b/examples/tablet.rs
index 6799a89b9..56f50a270 100644
--- a/examples/tablet.rs
+++ b/examples/tablet.rs
@@ -138,7 +138,7 @@ struct SimpleWindow {
     keyboard: Option<wl_keyboard::WlKeyboard>,
     keyboard_focus: bool,
     tablet_seat: Option<ZwpTabletSeatV2>,
-    tablets: HashMap<ZwpTabletV2, tablet::Description>,
+    tablets: HashMap<ZwpTabletV2, tablet::Info>,
     tools: tablet_tool::Tools,
     pool: SlotPool,
     buffer: Option<Buffer>,
@@ -434,15 +434,15 @@ impl tablet_seat::Handler for SimpleWindow {
 }
 
 impl tablet::Handler for SimpleWindow {
-    fn init_done(
+    fn info(
         &mut self,
         _: &Connection,
         _: &QueueHandle<Self>,
         tablet: &ZwpTabletV2,
-        description: tablet::Description,
+        info: tablet::Info,
     ) {
-        println!("Tablet {} initialised: {:#?}", tablet.id(), description);
-        self.tablets.insert(tablet.clone(), description);
+        println!("Tablet {} initialised: {:#?}", tablet.id(), info);
+        self.tablets.insert(tablet.clone(), info);
     }
 
     fn removed(
@@ -457,15 +457,15 @@ impl tablet::Handler for SimpleWindow {
 }
 
 impl tablet_tool::Handler for SimpleWindow {
-    fn init_done(
+    fn info(
         &mut self,
         _conn: &Connection,
         _qh: &QueueHandle<Self>,
         tool: &ZwpTabletToolV2,
-        description: tablet_tool::Description,
+        info: tablet_tool::Info,
     ) {
-        println!("Tablet tool {} initialised: {:#?}", tool.id(), description);
-        self.tools.add(tool.clone(), description);
+        println!("Tablet tool {} initialised: {:#?}", tool.id(), info);
+        self.tools.add(tool.clone(), info);
     }
 
     fn removed(
@@ -478,7 +478,7 @@ impl tablet_tool::Handler for SimpleWindow {
         self.tools.remove(tool);
     }
 
-    fn tablet_tool_frame(
+    fn frame(
         &mut self,
         _conn: &Connection,
         qh: &QueueHandle<Self>,
@@ -500,7 +500,7 @@ impl tablet_tool::Handler for SimpleWindow {
                         r: (state.tilt_x + 90.0 / 180.0 * 255.0) as u8,
                         g: (state.tilt_y + 90.0 / 180.0 * 255.0) as u8,
                         b: (state.rotation_degrees / 360.0 * 255.0 % 255.0) as u8,
-                        a: if tias.description.supports_slider() {
+                        a: if tias.info.supports_slider() {
                             ((state.slider_position + 65535) as f64 / 131071.0 * 255.0) as u8
                         } else {
                             // Sure, 0 is the neutraal position and all that,
@@ -550,22 +550,22 @@ impl tablet_tool::Handler for SimpleWindow {
                 if state.is_down() { "down" } else { " up " },
                 state.x,
                 state.y);
-            if tias.description.supports_pressure() {
+            if tias.info.supports_pressure() {
                 print!(" pressure={:5}", state.pressure);
             }
-            if tias.description.supports_tilt() {
+            if tias.info.supports_tilt() {
                 print!(" tilt_x={:5.2} tilt_y={:5.2}", state.tilt_x, state.tilt_y);
             }
-            if tias.description.supports_distance() {
+            if tias.info.supports_distance() {
                 print!(" distance={:5}", state.distance);
             }
-            if tias.description.supports_rotation() {
+            if tias.info.supports_rotation() {
                 print!(" rotation={:6.2}", state.rotation_degrees);
             }
-            if tias.description.supports_slider() {
+            if tias.info.supports_slider() {
                 print!(" slider={:6}", state.slider_position);
             }
-            if tias.description.supports_wheel() {
+            if tias.info.supports_wheel() {
                 print!(" wheel={:6.2}", state.wheel_degrees);
             }
             if state.stylus_button_1_pressed {
diff --git a/src/seat/tablet.rs b/src/seat/tablet.rs
index 70f269a08..c604867ff 100644
--- a/src/seat/tablet.rs
+++ b/src/seat/tablet.rs
@@ -10,13 +10,13 @@ use wayland_protocols::wp::tablet::zv2::client::zwp_tablet_v2::{self, ZwpTabletV
 
 pub trait Handler: Sized {
     /// This is fired at the time of the `zwp_tablet_v2.done` event,
-    /// and collects any preceding `name`, `id` and `path` events into a [`Description`].
-    fn init_done(
+    /// and collects any preceding `name`, `id` and `path` events into an [`Info`].
+    fn info(
         &mut self,
         conn: &Connection,
         qh: &QueueHandle<Self>,
         tablet: &ZwpTabletV2,
-        description: Description,
+        info: Info,
     );
 
     /// Sent when the tablet has been removed from the system.
@@ -33,7 +33,7 @@ pub trait Handler: Sized {
 
 /// The description of a tablet device.
 #[derive(Debug, Default)]
-pub struct Description {
+pub struct Info {
     /// The descriptive name of the tablet device.
     pub name: Option<String>,
     /// The USB vendor and product IDs for the tablet device.
@@ -48,12 +48,12 @@ pub struct Description {
 #[doc(hidden)]
 #[derive(Debug)]
 pub struct Data {
-    description: Mutex<Description>,
+    info: Mutex<Info>,
 }
 
 impl Data {
     pub fn new() -> Self {
-        Self { description: Default::default() }
+        Self { info: Default::default() }
     }
 }
 
@@ -70,15 +70,15 @@ where
         conn: &Connection,
         qh: &QueueHandle<D>,
     ) {
-        let mut guard = udata.description.lock().unwrap();
+        let mut guard = udata.info.lock().unwrap();
         match event {
             zwp_tablet_v2::Event::Name { name } => guard.name = Some(name),
             zwp_tablet_v2::Event::Id { vid, pid } => guard.id = Some((vid, pid)),
             zwp_tablet_v2::Event::Path { path } => guard.paths.push(path),
             zwp_tablet_v2::Event::Done => {
-                let description = mem::take(&mut *guard);
+                let info = mem::take(&mut *guard);
                 drop(guard);
-                data.init_done(conn, qh, tablet, description);
+                data.info(conn, qh, tablet, info);
             },
             zwp_tablet_v2::Event::Removed => {
                 data.removed(conn, qh, tablet);
diff --git a/src/seat/tablet_tool.rs b/src/seat/tablet_tool.rs
index 791d1d13a..07354de29 100644
--- a/src/seat/tablet_tool.rs
+++ b/src/seat/tablet_tool.rs
@@ -70,7 +70,7 @@ const HARDWARE_ID_WACOM: Capabilities = Capabilities::from_bits_retain(0b1000000
 
 /// Static information about the tool and its capabilities.
 #[derive(Clone, PartialEq, Eq)]
-pub struct Description {
+pub struct Info {
     // Wish this was #[repr(u8)]… it’s wasting four bytes.
     r#type: Type,
     // These are really Option<_>, but I squeezed their None discriminant into capabilities,
@@ -83,9 +83,9 @@ pub struct Description {
 }
 
 // Manual to Option<…> hardware_serial and hardware_id_wacom.
-impl fmt::Debug for Description {
+impl fmt::Debug for Info {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Description")
+        f.debug_struct("Info")
             .field("r#type", &self.r#type)
             .field("hardware_serial", &self.hardware_serial())
             .field("hardware_id_wacom", &self.hardware_id_wacom())
@@ -94,9 +94,9 @@ impl fmt::Debug for Description {
     }
 }
 
-impl Default for Description {
-    fn default() -> Description {
-        Description {
+impl Default for Info {
+    fn default() -> Info {
+        Info {
             // I get the impression type is mandatory,
             // so this should be overwritten with the correct value.
             // But if not… meh, Pen would be the default anyway.
@@ -108,7 +108,7 @@ impl Default for Description {
     }
 }
 
-impl Description {
+impl Info {
     /// The type of tool.
     pub fn r#type(&self) -> Type { self.r#type }
 
@@ -148,7 +148,7 @@ impl Description {
 
 #[derive(Debug)]
 pub struct InfoAndState {
-    pub description: Description,
+    pub info: Info,
     /// The time the last frame was sent,
     /// or zero if no frames have come yet.
     pub last_frame_time: u32,
@@ -161,7 +161,7 @@ impl InfoAndState {
     /// scaled in the range \[0, 1\],
     /// and set to 0.5 when down if pressure isn’t supported.
     pub fn pressure_web(&self) -> f64 {
-        match (self.description.supports_pressure(), &self.state) {
+        match (self.info.supports_pressure(), &self.state) {
             (true, &Some(State { pressure, .. })) => pressure as f64 / 65535.0,
             (false, Some(State { down_serial: Some(_), .. })) => 0.5,
             _ => 0.0,
@@ -169,10 +169,10 @@ impl InfoAndState {
     }
 }
 
-impl From<Description> for InfoAndState {
-    fn from(description: Description) -> InfoAndState {
+impl From<Info> for InfoAndState {
+    fn from(info: Info) -> InfoAndState {
         InfoAndState {
-            description,
+            info,
             last_frame_time: 0,
             state: None,
         }
@@ -197,9 +197,9 @@ impl Tools {
         self.map.get_mut(tool)
     }
 
-    pub fn add(&mut self, tool: ZwpTabletToolV2, description: Description) {
+    pub fn add(&mut self, tool: ZwpTabletToolV2, info: Info) {
         self.map.insert(tool.clone(), InfoAndState {
-            description,
+            info,
             last_frame_time: 0,
             state: None,
         });
@@ -254,14 +254,14 @@ impl<'a> IntoIterator for &'a Tools {
 
 // TODO: this isn’t the way, but what is?
 impl Handler for Tools {
-    fn init_done(
+    fn info(
         &mut self,
         _: &Connection,
         _: &QueueHandle<Self>,
         tool: &ZwpTabletToolV2,
-        description: Description,
+        info: Info,
     ) {
-        self.add(tool.clone(), description);
+        self.add(tool.clone(), info);
     }
 
     fn removed(
@@ -273,7 +273,7 @@ impl Handler for Tools {
         self.map.remove(tool);
     }
 
-    fn tablet_tool_frame(
+    fn frame(
         &mut self,
         _: &Connection,
         _: &QueueHandle<Self>,
@@ -532,13 +532,13 @@ pub const BTN_STYLUS3: u32 = 0x149;
 pub trait Handler: Sized {
     /// This is fired at the time of the `zwp_tablet_tool_v2.done` event,
     /// and collects any preceding `name`, `id` and `path` `type`, `hardware_serial`,
-    /// `hardware_serial_wacom` and `capability` events into a [`Description`].
-    fn init_done(
+    /// `hardware_serial_wacom` and `capability` events into an [`Info`].
+    fn info(
         &mut self,
         conn: &Connection,
         qh: &QueueHandle<Self>,
         tablet: &ZwpTabletToolV2,
-        description: Description,
+        info: Info,
     );
 
     /// Sent when the tablet has been removed from the system.
@@ -556,7 +556,7 @@ pub trait Handler: Sized {
     /// All the events within this frame should be considered one hardware event.
     /// The last event in the list passed will always be a `Frame` event,
     /// and there will only be that one frame.
-    fn tablet_tool_frame(
+    fn frame(
         &mut self,
         conn: &Connection,
         qh: &QueueHandle<Self>,
@@ -583,7 +583,7 @@ impl Data {
 struct DataInner {
     /// An accumulation of pending init-time events, flushed when a `done` event comes in,
     /// after which it will be perpetually empty.
-    description: Description,
+    info: Info,
 
     /// List of pending events, flushed when a `frame` event comes in.
     pending: EventList,
@@ -634,7 +634,7 @@ where
             // zero or more Capability,
             // then finished with Done).
             zwp_tablet_tool_v2::Event::Type { tool_type } => {
-                guard.description.r#type = match tool_type {
+                guard.info.r#type = match tool_type {
                     WEnum::Value(tool_type) => tool_type,
                     WEnum::Unknown(unknown) => {
                         log::warn!(target: "sctk", "{}: invalid tablet tool type: {:x}", tool.id(), unknown);
@@ -643,30 +643,30 @@ where
                 };
             },
             zwp_tablet_tool_v2::Event::HardwareSerial { hardware_serial_hi: hi, hardware_serial_lo: lo } => {
-                guard.description.hardware_serial = HardwareSerialOrId { hi, lo };
-                guard.description.capabilities |= HARDWARE_SERIAL;
+                guard.info.hardware_serial = HardwareSerialOrId { hi, lo };
+                guard.info.capabilities |= HARDWARE_SERIAL;
             },
             zwp_tablet_tool_v2::Event::HardwareIdWacom { hardware_id_hi: hi, hardware_id_lo: lo } => {
-                guard.description.hardware_id_wacom = HardwareSerialOrId { hi, lo };
-                guard.description.capabilities |= HARDWARE_ID_WACOM;
+                guard.info.hardware_id_wacom = HardwareSerialOrId { hi, lo };
+                guard.info.capabilities |= HARDWARE_ID_WACOM;
             },
             zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(Capability::Tilt) } => {
-                guard.description.capabilities |= Capabilities::TILT;
+                guard.info.capabilities |= Capabilities::TILT;
             },
             zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(Capability::Pressure) } => {
-                guard.description.capabilities |= Capabilities::PRESSURE;
+                guard.info.capabilities |= Capabilities::PRESSURE;
             },
             zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(Capability::Distance) } => {
-                guard.description.capabilities |= Capabilities::DISTANCE;
+                guard.info.capabilities |= Capabilities::DISTANCE;
             },
             zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(Capability::Rotation) } => {
-                guard.description.capabilities |= Capabilities::ROTATION;
+                guard.info.capabilities |= Capabilities::ROTATION;
             },
             zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(Capability::Slider) } => {
-                guard.description.capabilities |= Capabilities::SLIDER;
+                guard.info.capabilities |= Capabilities::SLIDER;
             },
             zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(Capability::Wheel) } => {
-                guard.description.capabilities |= Capabilities::WHEEL;
+                guard.info.capabilities |= Capabilities::WHEEL;
             },
             zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Value(_) } => (),
             zwp_tablet_tool_v2::Event::Capability { capability: WEnum::Unknown(unknown) } => {
@@ -674,9 +674,9 @@ where
                 return;
             },
             zwp_tablet_tool_v2::Event::Done => {
-                let description = mem::take(&mut guard.description);
+                let info = mem::take(&mut guard.info);
                 drop(guard);
-                data.init_done(conn, qh, tool, description);
+                data.info(conn, qh, tool, info);
             },
 
             // Destruction
@@ -695,7 +695,7 @@ where
                 let mut events = mem::take(&mut guard.pending);
                 drop(guard);
                 events.push(event);
-                data.tablet_tool_frame(conn, qh, tool, &events);
+                data.frame(conn, qh, tool, &events);
             },
             // Could enumerate all the events,
             // but honestly it’s just easier to do this,

From b7cb645943b2ba93e21786c49805ec14f10d67e8 Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Wed, 26 Mar 2025 16:59:54 +0530
Subject: [PATCH 14/27] Update some docs, remove obsolete bits

---
 src/seat/tablet_tool.rs | 52 +++++++++++------------------------------
 1 file changed, 13 insertions(+), 39 deletions(-)

diff --git a/src/seat/tablet_tool.rs b/src/seat/tablet_tool.rs
index 07354de29..819a3b5dc 100644
--- a/src/seat/tablet_tool.rs
+++ b/src/seat/tablet_tool.rs
@@ -507,27 +507,15 @@ pub struct Button {
     pub serial: u32,
 }
 
-// From linux/input-event-codes.h.
-// There isn’t a good definition of which buttons tablet tools might use,
-// which I think is why it wasn’t made an enum like type was.
-// (The mailing list thread about this stuff seems a bit inconclusive;
-// I should ask follow-up questions.
-// <https://lists.freedesktop.org/archives/wayland-devel/2016-November/031734.html>)
-//
-// Most tools are stylus variants, and are likely to use these if they have buttons:
+// Based on <https://lists.freedesktop.org/archives/wayland-devel/2025-March/044025.html>:
+// BTN_STYLUS, BTN_STYLUS2 and BTN_STYLUS3 are the only codes likely.
+// Mouse tools are long gone, finger was a mistake—everything’s a stylus.
 /// The first button on a stylus.
 pub const BTN_STYLUS: u32 = 0x14b;
 /// The second button on a stylus.
 pub const BTN_STYLUS2: u32 = 0x14c;
 /// The third button on a stylus.
 pub const BTN_STYLUS3: u32 = 0x149;
-//
-// Mouse toools will use BTN_LEFT et al.; but they’re already exported from crate::seat::pointer,
-// and do mouse tools even exist any more?
-// Finger, I have no idea, and I bet they just come through as touchscreen anyway.
-// (Seriously, pen and eraser are probably the only two types of tool that will ever be used.)
-// BTN_0 to BTN_9, I don’t particularly expect such things, that sounds like a pad, not a tool.
-// So, I’ll leave it at just these three stylus constants.
 
 pub trait Handler: Sized {
     /// This is fired at the time of the `zwp_tablet_tool_v2.done` event,
@@ -568,8 +556,6 @@ pub trait Handler: Sized {
 #[doc(hidden)]
 #[derive(Debug)]
 pub struct Data {
-    //seat: WlSeat,
-    //tablet_seat: ZwpTabletToolSeatV2,
     inner: Mutex<DataInner>,
 }
 
@@ -586,30 +572,18 @@ struct DataInner {
     info: Info,
 
     /// List of pending events, flushed when a `frame` event comes in.
-    pending: EventList,
+    ///
+    /// Explanation on chosen inline array sizing:
+    ///  • There will always be at least two events: one axis change, and a Frame.
+    ///  • Three is fundamentally common, when you have proximity and tip events.
+    ///  • Pressure will be almost ubiquitous, so add one for that.
+    ///  • Tilt will be very common too.
+    /// My opinion, unmeasured save by eyeballing an event stream on a tilt+pressure-capable pen,
+    /// is that four is probably the sweet spot.
+    /// Ability to tweak that number would be a good reason to encapsulate this…!
+    pending: SmallVec<[Event; 4]>,
 }
 
-/// A list of data frame events.
-//
-// Whereas PointerHandler gets given &[PointerEvent],
-// I’ve chosen to expose SmallVec here for practicality,
-// and to skip unnecessary potential clones of `ProximityIn`’s tablet and surface.
-// If we wanted to keep this but not expose SmallVec,
-// we’d newtype smallvec::Drain, duplicating all its surface area.
-// I might have done that, but when it doesn’t implement as_slice like Vec’s,
-// I become less enthusiastic.
-// I’m not convinced it’s worth the bother.
-//
-// Explanation on chosen sizing:
-//  • There will always be at least two events: one axis change, and a Frame.
-//  • Three is fundamentally common, when you have proximity and tip events.
-//  • Pressure will be almost ubiquitous, so add one for that.
-//  • Tilt will be very common too.
-// My opinion, unmeasured save by eyeballing an event stream on a tilt+pressure-capable pen,
-// is that four is probably the sweet spot.
-// Ability to tweak that number would be a good reason to encapsulate this…!
-pub type EventList = SmallVec<[Event; 4]>;
-
 impl<D> Dispatch<ZwpTabletToolV2, Data, D>
     for super::TabletManager
 where

From 568a5529b94ad5911cd2ad50bd1e85bb104e7972 Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Wed, 26 Mar 2025 17:52:46 +0530
Subject: [PATCH 15/27] Refine how Tools is exposed

Add a little, remove a little.
---
 examples/tablet.rs      |  2 +-
 src/seat/tablet_tool.rs | 54 ++++++++++++-----------------------------
 2 files changed, 16 insertions(+), 40 deletions(-)

diff --git a/examples/tablet.rs b/examples/tablet.rs
index 56f50a270..340fc385d 100644
--- a/examples/tablet.rs
+++ b/examples/tablet.rs
@@ -465,7 +465,7 @@ impl tablet_tool::Handler for SimpleWindow {
         info: tablet_tool::Info,
     ) {
         println!("Tablet tool {} initialised: {:#?}", tool.id(), info);
-        self.tools.add(tool.clone(), info);
+        self.tools.insert(tool.clone(), info);
     }
 
     fn removed(
diff --git a/src/seat/tablet_tool.rs b/src/seat/tablet_tool.rs
index 819a3b5dc..127ec8977 100644
--- a/src/seat/tablet_tool.rs
+++ b/src/seat/tablet_tool.rs
@@ -189,15 +189,13 @@ impl Tools {
         Tools::default()
     }
 
+    /// Get the info and state for a tool.
     pub fn get(&self, tool: &ZwpTabletToolV2) -> Option<&InfoAndState> {
         self.map.get(tool)
     }
 
-    pub fn get_mut(&mut self, tool: &ZwpTabletToolV2) -> Option<&mut InfoAndState> {
-        self.map.get_mut(tool)
-    }
-
-    pub fn add(&mut self, tool: ZwpTabletToolV2, info: Info) {
+    /// Add a tool with its info and no state.
+    pub fn insert(&mut self, tool: ZwpTabletToolV2, info: Info) {
         self.map.insert(tool.clone(), InfoAndState {
             info,
             last_frame_time: 0,
@@ -205,13 +203,17 @@ impl Tools {
         });
     }
 
+    /// Remove a tool from the collection.
     pub fn remove(&mut self, tool: &ZwpTabletToolV2) {
         self.map.remove(tool);
     }
 
-    /// Apply the events to the record state.
+    /// Apply the events to the tool’s state.
     ///
-    /// Returns it in order to save a superfluous [`.get()`](Self::get) call.
+    /// Returns the updated [`InfoAndState`] for convenience,
+    /// and to save a superfluous [`.get()`](Self::get) call.
+    ///
+    /// Panics if the tool is not in the collection.
     pub fn ingest_frame(&mut self, tool: &ZwpTabletToolV2, events: &[Event]) -> &InfoAndState {
         let mut events = events.into_iter();
         let ias = self.map.get_mut(tool).unwrap();
@@ -239,6 +241,12 @@ impl Tools {
         &*ias
     }
 
+    /// Iterate over each tablet tool and its data.
+    pub fn iter(&self) -> hash_map::Iter<'_, ZwpTabletToolV2, InfoAndState> {
+        self.map.iter()
+    }
+
+    /// Iterate over the data for each tablet tool.
     pub fn values(&self) -> hash_map::Values<'_, ZwpTabletToolV2, InfoAndState> {
         self.map.values()
     }
@@ -252,38 +260,6 @@ impl<'a> IntoIterator for &'a Tools {
     }
 }
 
-// TODO: this isn’t the way, but what is?
-impl Handler for Tools {
-    fn info(
-        &mut self,
-        _: &Connection,
-        _: &QueueHandle<Self>,
-        tool: &ZwpTabletToolV2,
-        info: Info,
-    ) {
-        self.add(tool.clone(), info);
-    }
-
-    fn removed(
-        &mut self,
-        _: &Connection,
-        _: &QueueHandle<Self>,
-        tool: &ZwpTabletToolV2,
-    ) {
-        self.map.remove(tool);
-    }
-
-    fn frame(
-        &mut self,
-        _: &Connection,
-        _: &QueueHandle<Self>,
-        tool: &ZwpTabletToolV2,
-        events: &[Event],
-    ) {
-        self.ingest_frame(tool, &events);
-    }
-}
-
 /// The current state of the tool, while in proximity.
 ///
 /// For many applications, when you receive a frame,

From 98f3aad804ed44723bc988eebe6729d4e79a9a40 Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Wed, 26 Mar 2025 17:57:44 +0530
Subject: [PATCH 16/27] Make tablet seat handler methods optional
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Honestly I’m not sure if even the seat is worthwhile.
If the user cares, they *can* map tablet_seat → seat themselves.
---
 examples/tablet.rs      | 35 +------------------------------
 src/seat/tablet_seat.rs | 46 +++++++++++++++++++++++++++--------------
 2 files changed, 32 insertions(+), 49 deletions(-)

diff --git a/examples/tablet.rs b/examples/tablet.rs
index 340fc385d..0cee52644 100644
--- a/examples/tablet.rs
+++ b/examples/tablet.rs
@@ -398,40 +398,7 @@ impl KeyboardHandler for SimpleWindow {
     }
 }
 
-impl tablet_seat::Handler for SimpleWindow {
-    fn tablet_added(
-        &mut self,
-        _conn: &Connection,
-        _qh: &QueueHandle<Self>,
-        _tablet_seat: &ZwpTabletSeatV2,
-        _seat: &wl_seat::WlSeat,
-        tablet: ZwpTabletV2,
-    ) {
-        println!("Added tablet: {}", tablet.id());
-    }
-
-    fn tool_added(
-        &mut self,
-        _conn: &Connection,
-        _qh: &QueueHandle<Self>,
-        _tablet_seat: &ZwpTabletSeatV2,
-        _seat: &wl_seat::WlSeat,
-        tool: ZwpTabletToolV2,
-    ) {
-        println!("Added tablet tool: {}", tool.id());
-    }
-
-    // fn pad_added(
-    //     &mut self,
-    //     _conn: &Connection,
-    //     _qh: &QueueHandle<Self>,
-    //     _tablet_seat: &ZwpTabletSeatV2,
-    //     _seat: &wl_seat::WlSeat,
-    //     pad: ZwpTabletPadV2,
-    // ) {
-    //     println!("Added tablet pad: {}", pad.id());
-    // }
-}
+impl tablet_seat::Handler for SimpleWindow {}
 
 impl tablet::Handler for SimpleWindow {
     fn info(
diff --git a/src/seat/tablet_seat.rs b/src/seat/tablet_seat.rs
index 17ddde089..806430fce 100644
--- a/src/seat/tablet_seat.rs
+++ b/src/seat/tablet_seat.rs
@@ -12,7 +12,19 @@ use wayland_protocols::wp::tablet::zv2::client::{
     zwp_tablet_pad_v2::ZwpTabletPadV2,
 };
 
+/// Handler for the tablet seat.
+///
+/// The `*_added` methods announce the creation of objects before they’re ready for use.
+/// If you might have multiple seats and want to associate devices with their tablet seat,
+/// then you can implement them, but otherwise you can just leave them blank.
+///
+/// What you *actually* care about is the corresponding handler’s `info` method.
+/// That’s when it’s ready to use.
+#[allow(unused_variables)]  // ← For all the trait method arguments
 pub trait Handler: Sized {
+    /// A tablet has been added.
+    ///
+    /// [`tablet::Handler::info`](super::tablet::Handler::info) will be called when it is ready for use.
     fn tablet_added(
         &mut self,
         conn: &Connection,
@@ -20,7 +32,11 @@ pub trait Handler: Sized {
         tablet_seat: &ZwpTabletSeatV2,
         seat: &WlSeat,
         id: ZwpTabletV2,
-    );
+    ) {}
+
+    /// A tablet tool has been added.
+    ///
+    /// [`tablet_tool::Handler::info`](super::tablet_tool::Handler::info) will be called when it is ready for use.
     fn tool_added(
         &mut self,
         conn: &Connection,
@@ -28,17 +44,19 @@ pub trait Handler: Sized {
         tablet_seat: &ZwpTabletSeatV2,
         seat: &WlSeat,
         id: ZwpTabletToolV2,
-    );
-    ///// TODO; non-functional stub, just so it doesn’t crash if a pad is present (I hope?).
-    ///// Nothing more is hooked up for pads.
-    //fn pad_added(
-    //    &mut self,
-    //    conn: &Connection,
-    //    qh: &QueueHandle<Self>,
-    //    tablet_seat: &ZwpTabletSeatV2,
-    //    seat: &WlSeat,
-    //    id: ZwpTabletPadV2,
-    //);
+    ) {}
+
+    /// A tablet pad has been added.
+    ///
+    /// [`tablet_pad::Handler::info`](super::tablet_pad::Handler::info) will be called when it is ready for use.
+    fn pad_added(
+        &mut self,
+        conn: &Connection,
+        qh: &QueueHandle<Self>,
+        tablet_seat: &ZwpTabletSeatV2,
+        seat: &WlSeat,
+        id: ZwpTabletPadV2,
+    ) {}
 }
 
 #[doc(hidden)]
@@ -79,9 +97,7 @@ where
                 data.tool_added(conn, qh, tablet_seat, &udata.wl_seat, id);
             },
             zwp_tablet_seat_v2::Event::PadAdded { id } => {
-                log::warn!(target: "sctk", "zwp_tablet_seat_v2.pad_added: unimplemented");
-                id.destroy();
-                //data.pad_added(conn, qh, tablet_seat, &udata.wl_seat, id);
+                data.pad_added(conn, qh, tablet_seat, &udata.wl_seat, id);
             },
             _ => unreachable!(),
         }

From 2b8df7da638491444facf64863e5ad16150b4441 Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Wed, 26 Mar 2025 18:00:16 +0530
Subject: [PATCH 17/27] (Advice sought) Remove seat from tablet seat handler
 methods
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Not sure if this is a good idea or not.
I would like advice.
I’m quite content to revert it.

It’s perfectly *possible* for the user to map tablet seat to seat,
as they have both directly after the get_tablet_seat call.
---
 src/seat/tablet_manager.rs |  7 +++----
 src/seat/tablet_seat.rs    | 22 ++++++----------------
 2 files changed, 9 insertions(+), 20 deletions(-)

diff --git a/src/seat/tablet_manager.rs b/src/seat/tablet_manager.rs
index f11953492..bb7414402 100644
--- a/src/seat/tablet_manager.rs
+++ b/src/seat/tablet_manager.rs
@@ -35,10 +35,9 @@ impl TabletManager {
         qh: &QueueHandle<D>,
     ) -> Result<ZwpTabletSeatV2, GlobalError>
     where
-        D: Dispatch<ZwpTabletSeatV2, super::tablet_seat::Data> + 'static,
+        D: Dispatch<ZwpTabletSeatV2, ()> + 'static,
     {
-        let udata = super::tablet_seat::Data { wl_seat: seat.clone() };
-        Ok(self.tablet_manager.get()?.get_tablet_seat(seat, qh, udata))
+        Ok(self.tablet_manager.get()?.get_tablet_seat(seat, qh, ()))
     }
 }
 
@@ -66,7 +65,7 @@ macro_rules! delegate_tablet {
             $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_manager_v2::ZwpTabletManagerV2: $crate::globals::GlobalData
         ] => $crate::seat::TabletManager);
         $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
-            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_seat_v2::ZwpTabletSeatV2: $crate::seat::tablet_seat::Data
+            $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_seat_v2::ZwpTabletSeatV2: ()
         ] => $crate::seat::TabletManager);
         $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
             $crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_v2::ZwpTabletV2: $crate::seat::tablet::Data
diff --git a/src/seat/tablet_seat.rs b/src/seat/tablet_seat.rs
index 806430fce..51e444b6a 100644
--- a/src/seat/tablet_seat.rs
+++ b/src/seat/tablet_seat.rs
@@ -1,6 +1,5 @@
 use wayland_client::{
     event_created_child,
-    protocol::wl_seat::WlSeat,
     Connection,
     Dispatch,
     QueueHandle,
@@ -30,7 +29,6 @@ pub trait Handler: Sized {
         conn: &Connection,
         qh: &QueueHandle<Self>,
         tablet_seat: &ZwpTabletSeatV2,
-        seat: &WlSeat,
         id: ZwpTabletV2,
     ) {}
 
@@ -42,7 +40,6 @@ pub trait Handler: Sized {
         conn: &Connection,
         qh: &QueueHandle<Self>,
         tablet_seat: &ZwpTabletSeatV2,
-        seat: &WlSeat,
         id: ZwpTabletToolV2,
     ) {}
 
@@ -54,21 +51,14 @@ pub trait Handler: Sized {
         conn: &Connection,
         qh: &QueueHandle<Self>,
         tablet_seat: &ZwpTabletSeatV2,
-        seat: &WlSeat,
         id: ZwpTabletPadV2,
     ) {}
 }
 
-#[doc(hidden)]
-#[derive(Debug)]
-pub struct Data {
-    pub(crate) wl_seat: WlSeat,
-}
-
-impl<D> Dispatch<ZwpTabletSeatV2, Data, D>
+impl<D> Dispatch<ZwpTabletSeatV2, (), D>
     for super::TabletManager
 where
-    D: Dispatch<ZwpTabletSeatV2, Data>
+    D: Dispatch<ZwpTabletSeatV2, ()>
      + Dispatch<ZwpTabletV2, super::tablet::Data>
      + Dispatch<ZwpTabletToolV2, super::tablet_tool::Data>
      + Dispatch<ZwpTabletPadV2, super::tablet_pad::Data>
@@ -85,19 +75,19 @@ where
         data: &mut D,
         tablet_seat: &ZwpTabletSeatV2,
         event: zwp_tablet_seat_v2::Event,
-        udata: &Data,
+        _udata: &(),
         conn: &Connection,
         qh: &QueueHandle<D>,
     ) {
         match event {
             zwp_tablet_seat_v2::Event::TabletAdded { id } => {
-                data.tablet_added(conn, qh, tablet_seat, &udata.wl_seat, id);
+                data.tablet_added(conn, qh, tablet_seat, id);
             },
             zwp_tablet_seat_v2::Event::ToolAdded { id } => {
-                data.tool_added(conn, qh, tablet_seat, &udata.wl_seat, id);
+                data.tool_added(conn, qh, tablet_seat, id);
             },
             zwp_tablet_seat_v2::Event::PadAdded { id } => {
-                data.pad_added(conn, qh, tablet_seat, &udata.wl_seat, id);
+                data.pad_added(conn, qh, tablet_seat, id);
             },
             _ => unreachable!(),
         }

From 387d71811e23fb592d4dfb6c01d3eb771f552de1 Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Fri, 28 Mar 2025 17:00:51 +0530
Subject: [PATCH 18/27] Document that no other axis methods are warranted

---
 src/seat/tablet_tool.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/seat/tablet_tool.rs b/src/seat/tablet_tool.rs
index 127ec8977..52138edbf 100644
--- a/src/seat/tablet_tool.rs
+++ b/src/seat/tablet_tool.rs
@@ -167,6 +167,16 @@ impl InfoAndState {
             _ => 0.0,
         }
     }
+
+    // I don’t think there’s anything else that warrants a method,
+    // because it needs to take both info and state into account:
+    //   • Tilt, 0/0 is a sane default when unsupported.
+    //   • Distance, you’ll probably want to handle supported/unsupported separately.
+    //   • Rotation, 0 is the natural position and a good default when unsupported.
+    //   • Slider, 0 is the neutral position and a good default when unsupported.
+    //   • Wheel, it’s all delta anyway so unsupported values are equivalent to unused.
+    // No, it’s only pressure, because you need the fallback to take down into account,
+    // because zero would be a horrible value to be stuck at.
 }
 
 impl From<Info> for InfoAndState {

From 5cd8a954b98cf5ee16969da846aa2e510f06f9be Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Sat, 29 Mar 2025 10:01:29 +0530
Subject: [PATCH 19/27] Remove more dead code

---
 src/seat/tablet_tool.rs | 22 ----------------------
 1 file changed, 22 deletions(-)

diff --git a/src/seat/tablet_tool.rs b/src/seat/tablet_tool.rs
index 52138edbf..9d4d1ad45 100644
--- a/src/seat/tablet_tool.rs
+++ b/src/seat/tablet_tool.rs
@@ -21,20 +21,6 @@ use wayland_protocols::wp::tablet::zv2::client::{
 
 pub use zwp_tablet_tool_v2::{Capability, Type, Event};
 
-#[derive(Debug)]
-pub enum InitEvent {
-    Type(Type),
-    HardwareSerial {
-        hi: u32,
-        lo: u32,
-    },
-    HardwareIdWacom {
-        hi: u32,
-        lo: u32,
-    },
-    Capability(Capability),
-}
-
 // Just a named tuple.
 /// A hardware identifier, just two `u32`s with names `hi` and `lo`.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -485,14 +471,6 @@ impl State {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Button {
-    /// Button state: `true` if pressed, `false` if released.
-    pub pressed: bool,
-    /// The serial for the most recent state change.
-    pub serial: u32,
-}
-
 // Based on <https://lists.freedesktop.org/archives/wayland-devel/2025-March/044025.html>:
 // BTN_STYLUS, BTN_STYLUS2 and BTN_STYLUS3 are the only codes likely.
 // Mouse tools are long gone, finger was a mistake—everything’s a stylus.

From 53eabb9e20d8c92ff49076cce7d478787b4c01b7 Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Sat, 29 Mar 2025 10:15:49 +0530
Subject: [PATCH 20/27] More shuffling tool stuff around, for the better
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

I think this is pretty close to what people will want now.

I came via passing around &mut Option<State> and such,
but realised it was better to stop blatting *all* the state,
and just shift the proximity_in information into an optional substruct.
This lets things be just methods on State, for much greater consistency,
and the scoping makes it easier to ignore State if you don’t want to use it, too.

I didn’t like the Tools map, it was too inflexible.
So, ditched it in favour of making the user choose the map and struct.
It’s much of a muchness on boilerplate, and simpler, which is a virtue.
Now you see a Tool struct which can have more per-tool fields added.
This is good.

It’s funny how you can come back to earlier designs like this.
This is very similar to what I had a few days ago,
but it was just a *little* different then, in bad ways.
Now I’ve got the best of all worlds I’ve thought of so far.

—⁂—

I’m still mulling over the udata pattern,
which would probably be more consistent with the rest of sctk.
I’m not entirely sold on shifting things into there,
for a couple of initial reasons:

  • I’m not sure if State can be optional quite so well—
    in order to avoid overhead if it’s not being used, it wants
    relaxed coherence, negative bounds, specialisation or similar.

  • If Info remains in the data, it must be in a mutex.
    Mutex guards are nasty to deal with, and compromise API.
---
 examples/tablet.rs      | 124 ++++++-------
 src/seat/tablet_tool.rs | 390 ++++++++++++++++------------------------
 2 files changed, 204 insertions(+), 310 deletions(-)

diff --git a/examples/tablet.rs b/examples/tablet.rs
index 0cee52644..930c3b3cf 100644
--- a/examples/tablet.rs
+++ b/examples/tablet.rs
@@ -109,7 +109,7 @@ fn main() {
         keyboard_focus: false,
         tablet_seat: None,
         tablets: HashMap::new(),
-        tools: tablet_tool::Tools::new(),
+        tools: HashMap::new(),
         buffer: None,
         queued_circles: Vec::new(),
         redraw_queued: false,
@@ -122,6 +122,12 @@ fn main() {
     }
 }
 
+struct Tool {
+    info: tablet_tool::Info,
+    state: tablet_tool::State,
+    cursor_surface: Option<Surface>,
+}
+
 struct SimpleWindow {
     registry_state: RegistryState,
     seat_state: SeatState,
@@ -139,7 +145,7 @@ struct SimpleWindow {
     keyboard_focus: bool,
     tablet_seat: Option<ZwpTabletSeatV2>,
     tablets: HashMap<ZwpTabletV2, tablet::Info>,
-    tools: tablet_tool::Tools,
+    tools: HashMap<ZwpTabletToolV2, Tool>,
     pool: SlotPool,
     buffer: Option<Buffer>,
     queued_circles: Vec<Circle>,
@@ -428,47 +434,51 @@ impl tablet_tool::Handler for SimpleWindow {
         &mut self,
         _conn: &Connection,
         _qh: &QueueHandle<Self>,
-        tool: &ZwpTabletToolV2,
+        wtool: &ZwpTabletToolV2,
         info: tablet_tool::Info,
     ) {
-        println!("Tablet tool {} initialised: {:#?}", tool.id(), info);
-        self.tools.insert(tool.clone(), info);
+        println!("Tablet tool {} initialised: {:#?}", wtool.id(), info);
+        self.tools.insert(wtool.clone(), Tool {
+            info,
+            state: tablet_tool::State::new(),
+            cursor_surface: None,
+        });
     }
 
     fn removed(
         &mut self,
         _conn: &Connection,
         _qh: &QueueHandle<Self>,
-        tool: &ZwpTabletToolV2,
+        wtool: &ZwpTabletToolV2,
     ) {
-        println!("Tablet tool {} removed", tool.id());
-        self.tools.remove(tool);
+        println!("Tablet tool {} removed", wtool.id());
+        self.tools.remove(wtool);
     }
 
     fn frame(
         &mut self,
         _conn: &Connection,
         qh: &QueueHandle<Self>,
-        tool: &ZwpTabletToolV2,
+        wtool: &ZwpTabletToolV2,
         events: &[tablet_tool::Event],
     ) {
-        //println!("Tablet tool {} frame: {:#?}", tool.id(), events);
-        let tias = self.tools.ingest_frame(tool, &events);
+        let tool = self.tools.get_mut(wtool).expect("got frame for unknown tool");
+        tool.state.ingest_frame(events);
 
-        if let Some(state) = &tias.state {
-            if state.is_down() {
-                let pressure = tias.pressure_web();
+        if tool.state.is_in_proximity() {
+            if tool.state.is_down() {
+                let pressure = tool.state.pressure_web(&tool.info);
                 let radius = 2.0 * pressure as f32;
                 self.queued_circles.push(Circle {
-                    x: state.x as f32,
-                    y: state.y as f32,
+                    x: tool.state.x as f32,
+                    y: tool.state.y as f32,
                     radius,
                     color: raqote::SolidSource {
-                        r: (state.tilt_x + 90.0 / 180.0 * 255.0) as u8,
-                        g: (state.tilt_y + 90.0 / 180.0 * 255.0) as u8,
-                        b: (state.rotation_degrees / 360.0 * 255.0 % 255.0) as u8,
-                        a: if tias.info.supports_slider() {
-                            ((state.slider_position + 65535) as f64 / 131071.0 * 255.0) as u8
+                        r: (tool.state.tilt_x + 90.0 / 180.0 * 255.0) as u8,
+                        g: (tool.state.tilt_y + 90.0 / 180.0 * 255.0) as u8,
+                        b: (tool.state.rotation_degrees / 360.0 * 255.0 % 255.0) as u8,
+                        a: if tool.info.supports_slider() {
+                            ((tool.state.slider_position + 65535) as f64 / 131071.0 * 255.0) as u8
                         } else {
                             // Sure, 0 is the neutraal position and all that,
                             // but semitransparent looks a bit odd,
@@ -480,68 +490,36 @@ impl tablet_tool::Handler for SimpleWindow {
                 });
             }
 
-            /*
-            let width = 32;
-            let height = 32;
-            let (buffer, canvas) = self.pool.create_buffer(
-                width as i32,
-                height as i32,
-                width as i32 * 4,
-                wl_shm::Format::Argb8888
-            ).expect("create buffer");
-            // https://github.com/Smithay/client-toolkit/issues/488 workaround.
-            let canvas = &mut canvas[..width as usize * height as usize * 4];
-
-            let radius = 6.0;
-            let mut dt = raqote::DrawTarget::from_backing(
-                width as i32,
-                height as i32,
-                bytemuck::cast_slice_mut(canvas),
-            );
-            let mut pb = raqote::PathBuilder::new();
-            pb.arc(width as f32 / 2.0, height as f32 / 2.0, radius, 0., TWO_PI);
-            dt.fill(&pb.finish(), &SOLID_RED, &raqote::DrawOptions::new());
-
-            // TODO: text.
-
-            let cursor_surface = Surface::new(&self.compositor_state, qh).unwrap();
-            let cursor_wl_surface = cursor_surface.wl_surface();
-            tool.set_cursor(state.proximity_in_serial, Some(cursor_wl_surface), width / 2, height / 2);
-            buffer.attach_to(cursor_wl_surface).expect("buffer attach");
-            cursor_wl_surface.damage_buffer(0, 0, width as i32, height as i32);
-            cursor_wl_surface.commit();
-            */
-
-            print!("t={} {} x={:7.2} y={:7.2}",
-                tias.last_frame_time,
-                if state.is_down() { "down" } else { " up " },
-                state.x,
-                state.y);
-            if tias.info.supports_pressure() {
-                print!(" pressure={:5}", state.pressure);
+            print!("t={}   tablet state    {} x={:7.2} y={:7.2}",
+                tool.state.time,
+                if tool.state.is_down() { "down" } else { "up  " },
+                tool.state.x,
+                tool.state.y);
+            if tool.info.supports_pressure() {
+                print!(" pressure={:5}", tool.state.pressure);
             }
-            if tias.info.supports_tilt() {
-                print!(" tilt_x={:5.2} tilt_y={:5.2}", state.tilt_x, state.tilt_y);
+            if tool.info.supports_tilt() {
+                print!(" tilt_x={:5.2} tilt_y={:5.2}", tool.state.tilt_x, tool.state.tilt_y);
             }
-            if tias.info.supports_distance() {
-                print!(" distance={:5}", state.distance);
+            if tool.info.supports_distance() {
+                print!(" distance={:5}", tool.state.distance);
             }
-            if tias.info.supports_rotation() {
-                print!(" rotation={:6.2}", state.rotation_degrees);
+            if tool.info.supports_rotation() {
+                print!(" rotation={:6.2}", tool.state.rotation_degrees);
             }
-            if tias.info.supports_slider() {
-                print!(" slider={:6}", state.slider_position);
+            if tool.info.supports_slider() {
+                print!(" slider={:6}", tool.state.slider_position);
             }
-            if tias.info.supports_wheel() {
-                print!(" wheel={:6.2}", state.wheel_degrees);
+            if tool.info.supports_wheel() {
+                print!(" wheel={:6.2}", tool.state.wheel_degrees);
             }
-            if state.stylus_button_1_pressed {
+            if tool.state.stylus_button_1_pressed {
                 print!(" button:1");
             }
-            if state.stylus_button_2_pressed {
+            if tool.state.stylus_button_2_pressed {
                 print!(" button:2");
             }
-            if state.stylus_button_3_pressed {
+            if tool.state.stylus_button_3_pressed {
                 print!(" button:3");
             }
             println!();
diff --git a/src/seat/tablet_tool.rs b/src/seat/tablet_tool.rs
index 9d4d1ad45..b6c63244e 100644
--- a/src/seat/tablet_tool.rs
+++ b/src/seat/tablet_tool.rs
@@ -1,4 +1,3 @@
-use std::collections::{hash_map, HashMap};
 use std::fmt;
 use std::mem;
 use std::sync::Mutex;
@@ -132,137 +131,13 @@ impl Info {
     pub fn supports_wheel(&self)    -> bool { self.capabilities.contains(Capabilities::WHEEL) }
 }
 
-#[derive(Debug)]
-pub struct InfoAndState {
-    pub info: Info,
-    /// The time the last frame was sent,
-    /// or zero if no frames have come yet.
-    pub last_frame_time: u32,
-    /// The current state of the tool, if in proximity.
-    pub state: Option<State>,
-}
-
-impl InfoAndState {
-    /// Get the pressure according to the web’s Pointer Events API:
-    /// scaled in the range \[0, 1\],
-    /// and set to 0.5 when down if pressure isn’t supported.
-    pub fn pressure_web(&self) -> f64 {
-        match (self.info.supports_pressure(), &self.state) {
-            (true, &Some(State { pressure, .. })) => pressure as f64 / 65535.0,
-            (false, Some(State { down_serial: Some(_), .. })) => 0.5,
-            _ => 0.0,
-        }
-    }
-
-    // I don’t think there’s anything else that warrants a method,
-    // because it needs to take both info and state into account:
-    //   • Tilt, 0/0 is a sane default when unsupported.
-    //   • Distance, you’ll probably want to handle supported/unsupported separately.
-    //   • Rotation, 0 is the natural position and a good default when unsupported.
-    //   • Slider, 0 is the neutral position and a good default when unsupported.
-    //   • Wheel, it’s all delta anyway so unsupported values are equivalent to unused.
-    // No, it’s only pressure, because you need the fallback to take down into account,
-    // because zero would be a horrible value to be stuck at.
-}
-
-impl From<Info> for InfoAndState {
-    fn from(info: Info) -> InfoAndState {
-        InfoAndState {
-            info,
-            last_frame_time: 0,
-            state: None,
-        }
-    }
-}
-
-#[derive(Debug, Default)]
-pub struct Tools {
-    map: HashMap<ZwpTabletToolV2, InfoAndState>,
-}
-
-impl Tools {
-    pub fn new() -> Tools {
-        Tools::default()
-    }
-
-    /// Get the info and state for a tool.
-    pub fn get(&self, tool: &ZwpTabletToolV2) -> Option<&InfoAndState> {
-        self.map.get(tool)
-    }
-
-    /// Add a tool with its info and no state.
-    pub fn insert(&mut self, tool: ZwpTabletToolV2, info: Info) {
-        self.map.insert(tool.clone(), InfoAndState {
-            info,
-            last_frame_time: 0,
-            state: None,
-        });
-    }
-
-    /// Remove a tool from the collection.
-    pub fn remove(&mut self, tool: &ZwpTabletToolV2) {
-        self.map.remove(tool);
-    }
-
-    /// Apply the events to the tool’s state.
-    ///
-    /// Returns the updated [`InfoAndState`] for convenience,
-    /// and to save a superfluous [`.get()`](Self::get) call.
-    ///
-    /// Panics if the tool is not in the collection.
-    pub fn ingest_frame(&mut self, tool: &ZwpTabletToolV2, events: &[Event]) -> &InfoAndState {
-        let mut events = events.into_iter();
-        let ias = self.map.get_mut(tool).unwrap();
-        let state = ias.state.get_or_insert_with(|| {
-            let Some(Event::ProximityIn { serial, tablet, surface }) = events.next()
-            else {
-                panic!("First zwp_tablet_tool_v2 frame didn’t start with a proximity_in event");
-            };
-            State::from_proximity_in(*serial, tablet.clone(), surface.clone())
-        });
-        let Some(Event::Frame { time }) = events.next_back() else { unreachable!() };
-        ias.last_frame_time = *time;
-
-        for event in events {
-            state.apply_event(&event);
-            if let Event::ProximityOut = event {
-                ias.state = None;
-                // Given that a frame is supposed to represent a single hardware event,
-                // I think you can fairly say it’d be mad to proximity_out and
-                // immediately proximity_in in the same frame.
-                // So I think we’re OK to just break.
-                break;
-            }
-        }
-        &*ias
-    }
-
-    /// Iterate over each tablet tool and its data.
-    pub fn iter(&self) -> hash_map::Iter<'_, ZwpTabletToolV2, InfoAndState> {
-        self.map.iter()
-    }
-
-    /// Iterate over the data for each tablet tool.
-    pub fn values(&self) -> hash_map::Values<'_, ZwpTabletToolV2, InfoAndState> {
-        self.map.values()
-    }
-}
-
-impl<'a> IntoIterator for &'a Tools {
-    type Item = (&'a ZwpTabletToolV2, &'a InfoAndState);
-    type IntoIter = hash_map::Iter<'a, ZwpTabletToolV2, InfoAndState>;
-    fn into_iter(self) -> Self::IntoIter {
-        self.map.iter()
-    }
-}
-
-/// The current state of the tool, while in proximity.
+/// The current state of the tool.
 ///
 /// For many applications, when you receive a frame,
 /// you don’t so much care about the events,
 /// as about capturing the tool’s current total state.
 ///
-/// This lets you do that.
+/// This lets you view it that way, if you choose.
 ///
 /// Caveats:
 ///
@@ -280,19 +155,20 @@ impl<'a> IntoIterator for &'a Tools {
 ///   (nothing but stylus inputs have been available since the early-/mid-2010s),
 ///   and if you care about serials or other buttons you will surely prefer events.
 //
-// At 176 bytes on a 64-bit platform, this is much larger than it fundamentally *need* be.
-// With effort, you could losslessly encode all but wheel in less than 37 bytes,
-// and with negligible loss you could shrink it to 29 bytes.
+// At 184 bytes on a 64-bit platform, this is much larger than it fundamentally *need* be.
+// With effort, you could losslessly encode all but wheel in less than 41 bytes,
+// and with negligible loss you could shrink it to 33 bytes.
 // But we’re trying to make it usefully accessible, not packed ultra-tight.
 // So it’s mildly painfully wasteful instead.
-#[derive(Debug, Clone)]
+#[derive(Debug, Default, Clone)]
 pub struct State {
-    // ProximityIn
-    /// The `Event::ProximityIn.serial` value,
-    /// needed for [`ZwpTabletToolV2::set_cursor`] requests.
-    pub proximity_in_serial: u32,
-    pub tablet: ZwpTabletV2,
-    pub surface: WlSurface,
+    // ProximityIn, ProximityOut
+    /// The proximity information.
+    ///
+    /// When this is `None` (initially and after a `ProximityOut` event),
+    /// tip state will be up and button states will be released,
+    /// but all other axes will have stale values.
+    pub proximity: Option<Proximity>,
 
     // Down, Up
     /// Whether the tool is in logical contact or not.
@@ -356,119 +232,154 @@ pub struct State {
     pub stylus_button_2_pressed: bool,
     /// Whether [`BTN_STYLUS3`] is pressed.
     pub stylus_button_3_pressed: bool,
+
+    // Frame
+    /// The time given in the last [Event::Frame].
+    pub time: u32,
+}
+
+/// Information from the `ProximityIn` event.
+#[derive(Debug, Clone)]
+pub struct Proximity {
+    /// The `Event::ProximityIn.serial` value,
+    /// needed for [`ZwpTabletToolV2::set_cursor`] requests.
+    pub serial: u32,
+    pub tablet: ZwpTabletV2,
+    pub surface: WlSurface,
 }
 
 impl State {
+    /// Create blank state for a tool not yet in proximity.
+    #[inline]
+    pub fn new() -> State {
+        State::default()
+    }
+
+    /// Whether the tool is in logical contact with the tablet.
+    #[inline]
     pub fn is_down(&self) -> bool {
         self.down_serial.is_some()
     }
-}
 
-pub fn button_state_to_bool(state: WEnum<zwp_tablet_tool_v2::ButtonState>) -> bool {
-    matches!(state, WEnum::Value(zwp_tablet_tool_v2::ButtonState::Pressed))
-}
-
-impl State {
-    pub fn from_proximity_in(serial: u32, tablet: ZwpTabletV2, surface: WlSurface) -> State {
-        State {
-            proximity_in_serial: serial,
-            tablet,
-            surface,
-            // Initialise the rest to the most meaningful values possible.
-            down_serial: None,
-            x: 0.0,
-            y: 0.0,
-            pressure: 0,
-            distance: 0,
-            tilt_x: 0.0,
-            tilt_y: 0.0,
-            rotation_degrees: 0.0,
-            slider_position: 0,
-            wheel_degrees: 0.0,
-            wheel_clicks: 0,
-            stylus_button_1_pressed: false,
-            stylus_button_2_pressed: false,
-            stylus_button_3_pressed: false,
-        }
+    /// Whether the tool is in proximity to a tablet.
+    pub fn is_in_proximity(&self) -> bool {
+        self.proximity.is_some()
     }
 
-    /// Apply the change described in an event to this state.
-    ///
-    /// Certain events are ignored:
-    ///
-    /// - Static description events (e.g. `Type` and `Done`) aren’t applicable.
-    /// - `ProximityOut` invalidates this entirely and needs to be applied at a higher level.
-    /// - `ProximityIn` should already have been consumed by the caller
-    ///   (it was what led to creating this object).
-    /// - `Frame` should be consumed by the caller
-    ///   (you can’t store frame time inside here,
-    ///   since it will be deleted by `ProximityOut`,
-    ///   but you might still care about its frame time).
+    /// Apply the events of a frame to this state.
     ///
-    /// For clarity:
-    /// `ProximityOut` is expected to be passed here (at present), though it’s no-op,
-    /// but `ProximityIn` and `Frame` should both have been consumed.
-    ///
-    /// Also, `Button` is ignored for anything other than the stylus buttons,
+    /// `Button` events are ignored for anything other than the stylus buttons,
     /// and button serials are discarded.
-    pub fn apply_event(&mut self, event: &Event) {
-        match *event {
-            Event::ProximityOut => {
-                // This invalidates `self`, and must be handled by the caller.
-            },
-            Event::Down { serial } => {
-                self.down_serial = Some(serial);
-            },
-            Event::Up => {
-                self.down_serial = None;
-            },
-            Event::Motion { x, y } => {
-                self.x = x;
-                self.y = y;
-            },
-            Event::Pressure { pressure } => {
-                // “The value of this event is normalized to a value between 0 and 65535.”
-                // But the Wayland wire format only supports 32-bit integers,
-                // so we cast it here. We might as well, I reckon.
-                self.pressure = pressure as u16;
-            },
-            Event::Distance { distance } => {
-                // Same deal, “normalized to a value between 0 and 65535”.
-                self.distance = distance as u16;
-            },
-            Event::Tilt { tilt_x, tilt_y } => {
-                self.tilt_x = tilt_x;
-                self.tilt_y = tilt_y;
-            },
-            Event::Rotation { degrees } => {
-                self.rotation_degrees = degrees;
-            },
-            Event::Slider { position } => {
-                // This one is “normalized between -65535 and 65535”, 17 bits, so it stays i32.
-                self.slider_position = position;
-            },
-            Event::Wheel { degrees, clicks } => {
-                // These ones use += because they’re deltas, unlike the rest.
-                self.wheel_degrees += degrees;
-                self.wheel_clicks += clicks;
-            },
-            Event::Button { serial: _, button: BTN_STYLUS, state } => {
-                self.stylus_button_1_pressed = button_state_to_bool(state);
-            },
-            Event::Button { serial: _, button: BTN_STYLUS2, state } => {
-                self.stylus_button_2_pressed = button_state_to_bool(state);
-            },
-            Event::Button { serial: _, button: BTN_STYLUS3, state } => {
-                self.stylus_button_3_pressed = button_state_to_bool(state);
-            },
-            Event::Button { .. } => {
-                // Ignored; see doc comment.
-            },
-            Event::ProximityIn { .. } | Event::Frame { .. } | _ => {
-                // Should be unreachable; see doc comment.
-            },
+    /// If you want them, you must examine the event stream yourself.
+    pub fn ingest_frame(&mut self, events: &[Event]) {
+        for event in events {
+            match *event {
+                Event::ProximityIn { serial, ref tablet, ref surface } => {
+                    self.proximity = Some(Proximity {
+                        serial,
+                        tablet: tablet.clone(),
+                        surface: surface.clone(),
+                    });
+                },
+                Event::ProximityOut => {
+                    self.proximity = None;
+                },
+                Event::Down { serial } => {
+                    self.down_serial = Some(serial);
+                },
+                Event::Up => {
+                    self.down_serial = None;
+                },
+                Event::Motion { x, y } => {
+                    self.x = x;
+                    self.y = y;
+                },
+                Event::Pressure { pressure } => {
+                    // “The value of this event is normalized to a value between 0 and 65535.”
+                    // But the Wayland wire format only supports 32-bit integers,
+                    // so we cast it here. We might as well, I reckon.
+                    self.pressure = pressure as u16;
+                },
+                Event::Distance { distance } => {
+                    // Same deal, “normalized to a value between 0 and 65535”.
+                    self.distance = distance as u16;
+                },
+                Event::Tilt { tilt_x, tilt_y } => {
+                    self.tilt_x = tilt_x;
+                    self.tilt_y = tilt_y;
+                },
+                Event::Rotation { degrees } => {
+                    self.rotation_degrees = degrees;
+                },
+                Event::Slider { position } => {
+                    // This one is “normalized between -65535 and 65535”, 17 bits, so it stays i32.
+                    self.slider_position = position;
+                },
+                Event::Wheel { degrees, clicks } => {
+                    // These ones use += because they’re deltas, unlike the rest.
+                    self.wheel_degrees += degrees;
+                    self.wheel_clicks += clicks;
+                },
+                Event::Button { serial: _, button: BTN_STYLUS, state } => {
+                    self.stylus_button_1_pressed = button_state_to_bool(state);
+                },
+                Event::Button { serial: _, button: BTN_STYLUS2, state } => {
+                    self.stylus_button_2_pressed = button_state_to_bool(state);
+                },
+                Event::Button { serial: _, button: BTN_STYLUS3, state } => {
+                    self.stylus_button_3_pressed = button_state_to_bool(state);
+                },
+                Event::Button { .. } => {
+                    // Deliberately ignored. Very unlikely in 2025, but possible.
+                },
+                Event::Frame { time } => {
+                    self.time = time;
+                },
+                _ => {
+                    // Info events, or anything else unknown. Should be unreachable.
+                },
+            }
+        }
+    }
+
+    /// Get the pressure according to the web’s Pointer Events API:
+    /// scaled in the range \[0.0, 1.0\],
+    /// and, if pressure isn’t supported, set to 0.5 when down and 0.0 when up.
+    pub fn pressure_web(&self, info: &Info) -> f64 {
+        if info.supports_pressure() {
+            self.pressure as f64 / 65535.0
+        } else if self.is_down() {
+            0.5
+        } else {
+            0.0
         }
     }
+
+    // Pressure wants a special method, because falling back to 0 would be horrible,
+    // and there’s an established convention on tip-state-aware fallback,
+    // and mixing pressure-aware and pressure-unaware pointers is routine.
+    // (Mind you, within tablet tools they’re probably almost all aware.
+    // This method is *more* useful when you’ve merged tablet tools, touch and pointers.)
+    //
+    // Distance might like a special method, as it’s basically the opposite of pressure,
+    // distance *from* the surface rather than distance *into* the surface,
+    // but it’s nowhere near as commonly supported in hardware,
+    // and it’s not common to build stuff on it,
+    // and the web’s Pointer Events API doesn’t even expose it,
+    // so there’s no established convention.
+    // *Could* make its fallback the opposite of pressure’s, 0.0 if down else 0.5,
+    // but I think people using distance are likely to want to branch on support,
+    // a little more than is the case with pressure.
+    //
+    // As for the other capabilities, they’re all fine with a static fallback value of zero:
+    // for tilt, rotation, slider, it’s the natural or neutral position;
+    // and for wheel, it’s all delta anyway so unsupported is equivalent to unused.
+}
+
+/// Convert an event’s button state to a `bool` representing whether it’s pressed.
+#[inline]
+pub fn button_state_to_bool(state: WEnum<zwp_tablet_tool_v2::ButtonState>) -> bool {
+    matches!(state, WEnum::Value(zwp_tablet_tool_v2::ButtonState::Pressed))
 }
 
 // Based on <https://lists.freedesktop.org/archives/wayland-devel/2025-March/044025.html>:
@@ -529,6 +440,7 @@ impl Data {
     }
 }
 
+// I’d make this an enum, but the overhead of keeping info forever is negligible, ~24 bytes.
 #[derive(Debug, Default)]
 struct DataInner {
     /// An accumulation of pending init-time events, flushed when a `done` event comes in,
@@ -639,6 +551,10 @@ where
             // but honestly it’s just easier to do this,
             // since we’re passing it through,
             // not reframing in any way.
+            //
+            // Any newly-defined info events will only be fired
+            // if we bump our declared version support,
+            // so no concerns there, this will only be the frame events.
             _ => guard.pending.push(event),
 
         }

From b19c60349b3814977d57bb5ae06f60b72a990493 Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Sat, 29 Mar 2025 14:06:40 +0530
Subject: [PATCH 21/27] Add cursors to the tablet tool example
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Only a custom cursor, haven’t tried a themed cursor yet.

Reaching the stage where I’m completely happy with this as a demo.
---
 examples/tablet.rs | 131 +++++++++++++++++++++++++++++++++------------
 1 file changed, 96 insertions(+), 35 deletions(-)

diff --git a/examples/tablet.rs b/examples/tablet.rs
index 930c3b3cf..ab9963718 100644
--- a/examples/tablet.rs
+++ b/examples/tablet.rs
@@ -45,14 +45,11 @@ use wayland_protocols::wp::tablet::zv2::client::{
 
 const TWO_PI: f32 = 2. * std::f32::consts::PI;
 
-const RED: raqote::SolidSource = raqote::SolidSource { r: 221, g: 0, b: 0, a: 255 };
-const GREEN: raqote::SolidSource = raqote::SolidSource { r: 0, g: 170, b: 0, a: 255 };
-const SOLID_RED: raqote::Source = raqote::Source::Solid(RED);
-const SOLID_GREEN: raqote::Source = raqote::Source::Solid(GREEN);
-
-const WHITE: raqote::SolidSource = raqote::SolidSource { r: 255, g: 255, b: 255, a: 255 };
-const BLACK: raqote::SolidSource = raqote::SolidSource { r: 0, g: 0, b: 0, a: 255 };
-const SOLID_BLACK: raqote::Source = raqote::Source::Solid(BLACK);
+const BLACK: raqote::Source = raqote::Source::Solid(raqote::SolidSource { r: 0, g: 0, b: 0, a: 255 });
+const WHITE: raqote::Source = raqote::Source::Solid(raqote::SolidSource { r: 255, g: 255, b: 255, a: 255 });
+const DARK_GREEN: raqote::Source = raqote::Source::Solid(raqote::SolidSource { r: 0, g: 102, b: 0, a: 255 });
+const DARK_RED: raqote::Source = raqote::Source::Solid(raqote::SolidSource { r: 153, g: 0, b: 0, a: 255 });
+const HALF_WHITE: raqote::Source = raqote::Source::Solid(raqote::SolidSource { r: 127, g: 127, b: 127, a: 127 });
 
 fn main() {
     env_logger::init();
@@ -62,15 +59,6 @@ fn main() {
     let (globals, mut event_queue) = registry_queue_init(&conn).unwrap();
     let qh = event_queue.handle();
 
-    let font = font_kit::source::SystemSource::new()
-        .select_best_match(
-            &[font_kit::family_name::FamilyName::SansSerif],
-            &font_kit::properties::Properties::new(),
-        )
-        .unwrap()
-        .load()
-        .unwrap();
-
     let compositor_state = CompositorState::bind(&globals, &qh)
                     .expect("wl_compositor not available");
     let shm_state = Shm::bind(&globals, &qh).expect("wl_shm not available");
@@ -98,7 +86,7 @@ fn main() {
         output_state: OutputState::new(&globals, &qh),
         compositor_state,
         shm_state,
-        xdg_shell_state,
+        _xdg_shell_state: xdg_shell_state,
         tablet_manager: TabletManager::bind(&globals, &qh),
 
         exit: false,
@@ -114,7 +102,6 @@ fn main() {
         queued_circles: Vec::new(),
         redraw_queued: false,
         pool,
-        font,
     };
 
     while !simple_window.exit {
@@ -134,7 +121,7 @@ struct SimpleWindow {
     output_state: OutputState,
     compositor_state: CompositorState,
     shm_state: Shm,
-    xdg_shell_state: XdgShell,
+    _xdg_shell_state: XdgShell,
     tablet_manager: TabletManager,
 
     exit: bool,
@@ -150,8 +137,6 @@ struct SimpleWindow {
     buffer: Option<Buffer>,
     queued_circles: Vec<Circle>,
     redraw_queued: bool,
-
-    font: font_kit::loaders::freetype::Font,
 }
 
 struct Circle {
@@ -192,6 +177,7 @@ impl CompositorHandler for SimpleWindow {
         println!("t={_time} DRAWING FRAME, got {} pending circles", self.queued_circles.len());
         if surface == self.window.wl_surface() {
             self.redraw_queued = false;
+            self.draw_cursors(conn, qh);
             self.draw(conn, qh, false);
         }
     }
@@ -525,7 +511,11 @@ impl tablet_tool::Handler for SimpleWindow {
             println!();
         }
 
-        self.queue_redraw_if_needed(qh);
+        // Even if the main window has nothing to redraw,
+        // the cursors probably do,
+        // and we’re doing only coarse reactivity here,
+        // so just queue a general redraw.
+        self.queue_redraw(qh);
     }
 }
 
@@ -536,18 +526,11 @@ impl ShmHandler for SimpleWindow {
 }
 
 impl SimpleWindow {
-    fn queue_redraw_if_needed(&mut self, qh: &QueueHandle<Self>) {
-        if !self.redraw_queued {
-            if !self.queued_circles.is_empty() {
-                self.queue_redraw(qh);
-            }
-        }
-    }
-
     fn queue_redraw(&mut self, qh: &QueueHandle<Self>) {
         if !self.redraw_queued {
-            println!("   → Queueing redraw");
             let surface = self.window.wl_surface();
+            // In theory, it might be better to do frame callbacks on cursor surfaces; don’t know.
+            // But in practice, doing it on the window surface is plenty good enough.
             surface.frame(qh, surface.clone());
             // Have to commit to make the frame request.
             surface.commit();
@@ -557,9 +540,8 @@ impl SimpleWindow {
 
     pub fn draw(&mut self, _conn: &Connection, _qh: &QueueHandle<Self>, force: bool) {
         if self.queued_circles.is_empty() && !force {
-            println!("Draw called with nothing to do!");
-            // False alarm, we don’t actually have anything to draw.
-            // Nothing to draw, wait until we have something to draw.
+            // Nothing needs updating.
+            // (It was presumably the cursors needing to be updated.)
             return;
         }
 
@@ -605,6 +587,85 @@ impl SimpleWindow {
         println!("Finished drawing frame.");
     }
 
+    pub fn draw_cursors(&mut self, _conn: &Connection, qh: &QueueHandle<Self>) {
+        for (wtool, tool) in &mut self.tools {
+            let Some(tablet_tool::Proximity { serial: proximity_in_serial, .. }) = tool.state.proximity
+            else { continue };
+            let width = 58;
+            let height = 33;
+            let (buffer, canvas) = self.pool.create_buffer(
+                width as i32,
+                height as i32,
+                width as i32 * 4,
+                wl_shm::Format::Argb8888
+            ).expect("create buffer");
+            // https://github.com/Smithay/client-toolkit/issues/488 workaround.
+            let canvas = &mut canvas[..width as usize * height as usize * 4];
+
+            let mut dt = raqote::DrawTarget::from_backing(
+                width as i32,
+                height as i32,
+                bytemuck::cast_slice_mut(canvas),
+            );
+            let o = &raqote::DrawOptions::new();
+            dt.clear(raqote::SolidSource { r: 0, g: 0, b: 0, a: 0 });
+
+            // Draw crosshairs, varyinig with pressure and contact state.
+            {
+                let mut pb = raqote::PathBuilder::new();
+                let radius = 4.0 + 4.0 * tool.state.pressure_web(&tool.info) as f32;
+                pb.move_to(16.5         ,  1.5         );
+                pb.line_to(16.5         , 16.5 - radius);
+                pb.move_to(16.5         , 16.5 + radius);
+                pb.line_to(16.5         , 31.5         );
+                pb.move_to( 1.5         , 16.5         );
+                pb.line_to(16.5 - radius, 16.5         );
+                pb.move_to(16.5 + radius, 16.5         );
+                pb.line_to(31.5         , 16.5         );
+                pb.arc(16.5, 16.5, radius, 0.0, TWO_PI);
+                let path = pb.finish();
+                let mut stroke_style = raqote::StrokeStyle {
+                    width: 3.0,
+                    cap: raqote::LineCap::Square,
+                    ..Default::default()
+                };
+                dt.stroke(&path, &HALF_WHITE, &stroke_style, o);
+                stroke_style.width = 1.0;
+                dt.stroke(&path, &if tool.state.is_down() { DARK_GREEN } else { DARK_RED }, &stroke_style, o);
+            }
+
+            // Draw button states, ’cos why not.
+            {
+                let y = 27.0;
+                let mut x = 30.0;
+                let width = 8.0;
+                let height = 6.0;
+                let dx = 10.0;
+                for pressed in [
+                    tool.state.stylus_button_1_pressed,
+                    tool.state.stylus_button_2_pressed,
+                    tool.state.stylus_button_3_pressed,
+                ] {
+                    dt.fill_rect(x, y, width, height, &BLACK, o);
+                    if !pressed {
+                        dt.fill_rect(x + 1.0, y + 1.0, width - 2.0, height - 2.0, &WHITE, o);
+                    }
+                    x += dx;
+                }
+            }
+
+            // Could draw more, but you get the idea.
+
+            let cursor_surface = Surface::new(&self.compositor_state, qh).unwrap();
+            let cursor_wl_surface = cursor_surface.wl_surface();
+            wtool.set_cursor(proximity_in_serial, Some(cursor_wl_surface), 16, 16);
+            buffer.attach_to(cursor_wl_surface).expect("buffer attach");
+            cursor_wl_surface.damage_buffer(0, 0, width as i32, height as i32);
+            cursor_wl_surface.commit();
+            tool.cursor_surface = Some(cursor_surface);
+        }
+    }
+
     /// Initialise the canvas buffer, damaging but not attaching/committing.
     ///
     /// This should be called whenever the window is resized, too.

From ae0667f70cba1a123bd0ef42a6ac73b1926b930c Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Sat, 29 Mar 2025 15:34:10 +0530
Subject: [PATCH 22/27] Make TabletManager largely implicit, via SeatState
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Is it better? Dunno. But it feels *maybe* warranted.

One thing I’m feeling is that argument ordering is inconsistent:
in some places qh is at the start, in other places at the end.
Am I missing a pattern, or do we need to go revise methodically?
---
 examples/tablet.rs         |  5 +--
 src/seat/mod.rs            | 87 ++++++++++++++++++++++++++++++--------
 src/seat/tablet_manager.rs | 26 +++++++-----
 3 files changed, 86 insertions(+), 32 deletions(-)

diff --git a/examples/tablet.rs b/examples/tablet.rs
index ab9963718..6ef9ca6d2 100644
--- a/examples/tablet.rs
+++ b/examples/tablet.rs
@@ -12,7 +12,6 @@ use smithay_client_toolkit::{
     registry_handlers,
     seat::{
         keyboard::{KeyEvent, KeyboardHandler, Keysym, Modifiers, RawModifiers},
-        TabletManager,
         tablet_seat,
         tablet,
         tablet_tool,
@@ -87,7 +86,6 @@ fn main() {
         compositor_state,
         shm_state,
         _xdg_shell_state: xdg_shell_state,
-        tablet_manager: TabletManager::bind(&globals, &qh),
 
         exit: false,
         width,
@@ -122,7 +120,6 @@ struct SimpleWindow {
     compositor_state: CompositorState,
     shm_state: Shm,
     _xdg_shell_state: XdgShell,
-    tablet_manager: TabletManager,
 
     exit: bool,
     width: u32,
@@ -292,7 +289,7 @@ impl SeatHandler for SimpleWindow {
         // FIXME: this doesn’t seem like the right place to put this.
         // Where *should* it go?
         if self.tablet_seat.is_none() {
-            let tablet_seat = self.tablet_manager.get_tablet_seat(&seat, qh).ok();
+            let tablet_seat = self.seat_state.get_tablet_seat(qh, &seat).ok();
             if tablet_seat.is_some() {
                 println!("Created tablet seat");
             } else {
diff --git a/src/seat/mod.rs b/src/seat/mod.rs
index 46e6d94be..cfd9a44b6 100644
--- a/src/seat/mod.rs
+++ b/src/seat/mod.rs
@@ -36,6 +36,11 @@ use pointer::cursor_shape::CursorShapeManager;
 use pointer::{PointerData, PointerDataExt, PointerHandler, ThemeSpec, ThemedPointer, Themes};
 use touch::{TouchData, TouchDataExt, TouchHandler};
 
+use wayland_protocols::wp::tablet::zv2::client::{
+    zwp_tablet_manager_v2::ZwpTabletManagerV2,
+    zwp_tablet_seat_v2::ZwpTabletSeatV2,
+};
+
 #[non_exhaustive]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Capability {
@@ -67,18 +72,23 @@ pub enum SeatError {
     DeadObject,
 }
 
+#[derive(Debug, thiserror::Error)]
+#[error("the tablet protocol is not supported")]
+pub struct TabletNotSupported;
+
 #[derive(Debug)]
 pub struct SeatState {
     // (name, seat)
     seats: Vec<SeatInner>,
-    cursor_shape_manager_state: CursorShapeManagerState,
+    cursor_shape_manager_state: ManagerState<CursorShapeManager>,
+    tablet_manager_state: ManagerState<TabletManager>,
 }
 
 #[derive(Debug)]
-enum CursorShapeManagerState {
+enum ManagerState<T> {
     NotPresent,
     Pending { registry: WlRegistry, global: Global },
-    Bound(CursorShapeManager),
+    Bound(T),
 }
 
 impl SeatState {
@@ -86,15 +96,25 @@ impl SeatState {
         global_list: &GlobalList,
         qh: &QueueHandle<D>,
     ) -> SeatState {
-        let (seats, cursor_shape_manager) = global_list.contents().with_list(|globals| {
-            let global = globals
-                .iter()
-                .find(|global| global.interface == WpCursorShapeManagerV1::interface().name)
-                .map(|global| CursorShapeManagerState::Pending {
-                    registry: global_list.registry().clone(),
-                    global: global.clone(),
-                })
-                .unwrap_or(CursorShapeManagerState::NotPresent);
+        let (seats, cursor_shape_manager_state, tablet_manager_state) =
+        global_list.contents().with_list(|globals| {
+            let mut csm = ManagerState::NotPresent;
+            let mut tm = ManagerState::NotPresent;
+            let csm_name = WpCursorShapeManagerV1::interface().name;
+            let tm_name = ZwpTabletManagerV2::interface().name;
+            for global in globals {
+                if global.interface == csm_name {
+                    csm = ManagerState::Pending {
+                        registry: global_list.registry().clone(),
+                        global: global.clone(),
+                    };
+                } else if global.interface == tm_name {
+                    tm = ManagerState::Pending {
+                        registry: global_list.registry().clone(),
+                        global: global.clone(),
+                    };
+                }
+            }
 
             (
                 crate::registry::bind_all(global_list.registry(), globals, qh, 1..=7, |id| {
@@ -107,12 +127,13 @@ impl SeatState {
                     }
                 })
                 .expect("failed to bind global"),
-                global,
+                csm,
+                tm,
             )
         });
 
         let mut state =
-            SeatState { seats: vec![], cursor_shape_manager_state: cursor_shape_manager };
+            SeatState { seats: vec![], cursor_shape_manager_state, tablet_manager_state };
 
         for seat in seats {
             let data = seat.data::<SeatData>().unwrap().clone();
@@ -251,21 +272,21 @@ impl SeatState {
 
         let wl_ptr = seat.get_pointer(qh, pointer_data);
 
-        if let CursorShapeManagerState::Pending { registry, global } =
+        if let ManagerState::Pending { registry, global } =
             &self.cursor_shape_manager_state
         {
             self.cursor_shape_manager_state =
                 match crate::registry::bind_one(registry, &[global.clone()], qh, 1..=1, GlobalData)
                 {
                     Ok(bound) => {
-                        CursorShapeManagerState::Bound(CursorShapeManager::from_existing(bound))
+                        ManagerState::Bound(CursorShapeManager::from_existing(bound))
                     }
-                    Err(_) => CursorShapeManagerState::NotPresent,
+                    Err(_) => ManagerState::NotPresent,
                 }
         }
 
         let shape_device =
-            if let CursorShapeManagerState::Bound(ref bound) = self.cursor_shape_manager_state {
+            if let ManagerState::Bound(ref bound) = self.cursor_shape_manager_state {
                 Some(bound.get_shape_device(&wl_ptr, qh))
             } else {
                 None
@@ -322,6 +343,36 @@ impl SeatState {
 
         Ok(seat.get_touch(qh, udata))
     }
+
+    /// Get a tablet seat, to gain access to tablets, tools, et cetera.
+    pub fn get_tablet_seat<D>(
+        &mut self,
+        qh: &QueueHandle<D>,
+        seat: &wl_seat::WlSeat,
+    ) -> Result<ZwpTabletSeatV2, TabletNotSupported>
+    where
+        D: Dispatch<ZwpTabletSeatV2, ()> + 'static,
+        D: Dispatch<ZwpTabletManagerV2, GlobalData> + 'static,
+    {
+        if let ManagerState::Pending { registry, global } =
+            &self.tablet_manager_state
+        {
+            self.tablet_manager_state =
+                match crate::registry::bind_one(registry, &[global.clone()], qh, 1..=1, GlobalData)
+                {
+                    Ok(bound) => {
+                        ManagerState::Bound(TabletManager::from_existing(bound))
+                    }
+                    Err(_) => ManagerState::NotPresent,
+                }
+        }
+
+        if let ManagerState::Bound(bound) = &self.tablet_manager_state {
+            Ok(bound.get_tablet_seat(seat, qh))
+        } else {
+            Err(TabletNotSupported)
+        }
+    }
 }
 
 pub trait SeatHandler: Sized {
diff --git a/src/seat/tablet_manager.rs b/src/seat/tablet_manager.rs
index bb7414402..2f25a5e38 100644
--- a/src/seat/tablet_manager.rs
+++ b/src/seat/tablet_manager.rs
@@ -1,5 +1,5 @@
 use wayland_client::{
-    globals::GlobalList,
+    globals::{BindError, GlobalList},
     protocol::wl_seat::WlSeat,
     Connection,
     Dispatch,
@@ -11,33 +11,39 @@ use wayland_protocols::wp::tablet::zv2::client::{
     zwp_tablet_seat_v2::ZwpTabletSeatV2,
 };
 
-use crate::{error::GlobalError, globals::GlobalData, registry::GlobalProxy};
+use crate::globals::GlobalData;
 
 #[derive(Debug)]
 pub struct TabletManager {
-    tablet_manager: GlobalProxy<ZwpTabletManagerV2>,
+    tablet_manager: ZwpTabletManagerV2,
 }
 
 impl TabletManager {
     /// Bind `zwp_tablet_manager_v2` global, if it exists
-    pub fn bind<D>(globals: &GlobalList, qh: &QueueHandle<D>) -> Self
+    pub fn bind<State>(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<State>,
+    ) -> Result<Self, BindError>
     where
-        D: Dispatch<ZwpTabletManagerV2, GlobalData> + 'static,
+        State: Dispatch<ZwpTabletManagerV2, GlobalData> + 'static,
     {
-        Self {
-            tablet_manager: GlobalProxy::from(globals.bind(qh, 1..=1, GlobalData)),
-        }
+        let tablet_manager = globals.bind(queue_handle, 1..=1, GlobalData)?;
+        Ok(Self { tablet_manager })
+    }
+
+    pub(crate) fn from_existing(tablet_manager: ZwpTabletManagerV2) -> Self {
+        Self { tablet_manager }
     }
 
     pub fn get_tablet_seat<D>(
         &self,
         seat: &WlSeat,
         qh: &QueueHandle<D>,
-    ) -> Result<ZwpTabletSeatV2, GlobalError>
+    ) -> ZwpTabletSeatV2
     where
         D: Dispatch<ZwpTabletSeatV2, ()> + 'static,
     {
-        Ok(self.tablet_manager.get()?.get_tablet_seat(seat, qh, ()))
+        self.tablet_manager.get_tablet_seat(seat, qh, ())
     }
 }
 

From d13e2ecdbefd245db3f0257a690f16df24d55c8d Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Sat, 29 Mar 2025 16:07:36 +0530
Subject: [PATCH 23/27] Refactor manager globals, expose cursor shape manager
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Pointer has CSM all wrapped up tight, but tablet doesn’t yet.
Exposing CSM is the easiest approach for now.
---
 src/seat/mod.rs | 92 ++++++++++++++++++++++++-------------------------
 1 file changed, 46 insertions(+), 46 deletions(-)

diff --git a/src/seat/mod.rs b/src/seat/mod.rs
index cfd9a44b6..005ebe790 100644
--- a/src/seat/mod.rs
+++ b/src/seat/mod.rs
@@ -7,7 +7,7 @@ use std::{
 };
 
 use crate::reexports::client::{
-    globals::{Global, GlobalList},
+    globals::{BindError, Global, GlobalList},
     protocol::{wl_pointer, wl_registry::WlRegistry, wl_seat, wl_shm, wl_surface, wl_touch},
     Connection, Dispatch, Proxy, QueueHandle,
 };
@@ -72,10 +72,6 @@ pub enum SeatError {
     DeadObject,
 }
 
-#[derive(Debug, thiserror::Error)]
-#[error("the tablet protocol is not supported")]
-pub struct TabletNotSupported;
-
 #[derive(Debug)]
 pub struct SeatState {
     // (name, seat)
@@ -86,11 +82,38 @@ pub struct SeatState {
 
 #[derive(Debug)]
 enum ManagerState<T> {
-    NotPresent,
+    Failed(BindError),
     Pending { registry: WlRegistry, global: Global },
     Bound(T),
 }
 
+impl<T> ManagerState<T> {
+    fn bind<I, D>(&mut self, qh: &QueueHandle<D>, version: std::ops::RangeInclusive<u32>, f: impl FnOnce(I) -> T) -> Result<&T, BindError>
+    where
+        I: Proxy + 'static,
+        D: Dispatch<I, GlobalData> + 'static,
+    {
+        *self = match std::mem::replace(self, ManagerState::Failed(BindError::NotPresent)) {
+            ManagerState::Pending { registry, global } => {
+                match crate::registry::bind_one(&registry, &[global], qh, version, GlobalData) {
+                    Ok(bound) => ManagerState::Bound(f(bound)),
+                    Err(e) => ManagerState::Failed(e),
+                }
+            }
+            other => other,
+        };
+
+        match self {
+            ManagerState::Bound(bound) => Ok(bound),
+            // FIXME: make BindError impl Clone
+            //ManagerState::Failed(e) => Err(e.clone()),
+            ManagerState::Failed(BindError::UnsupportedVersion) => Err(BindError::UnsupportedVersion),
+            ManagerState::Failed(BindError::NotPresent) => Err(BindError::NotPresent),
+            ManagerState::Pending { .. } => unreachable!(),
+        }
+    }
+}
+
 impl SeatState {
     pub fn new<D: Dispatch<wl_seat::WlSeat, SeatData> + 'static>(
         global_list: &GlobalList,
@@ -98,8 +121,8 @@ impl SeatState {
     ) -> SeatState {
         let (seats, cursor_shape_manager_state, tablet_manager_state) =
         global_list.contents().with_list(|globals| {
-            let mut csm = ManagerState::NotPresent;
-            let mut tm = ManagerState::NotPresent;
+            let mut csm = ManagerState::Failed(BindError::NotPresent);
+            let mut tm = ManagerState::Failed(BindError::NotPresent);
             let csm_name = WpCursorShapeManagerV1::interface().name;
             let tm_name = ZwpTabletManagerV2::interface().name;
             for global in globals {
@@ -272,25 +295,8 @@ impl SeatState {
 
         let wl_ptr = seat.get_pointer(qh, pointer_data);
 
-        if let ManagerState::Pending { registry, global } =
-            &self.cursor_shape_manager_state
-        {
-            self.cursor_shape_manager_state =
-                match crate::registry::bind_one(registry, &[global.clone()], qh, 1..=1, GlobalData)
-                {
-                    Ok(bound) => {
-                        ManagerState::Bound(CursorShapeManager::from_existing(bound))
-                    }
-                    Err(_) => ManagerState::NotPresent,
-                }
-        }
-
-        let shape_device =
-            if let ManagerState::Bound(ref bound) = self.cursor_shape_manager_state {
-                Some(bound.get_shape_device(&wl_ptr, qh))
-            } else {
-                None
-            };
+        let shape_device = self.cursor_shape_manager(qh).ok()
+            .map(|csm| csm.get_shape_device(&wl_ptr, qh));
 
         Ok(ThemedPointer {
             themes: Arc::new(Mutex::new(Themes::new(theme))),
@@ -303,6 +309,16 @@ impl SeatState {
         })
     }
 
+    pub fn cursor_shape_manager<D>(&mut self, qh: &QueueHandle<D>)
+        -> Result<&CursorShapeManager, BindError>
+    where
+        D: Dispatch<WpCursorShapeManagerV1, GlobalData>,
+        D: Dispatch<WpCursorShapeDeviceV1, GlobalData>,
+        D: 'static,
+    {
+        self.cursor_shape_manager_state.bind(qh, 1..=1, CursorShapeManager::from_existing)
+    }
+
     /// Creates a touch handle from a seat.
     ///
     /// ## Errors
@@ -349,29 +365,13 @@ impl SeatState {
         &mut self,
         qh: &QueueHandle<D>,
         seat: &wl_seat::WlSeat,
-    ) -> Result<ZwpTabletSeatV2, TabletNotSupported>
+    ) -> Result<ZwpTabletSeatV2, BindError>
     where
         D: Dispatch<ZwpTabletSeatV2, ()> + 'static,
         D: Dispatch<ZwpTabletManagerV2, GlobalData> + 'static,
     {
-        if let ManagerState::Pending { registry, global } =
-            &self.tablet_manager_state
-        {
-            self.tablet_manager_state =
-                match crate::registry::bind_one(registry, &[global.clone()], qh, 1..=1, GlobalData)
-                {
-                    Ok(bound) => {
-                        ManagerState::Bound(TabletManager::from_existing(bound))
-                    }
-                    Err(_) => ManagerState::NotPresent,
-                }
-        }
-
-        if let ManagerState::Bound(bound) = &self.tablet_manager_state {
-            Ok(bound.get_tablet_seat(seat, qh))
-        } else {
-            Err(TabletNotSupported)
-        }
+        let tm = self.tablet_manager_state.bind(qh, 1..=1, TabletManager::from_existing)?;
+        Ok(tm.get_tablet_seat(seat, qh))
     }
 }
 

From 9e4c0564a0734f23a2152060724d0cc49dde493c Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Sat, 29 Mar 2025 19:01:53 +0530
Subject: [PATCH 24/27] Tidy up example a bit, improve logging
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Its logging is comparatively important for grasping what’s going on,
and wanted a little more care put into it.
---
 examples/tablet.rs | 44 +++++++++++++++++++-------------------------
 1 file changed, 19 insertions(+), 25 deletions(-)

diff --git a/examples/tablet.rs b/examples/tablet.rs
index 6ef9ca6d2..b9d21024d 100644
--- a/examples/tablet.rs
+++ b/examples/tablet.rs
@@ -50,6 +50,8 @@ const DARK_GREEN: raqote::Source = raqote::Source::Solid(raqote::SolidSource { r
 const DARK_RED: raqote::Source = raqote::Source::Solid(raqote::SolidSource { r: 153, g: 0, b: 0, a: 255 });
 const HALF_WHITE: raqote::Source = raqote::Source::Solid(raqote::SolidSource { r: 127, g: 127, b: 127, a: 127 });
 
+const NO_TIME: &'static str = "               ";
+
 fn main() {
     env_logger::init();
 
@@ -169,9 +171,9 @@ impl CompositorHandler for SimpleWindow {
         conn: &Connection,
         qh: &QueueHandle<Self>,
         surface: &wl_surface::WlSurface,
-        _time: u32,
+        time: u32,
     ) {
-        println!("t={_time} DRAWING FRAME, got {} pending circles", self.queued_circles.len());
+        println!("[t={time:10}] draw Frame callback, {} circles to draw", self.queued_circles.len());
         if surface == self.window.wl_surface() {
             self.redraw_queued = false;
             self.draw_cursors(conn, qh);
@@ -274,28 +276,17 @@ impl SeatHandler for SimpleWindow {
         capability: Capability,
     ) {
         if capability == Capability::Keyboard && self.keyboard.is_none() {
-            println!("Set keyboard capability");
-            let keyboard = self
-                .seat_state
-                .get_keyboard(
-                    qh,
-                    &seat,
-                    None,
-                )
-                .expect("Failed to create keyboard");
-
-            self.keyboard = Some(keyboard);
+            self.keyboard = self.seat_state.get_keyboard(qh, &seat, None).ok();
         }
         // FIXME: this doesn’t seem like the right place to put this.
         // Where *should* it go?
         if self.tablet_seat.is_none() {
-            let tablet_seat = self.seat_state.get_tablet_seat(qh, &seat).ok();
-            if tablet_seat.is_some() {
-                println!("Created tablet seat");
+            self.tablet_seat = self.seat_state.get_tablet_seat(qh, &seat).ok();
+            if self.tablet_seat.is_some() {
+                println!("Created tablet_seat");
             } else {
-                println!("Compositor does not support tablet events");
+                println!("Compositor does not support tablet events");
             }
-            self.tablet_seat = tablet_seat;
         }
     }
 
@@ -397,7 +388,7 @@ impl tablet::Handler for SimpleWindow {
         tablet: &ZwpTabletV2,
         info: tablet::Info,
     ) {
-        println!("Tablet {} initialised: {:#?}", tablet.id(), info);
+        println!("{NO_TIME}tablet.done {}: {:?}", tablet.id(), info);
         self.tablets.insert(tablet.clone(), info);
     }
 
@@ -407,7 +398,7 @@ impl tablet::Handler for SimpleWindow {
         _: &QueueHandle<Self>,
         tablet: &ZwpTabletV2,
     ) {
-        println!("Tablet {} removed", tablet.id());
+        println!("{NO_TIME}tablet.removed {}", tablet.id());
         self.tablets.remove(tablet);
     }
 }
@@ -420,7 +411,7 @@ impl tablet_tool::Handler for SimpleWindow {
         wtool: &ZwpTabletToolV2,
         info: tablet_tool::Info,
     ) {
-        println!("Tablet tool {} initialised: {:#?}", wtool.id(), info);
+        println!("{NO_TIME}tablet_tool.done {}: {:?}", wtool.id(), info);
         self.tools.insert(wtool.clone(), Tool {
             info,
             state: tablet_tool::State::new(),
@@ -434,7 +425,7 @@ impl tablet_tool::Handler for SimpleWindow {
         _qh: &QueueHandle<Self>,
         wtool: &ZwpTabletToolV2,
     ) {
-        println!("Tablet tool {} removed", wtool.id());
+        println!("{NO_TIME}tablet_tool.removed {}", wtool.id());
         self.tools.remove(wtool);
     }
 
@@ -448,6 +439,7 @@ impl tablet_tool::Handler for SimpleWindow {
         let tool = self.tools.get_mut(wtool).expect("got frame for unknown tool");
         tool.state.ingest_frame(events);
 
+        print!("[t={:10}] tablet_tool.frame ", tool.state.time);
         if tool.state.is_in_proximity() {
             if tool.state.is_down() {
                 let pressure = tool.state.pressure_web(&tool.info);
@@ -473,8 +465,7 @@ impl tablet_tool::Handler for SimpleWindow {
                 });
             }
 
-            print!("t={}   tablet state    {} x={:7.2} y={:7.2}",
-                tool.state.time,
+            print!("{} x={:7.2} y={:7.2}",
                 if tool.state.is_down() { "down" } else { "up  " },
                 tool.state.x,
                 tool.state.y);
@@ -506,6 +497,8 @@ impl tablet_tool::Handler for SimpleWindow {
                 print!(" button:3");
             }
             println!();
+        } else {
+            println!("left proximity");
         }
 
         // Even if the main window has nothing to redraw,
@@ -537,6 +530,7 @@ impl SimpleWindow {
 
     pub fn draw(&mut self, _conn: &Connection, _qh: &QueueHandle<Self>, force: bool) {
         if self.queued_circles.is_empty() && !force {
+            println!("{NO_TIME}draw Nothing to draw in the window");
             // Nothing needs updating.
             // (It was presumably the cursors needing to be updated.)
             return;
@@ -581,7 +575,7 @@ impl SimpleWindow {
         }
         buffer.attach_to(surface).expect("buffer attach");
         surface.commit();
-        println!("Finished drawing frame.");
+        println!("{NO_TIME}draw Finished drawing frame");
     }
 
     pub fn draw_cursors(&mut self, _conn: &Connection, qh: &QueueHandle<Self>) {

From c9fe2f695d47bf5631c8c1aa0f9fde92dda3be8f Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Sat, 29 Mar 2025 19:03:06 +0530
Subject: [PATCH 25/27] Support cursor shapes on tablet tools, a bit
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This should make it possible (untested),
but it’s clearly not finished yet.
---
 examples/tablet.rs               | 15 +++++++++++++++
 src/seat/pointer/cursor_shape.rs | 12 ++++++++++++
 2 files changed, 27 insertions(+)

diff --git a/examples/tablet.rs b/examples/tablet.rs
index b9d21024d..33390d605 100644
--- a/examples/tablet.rs
+++ b/examples/tablet.rs
@@ -113,6 +113,21 @@ struct Tool {
     info: tablet_tool::Info,
     state: tablet_tool::State,
     cursor_surface: Option<Surface>,
+    // This demo is currently only hooked up for custom cursors,
+    // which were a mite easier to implement, more interesting,
+    // and may be more commonly desired with tablets anyway.
+    // If you want to use standard theme cursors,
+    // for now the easiest (but not quite perfect) way is:
+    //
+    // 1. Add this field:
+    //    cursor_shape_device: smithay_client_toolkit::reexports::protocols::wp::cursor_shape::v1::client::wp_cursor_shape_device_v1::WpCursorShapeDeviceV1,
+    //
+    // 2. Populate it from window.seat_state.cursor_shape_manager(qh).get_shape_device_for_tablet_tool(…).
+    //
+    // 3. On ProximityIn events, call cursor_shape_device.set_shape(state.proximity?.serial, shape).
+    //
+    // In the future, this should be better integrated, like it is with ThemedPointer,
+    // but for now that’s the general outline.
 }
 
 struct SimpleWindow {
diff --git a/src/seat/pointer/cursor_shape.rs b/src/seat/pointer/cursor_shape.rs
index d6129745a..973b9c4a3 100644
--- a/src/seat/pointer/cursor_shape.rs
+++ b/src/seat/pointer/cursor_shape.rs
@@ -3,6 +3,7 @@ use cursor_icon::CursorIcon;
 use crate::globals::GlobalData;
 use crate::reexports::client::globals::{BindError, GlobalList};
 use crate::reexports::client::protocol::wl_pointer::WlPointer;
+use crate::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_tool_v2::ZwpTabletToolV2;
 use crate::reexports::client::{Connection, Dispatch, Proxy, QueueHandle};
 use crate::reexports::protocols::wp::cursor_shape::v1::client::wp_cursor_shape_device_v1::Shape;
 use crate::reexports::protocols::wp::cursor_shape::v1::client::wp_cursor_shape_device_v1::WpCursorShapeDeviceV1;
@@ -40,6 +41,17 @@ impl CursorShapeManager {
         self.cursor_shape_manager.get_pointer(pointer, queue_handle, GlobalData)
     }
 
+    pub fn get_shape_device_for_tablet_tool<State>(
+        &self,
+        tablet_tool: &ZwpTabletToolV2,
+        queue_handle: &QueueHandle<State>,
+    ) -> WpCursorShapeDeviceV1
+    where
+        State: Dispatch<WpCursorShapeDeviceV1, GlobalData> + 'static,
+    {
+        self.cursor_shape_manager.get_tablet_tool_v2(tablet_tool, queue_handle, GlobalData)
+    }
+
     pub fn inner(&self) -> &WpCursorShapeManagerV1 {
         &self.cursor_shape_manager
     }

From 7d7f20d5f8dbfd46c1f31db33d05899484299ce9 Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Sat, 29 Mar 2025 19:04:03 +0530
Subject: [PATCH 26/27] Refactor SeatState::new for subjective prettiness

---
 src/seat/mod.rs | 41 +++++++++++++++++------------------------
 1 file changed, 17 insertions(+), 24 deletions(-)

diff --git a/src/seat/mod.rs b/src/seat/mod.rs
index 005ebe790..a7b985ac4 100644
--- a/src/seat/mod.rs
+++ b/src/seat/mod.rs
@@ -119,40 +119,33 @@ impl SeatState {
         global_list: &GlobalList,
         qh: &QueueHandle<D>,
     ) -> SeatState {
-        let (seats, cursor_shape_manager_state, tablet_manager_state) =
-        global_list.contents().with_list(|globals| {
-            let mut csm = ManagerState::Failed(BindError::NotPresent);
-            let mut tm = ManagerState::Failed(BindError::NotPresent);
-            let csm_name = WpCursorShapeManagerV1::interface().name;
-            let tm_name = ZwpTabletManagerV2::interface().name;
+        let mut cursor_shape_manager_state = ManagerState::Failed(BindError::NotPresent);
+        let mut tablet_manager_state = ManagerState::Failed(BindError::NotPresent);
+        let seats = global_list.contents().with_list(|globals| {
             for global in globals {
-                if global.interface == csm_name {
-                    csm = ManagerState::Pending {
+                if global.interface == WpCursorShapeManagerV1::interface().name {
+                    cursor_shape_manager_state = ManagerState::Pending {
                         registry: global_list.registry().clone(),
                         global: global.clone(),
                     };
-                } else if global.interface == tm_name {
-                    tm = ManagerState::Pending {
+                } else if global.interface == ZwpTabletManagerV2::interface().name {
+                    tablet_manager_state = ManagerState::Pending {
                         registry: global_list.registry().clone(),
                         global: global.clone(),
                     };
                 }
             }
 
-            (
-                crate::registry::bind_all(global_list.registry(), globals, qh, 1..=7, |id| {
-                    SeatData {
-                        has_keyboard: Arc::new(AtomicBool::new(false)),
-                        has_pointer: Arc::new(AtomicBool::new(false)),
-                        has_touch: Arc::new(AtomicBool::new(false)),
-                        name: Arc::new(Mutex::new(None)),
-                        id,
-                    }
-                })
-                .expect("failed to bind global"),
-                csm,
-                tm,
-            )
+            crate::registry::bind_all(global_list.registry(), globals, qh, 1..=7, |id| {
+                SeatData {
+                    has_keyboard: Arc::new(AtomicBool::new(false)),
+                    has_pointer: Arc::new(AtomicBool::new(false)),
+                    has_touch: Arc::new(AtomicBool::new(false)),
+                    name: Arc::new(Mutex::new(None)),
+                    id,
+                }
+            })
+            .expect("failed to bind global")
         });
 
         let mut state =

From 5dd2be3202836e739845ac9c24803f656302ba0e Mon Sep 17 00:00:00 2001
From: Chris Morgan <me@chrismorgan.info>
Date: Sat, 29 Mar 2025 19:16:07 +0530
Subject: [PATCH 27/27] Make {tablet, tablet_tool}::Info non-exhaustive
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Almost forgot! Important for forwards-compatibility,
e.g. this new bus type thing on tablet which I haven’t added yet.
---
 src/seat/tablet.rs      | 1 +
 src/seat/tablet_tool.rs | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/seat/tablet.rs b/src/seat/tablet.rs
index c604867ff..38a21f660 100644
--- a/src/seat/tablet.rs
+++ b/src/seat/tablet.rs
@@ -33,6 +33,7 @@ pub trait Handler: Sized {
 
 /// The description of a tablet device.
 #[derive(Debug, Default)]
+#[non_exhaustive]
 pub struct Info {
     /// The descriptive name of the tablet device.
     pub name: Option<String>,
diff --git a/src/seat/tablet_tool.rs b/src/seat/tablet_tool.rs
index b6c63244e..f5c83b5b8 100644
--- a/src/seat/tablet_tool.rs
+++ b/src/seat/tablet_tool.rs
@@ -55,6 +55,7 @@ const HARDWARE_ID_WACOM: Capabilities = Capabilities::from_bits_retain(0b1000000
 
 /// Static information about the tool and its capabilities.
 #[derive(Clone, PartialEq, Eq)]
+#[non_exhaustive]
 pub struct Info {
     // Wish this was #[repr(u8)]… it’s wasting four bytes.
     r#type: Type,