monolith

public

Star0

Fork 0

Watch0

316 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `96942b9aee39`

tarball

atagen <boss@atagen.co>2026-10-19 10:59 UTC

1 file changed+23-53

cursor: keep only the chosen theme image per shape and size

Cursor held every size and frame of the 17 preloaded shapes, a few MB resident, and cached a failed upload for the life of the process. A shape is now read from the theme when first drawn at a scale and only the image it picked stays. A missing theme file is remembered, an upload failure is retried.

Modified file: crates/monolith/src/cursor.rs+23 additions−53 deletions@@ -16,7 +16,7 @@ use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::utils::user_data::UserDataMap;
 use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Transform};
 use smithay::wayland::compositor::with_states;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::sync::Mutex;
 
 /// A theme shape sized for one output scale.
@@ -30,10 +30,10 @@ struct Prepared {
 pub struct Cursor {
     theme: xcursor::CursorTheme,
     size: u32,
-    /// Every image of the shapes read so far, including ones the theme lacks.
-    files: HashMap<CursorIcon, Option<Vec<xcursor::parser::Image>>>,
     /// Shapes sized for an output scale, in steps of 1/120.
-    sized: HashMap<(CursorIcon, u32), Option<Prepared>>,
+    sized: HashMap<(CursorIcon, u32), Prepared>,
+    /// Shapes the theme has no file for, which a retry would not change.
+    absent: HashSet<CursorIcon>,
 }
 
 impl Cursor {
@@ -43,55 +43,29 @@ impl Cursor {
             .ok()
             .and_then(|s| s.parse().ok())
             .unwrap_or(24u32);
-        let mut cursor = Self {
+        let cursor = Self {
             theme: xcursor::CursorTheme::load(&theme),
             size,
-            files: HashMap::new(),
             sized: HashMap::new(),
+            absent: HashSet::new(),
         };
-        if cursor.file(CursorIcon::Default).is_none() {
+        if cursor.read(CursorIcon::Default).is_none() {
             tracing::warn!(theme, "no xcursor theme found, drawing a plain cursor");
         }
-        // Reading a shape from the theme takes milliseconds, which in a frame
-        // makes it miss, so the ones clients ask for most load up front.
-        for icon in [
-            CursorIcon::Text,
-            CursorIcon::Pointer,
-            CursorIcon::Grab,
-            CursorIcon::Grabbing,
-            CursorIcon::NotAllowed,
-            CursorIcon::Wait,
-            CursorIcon::Progress,
-            CursorIcon::EwResize,
-            CursorIcon::NsResize,
-            CursorIcon::NResize,
-            CursorIcon::SResize,
-            CursorIcon::EResize,
-            CursorIcon::WResize,
-            CursorIcon::NwResize,
-            CursorIcon::NeResize,
-            CursorIcon::SwResize,
-            CursorIcon::SeResize,
-        ] {
-            cursor.file(icon);
-        }
         cursor
     }
 
     /// The theme's images for `icon`, falling back to the default arrow.
-    fn file(&mut self, icon: CursorIcon) -> Option<&[xcursor::parser::Image]> {
-        if !self.files.contains_key(&icon) {
-            let names = std::iter::once(icon.name()).chain(icon.alt_names().iter().copied());
-            let images = names
-                .chain(["default", "left_ptr"])
-                .find_map(|n| load_file(&self.theme, n));
-            self.files.insert(icon, images);
-        }
-        self.files.get(&icon)?.as_deref()
+    fn read(&self, icon: CursorIcon) -> Option<Vec<xcursor::parser::Image>> {
+        let names = std::iter::once(icon.name()).chain(icon.alt_names().iter().copied());
+        names
+            .chain(["default", "left_ptr"])
+            .find_map(|n| load_file(&self.theme, n))
     }
 
     /// The theme's image nearest the cursor size times `scale`, stretched to
-    /// exactly that size so it covers whole pixels.
+    /// exactly that size so it covers whole pixels. Only that image is kept,
+    /// and an upload that fails is retried on the next call.
     fn sized(
         &mut self,
         renderer: &mut VulkanRenderer,
@@ -99,21 +73,17 @@ impl Cursor {
         scale: f64,
     ) -> Option<&Prepared> {
         let key = (icon, (scale * 120.0).round() as u32);
-        if !self.sized.contains_key(&key) {
+        if !self.sized.contains_key(&key) && !self.absent.contains(&icon) {
+            let Some(images) = self.read(icon) else {
+                self.absent.insert(icon);
+                return None;
+            };
             let wanted = ((f64::from(self.size) * scale).round() as u32).max(1);
-            let prepared = self
-                .file(icon)
-                .and_then(|images| images.iter().min_by_key(|i| i.size.abs_diff(wanted)))
-                .and_then(|image| {
-                    prepare(
-                        renderer,
-                        image,
-                        f64::from(wanted) / f64::from(image.size.max(1)),
-                    )
-                });
-            self.sized.insert(key, prepared);
+            let image = images.iter().min_by_key(|i| i.size.abs_diff(wanted))?;
+            let ratio = f64::from(wanted) / f64::from(image.size.max(1));
+            self.sized.insert(key, prepare(renderer, image, ratio)?);
         }
-        self.sized.get(&key)?.as_ref()
+        self.sized.get(&key)
     }
 
     /// Elements for the pointer at `pos`, in output-local coordinates.

monolith

Commit 96942b9aee39

Commit `96942b9aee39`