Add cursor_image_status/set_cursor_image_status to SeatExt

The `cursor_image_status()` function saves some duplication in various
places. The `set_cursor_image_status()` saves a bit less, but is also
handy.

src/backend/render/cursor.rs

@@ -20,8 +20,7 @@ use smithay::{
     reexports::wayland_server::protocol::wl_surface,
     render_elements,
     utils::{
-        Buffer as BufferCoords, IsAlive, Logical, Monotonic, Physical, Point, Scale, Size, Time,
+        Buffer as BufferCoords, Logical, Monotonic, Physical, Point, Scale, Size, Time, Transform,
-        Transform,
     },
     wayland::compositor::{get_role, with_states},
 };
@@ -266,20 +265,7 @@ where
     R::TextureId: Send + Clone + 'static,
 {
     // draw the cursor as relevant
-    // reset the cursor if the surface is no longer alive
+    let cursor_status = seat.cursor_image_status();
-    let cursor_status = seat
-        .user_data()
-        .get::<Mutex<CursorImageStatus>>()
-        .map(|lock| {
-            let mut cursor_status = lock.lock().unwrap();
-            if let CursorImageStatus::Surface(ref surface) = *cursor_status {
-                if !surface.alive() {
-                    *cursor_status = CursorImageStatus::default_named();
-                }
-            }
-            cursor_status.clone()
-        })
-        .unwrap_or(CursorImageStatus::default_named());
 
     let seat_userdata = seat.user_data();
     let mut state_ref = seat_userdata.get::<CursorState>().unwrap().lock().unwrap();

src/shell/element/stack.rs

@@ -1333,8 +1333,7 @@ impl PointerTarget<State> for CosmicStack {
                 .lock()
                 .unwrap();
             cursor_state.set_shape(next.cursor_shape());
-            let cursor_status = seat.user_data().get::<Mutex<CursorImageStatus>>().unwrap();
+            seat.set_cursor_image_status(CursorImageStatus::default_named());
-            *cursor_status.lock().unwrap() = CursorImageStatus::default_named();
         });
 
         event.location -= self.0.with_program(|p| {
@@ -1363,8 +1362,7 @@ impl PointerTarget<State> for CosmicStack {
                 .lock()
                 .unwrap();
             cursor_state.set_shape(next.cursor_shape());
-            let cursor_status = seat.user_data().get::<Mutex<CursorImageStatus>>().unwrap();
+            seat.set_cursor_image_status(CursorImageStatus::default_named());
-            *cursor_status.lock().unwrap() = CursorImageStatus::default_named();
         });
 
         let active_window_geo = self.0.with_program(|p| {

src/shell/element/window.rs

@@ -711,8 +711,7 @@ impl PointerTarget<State> for CosmicWindow {
 
                 let cursor_state = seat.user_data().get::<CursorState>().unwrap();
                 cursor_state.lock().unwrap().set_shape(next.cursor_shape());
-                let cursor_status = seat.user_data().get::<Mutex<CursorImageStatus>>().unwrap();
+                seat.set_cursor_image_status(CursorImageStatus::default_named());
-                *cursor_status.lock().unwrap() = CursorImageStatus::default_named();
             }
         });
 
@@ -736,8 +735,7 @@ impl PointerTarget<State> for CosmicWindow {
 
                 let cursor_state = seat.user_data().get::<CursorState>().unwrap();
                 cursor_state.lock().unwrap().set_shape(next.cursor_shape());
-                let cursor_status = seat.user_data().get::<Mutex<CursorImageStatus>>().unwrap();
+                seat.set_cursor_image_status(CursorImageStatus::default_named());
-                *cursor_status.lock().unwrap() = CursorImageStatus::default_named();
             }
         });
 

src/shell/mod.rs

@@ -1427,12 +1427,7 @@ impl Common {
             }
 
             let is_cursor_image = shell.seats.iter().any(|seat| {
-                seat.user_data()
+                    matches!(seat.cursor_image_status(), CursorImageStatus::Surface(ref cursor_surface) if cursor_surface == surface)
-                .get::<Mutex<CursorImageStatus>>()
-                .map(|guard| {
-                    matches!(*guard.lock().unwrap(), CursorImageStatus::Surface(ref cursor_surface) if cursor_surface == surface)
-                })
-                .unwrap_or(false)
             });
 
             if is_cursor_image {

src/shell/seats.rs

@@ -252,6 +252,8 @@ pub trait SeatExt {
         loc: impl Into<Point<f64, Buffer>>,
         time: Time<Monotonic>,
     ) -> Option<(Rectangle<i32, Buffer>, Point<i32, Buffer>)>;
+    fn cursor_image_status(&self) -> CursorImageStatus;
+    fn set_cursor_image_status(&self, status: CursorImageStatus);
 }
 
 impl SeatExt for Seat<State> {
@@ -337,21 +339,7 @@ impl SeatExt for Seat<State> {
     ) -> Option<(Rectangle<i32, Buffer>, Point<i32, Buffer>)> {
         let location = loc.into().to_i32_round();
 
-        let cursor_status = self
+        match self.cursor_image_status() {
-            .user_data()
-            .get::<Mutex<CursorImageStatus>>()
-            .map(|lock| {
-                let mut cursor_status = lock.lock().unwrap();
-                if let CursorImageStatus::Surface(ref surface) = *cursor_status {
-                    if !surface.alive() {
-                        *cursor_status = CursorImageStatus::default_named();
-                    }
-                }
-                cursor_status.clone()
-            })
-            .unwrap_or(CursorImageStatus::default_named());
-
-        match cursor_status {
             CursorImageStatus::Surface(surface) => {
                 let hotspot = with_states(&surface, |states| {
                     states
@@ -387,4 +375,25 @@ impl SeatExt for Seat<State> {
             CursorImageStatus::Hidden => None,
         }
     }
+
+    fn cursor_image_status(&self) -> CursorImageStatus {
+        self.user_data()
+            .get::<Mutex<CursorImageStatus>>()
+            // Reset the cursor if the surface is no longer alive
+            .map(|lock| {
+                let mut cursor_status = lock.lock().unwrap();
+                if let CursorImageStatus::Surface(ref surface) = *cursor_status {
+                    if !surface.alive() {
+                        *cursor_status = CursorImageStatus::default_named();
+                    }
+                }
+                cursor_status.clone()
+            })
+            .unwrap_or(CursorImageStatus::default_named())
+    }
+
+    fn set_cursor_image_status(&self, status: CursorImageStatus) {
+        let cursor_status = self.user_data().get::<Mutex<CursorImageStatus>>().unwrap();
+        *cursor_status.lock().unwrap() = status;
+    }
 }

src/state.rs

@@ -70,7 +70,7 @@ use smithay::{
             Client, DisplayHandle, Resource,
         },
     },
-    utils::{Clock, IsAlive, Monotonic, Point},
+    utils::{Clock, Monotonic, Point},
     wayland::{
         alpha_modifier::AlphaModifierState,
         compositor::{CompositorClientState, CompositorState, SurfaceData},
@@ -118,7 +118,7 @@ use std::{
     collections::HashSet,
     ffi::OsString,
     process::Child,
-    sync::{atomic::AtomicBool, Arc, Mutex, Once},
+    sync::{atomic::AtomicBool, Arc, Once},
     time::{Duration, Instant},
 };
 
@@ -729,19 +729,7 @@ impl Common {
             .iter()
             .filter(|seat| &seat.active_output() == output)
         {
-            let cursor_status = seat
+            let cursor_status = seat.cursor_image_status();
-                .user_data()
-                .get::<Mutex<CursorImageStatus>>()
-                .map(|lock| {
-                    let mut cursor_status = lock.lock().unwrap();
-                    if let CursorImageStatus::Surface(ref surface) = *cursor_status {
-                        if !surface.alive() {
-                            *cursor_status = CursorImageStatus::default_named();
-                        }
-                    }
-                    cursor_status.clone()
-                })
-                .unwrap_or(CursorImageStatus::default_named());
 
             // cursor ...
             if let CursorImageStatus::Surface(wl_surface) = cursor_status {
@@ -1021,19 +1009,7 @@ impl Common {
             .iter()
             .filter(|seat| &seat.active_output() == output)
         {
-            let cursor_status = seat
+            let cursor_status = seat.cursor_image_status();
-                .user_data()
-                .get::<Mutex<CursorImageStatus>>()
-                .map(|lock| {
-                    let mut cursor_status = lock.lock().unwrap();
-                    if let CursorImageStatus::Surface(ref surface) = *cursor_status {
-                        if !surface.alive() {
-                            *cursor_status = CursorImageStatus::default_named();
-                        }
-                    }
-                    cursor_status.clone()
-                })
-                .unwrap_or(CursorImageStatus::default_named());
 
             if let CursorImageStatus::Surface(wl_surface) = cursor_status {
                 send_frames_surface_tree(

src/wayland/handlers/data_device.rs

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-only
 
-use crate::state::State;
+use crate::{state::State, utils::prelude::SeatExt};
 use smithay::{
     delegate_data_device,
     input::{
@@ -70,26 +70,20 @@ impl ClientDndGrabHandler for State {
         let user_data = seat.user_data();
         user_data.insert_if_missing_threadsafe::<Mutex<Option<DnDIcon>>, _>(|| Default::default());
 
-        let offset = seat
+        let offset = if let CursorImageStatus::Surface(ref surface) = seat.cursor_image_status() {
-            .user_data()
+            compositor::with_states(surface, |states| {
-            .get::<Mutex<CursorImageStatus>>()
+                let hotspot = states
-            .map(|guard| {
+                    .data_map
-                if let CursorImageStatus::Surface(ref surface) = *guard.lock().unwrap() {
+                    .get::<CursorImageSurfaceData>()
-                    compositor::with_states(surface, |states| {
+                    .unwrap()
-                        let hotspot = states
+                    .lock()
-                            .data_map
+                    .unwrap()
-                            .get::<CursorImageSurfaceData>()
+                    .hotspot;
-                            .unwrap()
+                Point::from((-hotspot.x, -hotspot.y))
-                            .lock()
-                            .unwrap()
-                            .hotspot;
-                        Point::from((-hotspot.x, -hotspot.y))
-                    })
-                } else {
-                    (0, 0).into()
-                }
             })
-            .unwrap_or_default();
+        } else {
+            (0, 0).into()
+        };
 
         *user_data
             .get::<Mutex<Option<DnDIcon>>>()

src/wayland/handlers/seat.rs

@@ -4,12 +4,12 @@ use crate::{
     shell::focus::target::{KeyboardFocusTarget, PointerFocusTarget},
     shell::Devices,
     state::State,
+    utils::prelude::SeatExt,
 };
 use smithay::{
     delegate_cursor_shape, delegate_seat,
     input::{keyboard::LedState, pointer::CursorImageStatus, SeatHandler, SeatState},
 };
-use std::sync::Mutex;
 
 impl SeatHandler for State {
     type KeyboardFocus = KeyboardFocusTarget;
@@ -20,17 +20,8 @@ impl SeatHandler for State {
         &mut self.common.seat_state
     }
 
-    fn cursor_image(
+    fn cursor_image(&mut self, seat: &smithay::input::Seat<Self>, image: CursorImageStatus) {
-        &mut self,
+        seat.set_cursor_image_status(image);
-        seat: &smithay::input::Seat<Self>,
-        image: smithay::input::pointer::CursorImageStatus,
-    ) {
-        *seat
-            .user_data()
-            .get::<Mutex<CursorImageStatus>>()
-            .unwrap()
-            .lock()
-            .unwrap() = image;
     }
 
     fn focus_changed(