seat/pointer: add support for cursor-shape-v1

kchibisov · kchibisov · commit fdb57b945597 · 2023-07-20T21:39:56.000+04:00
When using `ThemedPointer` automatically use the `cursor-shape-v1`
protocol to set cursor icon if the seat was made aware to use
cursor_shape.

We still accept the `WlSurface` and `WlShm` when building the
`ThemedPointer` to handle the pointer hiding and custom cursor
setting.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -18,6 +18,8 @@
 
 - Make `DataDeviceManagerState`'s `create_{copy_paste,drag_and_drop}_source` accept `IntoIterator<Item = T: ToString>`.
 - Add support for `zwp_primary_selection_v1`.
+- `CursorShapeManager` providing handling for `cursor-shape-v1` protocol.
+- `SeatState::with_cursor_shape_state_manager` to automatically utilize `cursor-shape-v1` for `ThemedPointer`.
 
 ## 0.17.0 - 2023-03-28
 
diff --git a/Cargo.toml b/Cargo.toml
@@ -26,7 +26,7 @@ thiserror = "1.0.30"
 wayland-backend = "0.1.0"
 wayland-client = "0.30.1"
 wayland-cursor = "0.30.0"
-wayland-protocols = { version = "0.30.0", features = ["client", "unstable"] }
+wayland-protocols = { version = "0.30.1", features = ["client", "staging", "unstable"] }
 wayland-protocols-wlr = { version = "0.1.0", features = ["client"] }
 wayland-scanner = "0.30.0"
 wayland-csd-frame = "0.1.0"
diff --git a/examples/themed_window.rs b/examples/themed_window.rs
@@ -11,6 +11,7 @@ use smithay_client_toolkit::reexports::csd_frame::{
 };
 use smithay_client_toolkit::reexports::protocols::xdg::shell::client::xdg_toplevel::ResizeEdge as XdgResizeEdge;
 use smithay_client_toolkit::seat::keyboard::keysyms;
+use smithay_client_toolkit::seat::pointer::cursor_shape::CursorShapeManager;
 use smithay_client_toolkit::{
     compositor::{CompositorHandler, CompositorState},
     delegate_compositor, delegate_keyboard, delegate_output, delegate_pointer, delegate_registry,
@@ -87,7 +88,8 @@ fn main() {
     let (globals, mut event_queue) = registry_queue_init(&conn).unwrap();
     let qh = event_queue.handle();
     let registry_state = RegistryState::new(&globals);
-    let seat_state = SeatState::new(&globals, &qh);
+    let csm = CursorShapeManager::bind(&globals, &qh).ok();
+    let seat_state = SeatState::new(&globals, &qh).with_cursor_shape_manager(csm);
     let output_state = OutputState::new(&globals, &qh);
     let compositor_state =
         CompositorState::bind(&globals, &qh).expect("wl_compositor not available");
diff --git a/src/seat/mod.rs b/src/seat/mod.rs
@@ -21,13 +21,14 @@ use wayland_client::{
 
 use crate::{
     compositor::SurfaceDataExt,
+    globals::GlobalData,
     registry::{ProvidesRegistryState, RegistryHandler},
 };
 
-use self::{
-    pointer::{PointerData, PointerDataExt, PointerHandler, ThemeSpec, ThemedPointer, Themes},
-    touch::{TouchData, TouchDataExt, TouchHandler},
-};
+use crate::reexports::protocols::wp::cursor_shape::v1::client::wp_cursor_shape_device_v1::WpCursorShapeDeviceV1;
+use pointer::cursor_shape::CursorShapeManager;
+use pointer::{PointerData, PointerDataExt, PointerHandler, ThemeSpec, ThemedPointer, Themes};
+use touch::{TouchData, TouchDataExt, TouchHandler};
 
 #[non_exhaustive]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -64,6 +65,8 @@ pub enum SeatError {
 pub struct SeatState {
     // (name, seat)
     seats: Vec<SeatInner>,
+    // Shape manager for the cursor icons.
+    cursor_shape_manager: Option<CursorShapeManager>,
 }
 
 impl SeatState {
@@ -82,7 +85,7 @@ impl SeatState {
             .expect("failed to bind global")
         });
 
-        let mut state = SeatState { seats: vec![] };
+        let mut state = SeatState { seats: vec![], cursor_shape_manager: None };
         for seat in seats {
             let data = seat.data::<SeatData>().unwrap().clone();
 
@@ -91,11 +94,26 @@ impl SeatState {
         state
     }
 
+    /// Provide the [`CursorShapeManager`] to automatically handle server side cursor
+    /// when using [`Self::get_pointer_with_theme`] and [`Self::get_pointer_with_theme_and_data`].
+    pub fn with_cursor_shape_manager(
+        mut self,
+        cursor_shape_manager: Option<CursorShapeManager>,
+    ) -> Self {
+        self.cursor_shape_manager = cursor_shape_manager;
+        self
+    }
+
     /// Returns an iterator over all the seats.
     pub fn seats(&self) -> impl Iterator<Item = wl_seat::WlSeat> {
         self.seats.iter().map(|inner| inner.seat.clone()).collect::<Vec<_>>().into_iter()
     }
 
+    /// Get the cursor shape manager passed in [`SeatState::with_cursor_shape_manager`].
+    pub fn cursor_shape_manager(&self) -> Option<&CursorShapeManager> {
+        self.cursor_shape_manager.as_ref()
+    }
+
     /// Returns information about a seat.
     ///
     /// This will return [`None`] if the seat is dead.
@@ -144,6 +162,7 @@ impl SeatState {
     where
         D: Dispatch<wl_pointer::WlPointer, PointerData>
             + Dispatch<wl_surface::WlSurface, S>
+            + Dispatch<WpCursorShapeDeviceV1, GlobalData>
             + PointerHandler
             + 'static,
         S: SurfaceDataExt + 'static,
@@ -200,6 +219,7 @@ impl SeatState {
     where
         D: Dispatch<wl_pointer::WlPointer, U>
             + Dispatch<wl_surface::WlSurface, S>
+            + Dispatch<WpCursorShapeDeviceV1, GlobalData>
             + PointerHandler
             + 'static,
         S: SurfaceDataExt + 'static,
@@ -213,11 +233,13 @@ impl SeatState {
         }
 
         let wl_ptr = seat.get_pointer(qh, pointer_data);
+        let shape_device = self.cursor_shape_manager().map(|csm| csm.get_shape_device(&wl_ptr, qh));
         Ok(ThemedPointer {
             themes: Arc::new(Mutex::new(Themes::new(theme))),
             pointer: wl_ptr,
             shm: shm.clone(),
             surface,
+            shape_device,
             _marker: std::marker::PhantomData,
             _surface_data: std::marker::PhantomData,
         })
diff --git a/src/seat/pointer/cursor_shape.rs b/src/seat/pointer/cursor_shape.rs
@@ -0,0 +1,114 @@
+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::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;
+use crate::reexports::protocols::wp::cursor_shape::v1::client::wp_cursor_shape_manager_v1::WpCursorShapeManagerV1;
+
+#[derive(Debug)]
+pub struct CursorShapeManager {
+    cursor_shape_manager: WpCursorShapeManagerV1,
+}
+
+impl CursorShapeManager {
+    pub fn bind<State>(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<State>,
+    ) -> Result<Self, BindError>
+    where
+        State: Dispatch<WpCursorShapeManagerV1, GlobalData> + 'static,
+    {
+        let cursor_shape_manager = globals.bind(queue_handle, 1..=1, GlobalData)?;
+        Ok(Self { cursor_shape_manager })
+    }
+
+    pub fn get_shape_device<State>(
+        &self,
+        pointer: &WlPointer,
+        queue_handle: &QueueHandle<State>,
+    ) -> WpCursorShapeDeviceV1
+    where
+        State: Dispatch<WpCursorShapeDeviceV1, GlobalData> + 'static,
+    {
+        self.cursor_shape_manager.get_pointer(pointer, queue_handle, GlobalData)
+    }
+
+    pub fn inner(&self) -> &WpCursorShapeManagerV1 {
+        &self.cursor_shape_manager
+    }
+}
+
+impl<State> Dispatch<WpCursorShapeManagerV1, GlobalData, State> for CursorShapeManager
+where
+    State: Dispatch<WpCursorShapeManagerV1, GlobalData>,
+{
+    fn event(
+        _: &mut State,
+        _: &WpCursorShapeManagerV1,
+        _: <WpCursorShapeManagerV1 as Proxy>::Event,
+        _: &GlobalData,
+        _: &Connection,
+        _: &QueueHandle<State>,
+    ) {
+        unreachable!("wl_cursor_shape_manager_v1 has no events")
+    }
+}
+
+impl<State> Dispatch<WpCursorShapeDeviceV1, GlobalData, State> for CursorShapeManager
+where
+    State: Dispatch<WpCursorShapeDeviceV1, GlobalData>,
+{
+    fn event(
+        _: &mut State,
+        _: &WpCursorShapeDeviceV1,
+        _: <WpCursorShapeDeviceV1 as Proxy>::Event,
+        _: &GlobalData,
+        _: &Connection,
+        _: &QueueHandle<State>,
+    ) {
+        unreachable!("wl_cursor_shape_device_v1 has no events")
+    }
+}
+
+pub(crate) fn cursor_icon_to_shape(cursor_icon: CursorIcon) -> Shape {
+    match cursor_icon {
+        CursorIcon::Default => Shape::Default,
+        CursorIcon::ContextMenu => Shape::ContextMenu,
+        CursorIcon::Help => Shape::Help,
+        CursorIcon::Pointer => Shape::Pointer,
+        CursorIcon::Progress => Shape::Progress,
+        CursorIcon::Wait => Shape::Wait,
+        CursorIcon::Cell => Shape::Cell,
+        CursorIcon::Crosshair => Shape::Crosshair,
+        CursorIcon::Text => Shape::Text,
+        CursorIcon::VerticalText => Shape::VerticalText,
+        CursorIcon::Alias => Shape::Alias,
+        CursorIcon::Copy => Shape::Copy,
+        CursorIcon::Move => Shape::Move,
+        CursorIcon::NoDrop => Shape::NoDrop,
+        CursorIcon::NotAllowed => Shape::NotAllowed,
+        CursorIcon::Grab => Shape::Grab,
+        CursorIcon::Grabbing => Shape::Grabbing,
+        CursorIcon::EResize => Shape::EResize,
+        CursorIcon::NResize => Shape::NResize,
+        CursorIcon::NeResize => Shape::NeResize,
+        CursorIcon::NwResize => Shape::NwResize,
+        CursorIcon::SResize => Shape::SResize,
+        CursorIcon::SeResize => Shape::SeResize,
+        CursorIcon::SwResize => Shape::SwResize,
+        CursorIcon::WResize => Shape::WResize,
+        CursorIcon::EwResize => Shape::EwResize,
+        CursorIcon::NsResize => Shape::NsResize,
+        CursorIcon::NeswResize => Shape::NeswResize,
+        CursorIcon::NwseResize => Shape::NwseResize,
+        CursorIcon::ColResize => Shape::ColResize,
+        CursorIcon::RowResize => Shape::RowResize,
+        CursorIcon::AllScroll => Shape::AllScroll,
+        CursorIcon::ZoomIn => Shape::ZoomIn,
+        CursorIcon::ZoomOut => Shape::ZoomOut,
+        _ => Shape::Default,
+    }
+}
diff --git a/src/seat/pointer/mod.rs b/src/seat/pointer/mod.rs
@@ -15,6 +15,7 @@ use wayland_client::{
     Connection, Dispatch, Proxy, QueueHandle, WEnum,
 };
 use wayland_cursor::{Cursor, CursorTheme};
+use wayland_protocols::wp::cursor_shape::v1::client::wp_cursor_shape_device_v1::WpCursorShapeDeviceV1;
 
 use crate::{
     compositor::{SurfaceData, SurfaceDataExt},
@@ -26,6 +27,10 @@ use super::SeatState;
 #[doc(inline)]
 pub use cursor_icon::{CursorIcon, ParseError as CursorIconParseError};
 
+pub mod cursor_shape;
+
+use cursor_shape::cursor_icon_to_shape;
+
 /* From linux/input-event-codes.h - the buttons usually used by mice */
 pub const BTN_LEFT: u32 = 0x110;
 pub const BTN_RIGHT: u32 = 0x111;
@@ -171,7 +176,17 @@ macro_rules! delegate_pointer {
                 $crate::reexports::client::protocol::wl_pointer::WlPointer: $crate::seat::pointer::PointerData
             ] => $crate::seat::SeatState
         );
-    };
+        $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty:
+            [
+                $crate::reexports::protocols::wp::cursor_shape::v1::client::wp_cursor_shape_manager_v1::WpCursorShapeManagerV1: $crate::globals::GlobalData
+            ] => $crate::seat::pointer::cursor_shape::CursorShapeManager
+        );
+        $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty:
+            [
+                $crate::reexports::protocols::wp::cursor_shape::v1::client::wp_cursor_shape_device_v1::WpCursorShapeDeviceV1: $crate::globals::GlobalData
+            ] => $crate::seat::pointer::cursor_shape::CursorShapeManager
+        );
+     };
     ($(@<$( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+>)? $ty: ty, pointer: [$($pointer_data:ty),* $(,)?]) => {
         $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty:
             [
@@ -180,6 +195,16 @@ macro_rules! delegate_pointer {
                 )*
             ] => $crate::seat::SeatState
         );
+        $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty:
+            [
+                $crate::reexports::protocols::wp::cursor_shape::v1::client::wp_cursor_shape_manager_v1::WpCursorShapeManagerV1: $crate::globals::GlobalData
+            ] => $crate::seat::pointer::cursor_shape::CursorShapeManager
+        );
+        $crate::reexports::client::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty:
+            [
+                $crate::reexports::protocols::wp::cursor_shape::v1::client::wp_cursor_shape_device_v1::WpCursorShapeDeviceV1: $crate::globals::GlobalData
+            ] => $crate::seat::pointer::cursor_shape::CursorShapeManager
+        );
     };
 }
 
@@ -401,6 +426,7 @@ pub struct ThemedPointer<U = PointerData, S = SurfaceData> {
     pub(super) shm: WlShm,
     /// The surface owned by the cursor to present the icon.
     pub(super) surface: WlSurface,
+    pub(super) shape_device: Option<WpCursorShapeDeviceV1>,
     pub(super) _marker: std::marker::PhantomData<U>,
     pub(super) _surface_data: std::marker::PhantomData<S>,
 }
@@ -410,6 +436,31 @@ impl<U: PointerDataExt + 'static, S: SurfaceDataExt + 'static> ThemedPointer<U,
     ///
     /// The cursor icon should be reloaded on every [`PointerEventKind::Enter`] event.
     pub fn set_cursor(&self, conn: &Connection, icon: CursorIcon) -> Result<(), PointerThemeError> {
+        let serial = match self
+            .pointer
+            .data::<U>()
+            .and_then(|data| data.pointer_data().latest_enter_serial())
+        {
+            Some(serial) => serial,
+            None => return Err(PointerThemeError::MissingEnterSerial),
+        };
+
+        if let Some(shape_device) = self.shape_device.as_ref() {
+            shape_device.set_shape(serial, cursor_icon_to_shape(icon));
+            Ok(())
+        } else {
+            self.set_cursor_legacy(conn, serial, icon)
+        }
+    }
+
+    /// The legacy method of loading the cursor from the system cursor
+    /// theme instead of relying on compositor to set the cursor.
+    fn set_cursor_legacy(
+        &self,
+        conn: &Connection,
+        serial: u32,
+        icon: CursorIcon,
+    ) -> Result<(), PointerThemeError> {
         let mut themes = self.themes.lock().unwrap();
 
         let scale = self.surface.data::<S>().unwrap().surface_data().scale_factor();
@@ -436,18 +487,8 @@ impl<U: PointerDataExt + 'static, S: SurfaceDataExt + 'static> ThemedPointer<U,
         self.surface.commit();
 
         // Set the pointer surface to change the pointer.
-        let data = self.pointer.data::<U>();
-        if let Some(serial) = data.and_then(|data| data.pointer_data().latest_enter_serial()) {
-            self.pointer.set_cursor(
-                serial,
-                Some(&self.surface),
-                hx as i32 / scale,
-                hy as i32 / scale,
-            );
-            Ok(())
-        } else {
-            Err(PointerThemeError::MissingEnterSerial)
-        }
+        self.pointer.set_cursor(serial, Some(&self.surface), hx as i32 / scale, hy as i32 / scale);
+        Ok(())
     }
 
     /// Hide the cursor by providing empty surface for it.
@@ -476,6 +517,10 @@ impl<U: PointerDataExt + 'static, S: SurfaceDataExt + 'static> ThemedPointer<U,
 
 impl<U, S> Drop for ThemedPointer<U, S> {
     fn drop(&mut self) {
+        if let Some(shape_device) = self.shape_device.take() {
+            shape_device.destroy();
+        }
+
         if self.pointer.version() >= 3 {
             self.pointer.release();
         }
