wayland: implement wlr-virtual-pointer-unstable-v1

src/ifs/zwlr_virtual_pointer_v1.rs

@@ -0,0 +1,209 @@
+use {
+    crate::{
+        backend::{AxisSource as BackendAxisSource, ButtonState, ScrollAxis},
+        client::{Client, ClientError},
+        fixed::Fixed,
+        ifs::{
+            wl_output::OutputGlobalOpt,
+            wl_seat::{
+                PX_PER_SCROLL, WlSeatGlobal,
+                wl_pointer::{self, CONTINUOUS, FINGER, PRESSED, RELEASED, WHEEL},
+            },
+        },
+        leaks::Tracker,
+        object::{Object, Version},
+        utils::{copyhashmap::CopyHashMap, syncqueue::SyncQueue},
+        wire::{ZwlrVirtualPointerV1Id, zwlr_virtual_pointer_v1::*},
+    },
+    std::rc::Rc,
+    thiserror::Error,
+};
+
+pub struct ZwlrVirtualPointerV1 {
+    pub id: ZwlrVirtualPointerV1Id,
+    pub client: Rc<Client>,
+    pub tracker: Tracker<Self>,
+    pub version: Version,
+    pub events: SyncQueue<Event>,
+    pub seat: Rc<WlSeatGlobal>,
+    pub output: Option<Rc<OutputGlobalOpt>>,
+    pub buttons: CopyHashMap<u32, ()>,
+}
+
+pub enum Event {
+    Motion(u32, Fixed, Fixed),
+    MotionAbsolute(u32, u32, u32, u32, u32),
+    Button(u32, u32, ButtonState),
+    Axis(u32, ScrollAxis, Fixed),
+    AxisSource(BackendAxisSource),
+    AxisStop(u32, ScrollAxis),
+    AxisDiscrete(u32, ScrollAxis, Fixed, i32),
+}
+
+fn map_axis(axis: u32) -> Result<ScrollAxis, ZwlrVirtualPointerV1Error> {
+    const VERTICAL_SCROLL: u32 = wl_pointer::VERTICAL_SCROLL as u32;
+    const HORIZONTAL_SCROLL: u32 = wl_pointer::HORIZONTAL_SCROLL as u32;
+    let axis = match axis {
+        VERTICAL_SCROLL => ScrollAxis::Vertical,
+        HORIZONTAL_SCROLL => ScrollAxis::Horizontal,
+        n => return Err(ZwlrVirtualPointerV1Error::UnknownAxis(n)),
+    };
+    Ok(axis)
+}
+
+impl ZwlrVirtualPointerV1 {
+    fn detach(&self) {
+        for (button, _) in self.buttons.lock().drain() {
+            let now = self.client.state.now_usec();
+            self.seat.button_event(now, button, ButtonState::Released);
+        }
+    }
+}
+
+impl ZwlrVirtualPointerV1RequestHandler for ZwlrVirtualPointerV1 {
+    type Error = ZwlrVirtualPointerV1Error;
+
+    fn motion(&self, req: Motion, _slf: &Rc<Self>) -> Result<(), Self::Error> {
+        self.events.push(Event::Motion(req.time, req.dx, req.dy));
+        Ok(())
+    }
+
+    fn motion_absolute(&self, req: MotionAbsolute, _slf: &Rc<Self>) -> Result<(), Self::Error> {
+        self.events.push(Event::MotionAbsolute(
+            req.time,
+            req.x,
+            req.y,
+            req.x_extent,
+            req.y_extent,
+        ));
+        Ok(())
+    }
+
+    fn button(&self, req: Button, _slf: &Rc<Self>) -> Result<(), Self::Error> {
+        let state = match req.state {
+            RELEASED => ButtonState::Released,
+            PRESSED => ButtonState::Pressed,
+            n => return Err(ZwlrVirtualPointerV1Error::UnknownButtonState(n)),
+        };
+        self.events.push(Event::Button(req.time, req.button, state));
+        Ok(())
+    }
+
+    fn axis(&self, req: Axis, _slf: &Rc<Self>) -> Result<(), Self::Error> {
+        self.events
+            .push(Event::Axis(req.time, map_axis(req.axis)?, req.value));
+        Ok(())
+    }
+
+    fn frame(&self, _req: Frame, _slf: &Rc<Self>) -> Result<(), Self::Error> {
+        fn ms_to_us(ms: u32) -> u64 {
+            ms as u64 * 1_000
+        }
+        let mut axis_time = None;
+        while let Some(ev) = self.events.pop() {
+            match ev {
+                Event::Motion(time, dx, dy) => {
+                    self.seat.motion_event(ms_to_us(time), dx, dy, dx, dy);
+                }
+                Event::MotionAbsolute(time, x, y, x_max, y_max) => {
+                    let x = x as f32 / x_max as f32;
+                    let y = y as f32 / y_max as f32;
+                    let rect = self
+                        .output
+                        .as_ref()
+                        .and_then(|c| c.get())
+                        .map(|g| g.pos.get())
+                        .unwrap_or_else(|| self.client.state.root.extents.get());
+                    self.seat.motion_absolute_event(ms_to_us(time), rect, x, y);
+                }
+                Event::Button(time, button, state) => {
+                    match state {
+                        ButtonState::Released => self.buttons.remove(&button),
+                        ButtonState::Pressed => self.buttons.set(button, ()),
+                    };
+                    self.seat.button_event(ms_to_us(time), button, state);
+                }
+                Event::Axis(time, axis, v) => {
+                    axis_time = Some(time);
+                    self.seat.axis_px(v, axis, false);
+                }
+                Event::AxisSource(source) => {
+                    self.seat.axis_source(source);
+                }
+                Event::AxisStop(time, axis) => {
+                    axis_time = Some(time);
+                    self.seat.axis_stop(axis);
+                }
+                Event::AxisDiscrete(time, axis, value, discrete) => {
+                    axis_time = Some(time);
+                    self.seat.axis_px(value, axis, false);
+                    self.seat
+                        .axis_120(discrete.saturating_mul(120), axis, false);
+                }
+            }
+        }
+        if let Some(time) = axis_time {
+            self.seat.axis_frame(PX_PER_SCROLL, ms_to_us(time));
+        }
+        Ok(())
+    }
+
+    fn axis_source(&self, req: AxisSource, _slf: &Rc<Self>) -> Result<(), Self::Error> {
+        let source = match req.axis_source {
+            WHEEL => BackendAxisSource::Wheel,
+            FINGER => BackendAxisSource::Finger,
+            CONTINUOUS => BackendAxisSource::Continuous,
+            n => return Err(ZwlrVirtualPointerV1Error::UnknownAxisSource(n)),
+        };
+        self.events.push(Event::AxisSource(source));
+        Ok(())
+    }
+
+    fn axis_stop(&self, req: AxisStop, _slf: &Rc<Self>) -> Result<(), Self::Error> {
+        self.events
+            .push(Event::AxisStop(req.time, map_axis(req.axis)?));
+        Ok(())
+    }
+
+    fn axis_discrete(&self, req: AxisDiscrete, _slf: &Rc<Self>) -> Result<(), Self::Error> {
+        self.events.push(Event::AxisDiscrete(
+            req.time,
+            map_axis(req.axis)?,
+            req.value,
+            req.discrete,
+        ));
+        Ok(())
+    }
+
+    fn destroy(&self, _req: Destroy, _slf: &Rc<Self>) -> Result<(), Self::Error> {
+        self.client.remove_obj(self)?;
+        self.detach();
+        Ok(())
+    }
+}
+
+object_base! {
+    self = ZwlrVirtualPointerV1;
+    version = self.version;
+}
+
+impl Object for ZwlrVirtualPointerV1 {
+    fn break_loops(&self) {
+        self.detach();
+    }
+}
+
+simple_add_obj!(ZwlrVirtualPointerV1);
+
+#[derive(Debug, Error)]
+pub enum ZwlrVirtualPointerV1Error {
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+    #[error("Unknown button state {0}")]
+    UnknownButtonState(u32),
+    #[error("Unknown axis {0}")]
+    UnknownAxis(u32),
+    #[error("Unknown axis source {0}")]
+    UnknownAxisSource(u32),
+}
+efrom!(ZwlrVirtualPointerV1Error, ClientError);