Something went wrong. Try again.
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319use std::cell::RefCell;use std::collections::HashMap;use std::env;use std::fs::File;use std::io::Read;use std::rc::Rc;
use anyhow::{anyhow, Context};use smithay::backend::allocator::Fourcc;use smithay::backend::renderer::element::memory::MemoryRenderBuffer;use smithay::input::pointer::{CursorIcon, CursorImageStatus, CursorImageSurfaceData};use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;use smithay::utils::{IsAlive, Logical, Physical, Point, Transform};use smithay::wayland::compositor::with_states;use xcursor::parser::{parse_xcursor, Image};use xcursor::CursorTheme;
/// Some default looking `left_ptr` icon.static FALLBACK_CURSOR_DATA: &[u8] = include_bytes!("../resources/cursor.rgba");
type XCursorCache = HashMap<(CursorIcon, i32), Option<Rc<XCursor>>>;
pub struct CursorManager { theme: CursorTheme, size: u8, current_cursor: CursorImageStatus, named_cursor_cache: RefCell<XCursorCache>,}
impl CursorManager { pub fn new(theme: &str, size: u8) -> Self { Self::ensure_env(theme, size);
let theme = CursorTheme::load(theme);
Self { theme, size, current_cursor: CursorImageStatus::default_named(), named_cursor_cache: Default::default(), } }
/// Reload the cursor theme. pub fn reload(&mut self, theme: &str, size: u8) { Self::ensure_env(theme, size); self.theme = CursorTheme::load(theme); self.size = size; self.named_cursor_cache.get_mut().clear(); }
/// Checks if the cursor WlSurface is alive, and if not, cleans it up. pub fn check_cursor_image_surface_alive(&mut self) { if let CursorImageStatus::Surface(surface) = &self.current_cursor { if !surface.alive() { self.current_cursor = CursorImageStatus::default_named(); } } }
/// Get the current rendering cursor. pub fn get_render_cursor(&self, scale: i32) -> RenderCursor { match self.current_cursor.clone() { CursorImageStatus::Hidden => RenderCursor::Hidden, CursorImageStatus::Surface(surface) => { let hotspot = with_states(&surface, |states| { states .data_map .get::<CursorImageSurfaceData>() .unwrap() .lock() .unwrap() .hotspot });
RenderCursor::Surface { hotspot, surface } } CursorImageStatus::Named(icon) => self.get_render_cursor_named(icon, scale), } }
fn get_render_cursor_named(&self, icon: CursorIcon, scale: i32) -> RenderCursor { self.get_cursor_with_name(icon, scale) .map(|cursor| RenderCursor::Named { icon, scale, cursor, }) .unwrap_or_else(|| RenderCursor::Named { icon: Default::default(), scale, cursor: self.get_default_cursor(scale), }) }
pub fn is_current_cursor_animated(&self, scale: i32) -> bool { match &self.current_cursor { CursorImageStatus::Hidden => false, CursorImageStatus::Surface(_) => false, CursorImageStatus::Named(icon) => self .get_cursor_with_name(*icon, scale) .unwrap_or_else(|| self.get_default_cursor(scale)) .is_animated_cursor(), } }
/// Get named cursor for the given `icon` and `scale`. pub fn get_cursor_with_name(&self, icon: CursorIcon, scale: i32) -> Option<Rc<XCursor>> { self.named_cursor_cache .borrow_mut() .entry((icon, scale)) .or_insert_with_key(|(icon, scale)| { let size = self.size as i32 * scale; let mut cursor = Self::load_xcursor(&self.theme, icon.name(), size);
// Check alternative names to account for non-compliant themes. if cursor.is_err() { for name in icon.alt_names() { cursor = Self::load_xcursor(&self.theme, name, size); if cursor.is_ok() { break; } } }
if let Err(err) = &cursor { warn!("error loading xcursor {}@{size}: {err:?}", icon.name()); }
// The default cursor must always have a fallback. if *icon == CursorIcon::Default && cursor.is_err() { cursor = Ok(Self::fallback_cursor()); }
cursor.ok().map(Rc::new) }) .clone() }
/// Get default cursor. pub fn get_default_cursor(&self, scale: i32) -> Rc<XCursor> { // The default cursor always has a fallback. self.get_cursor_with_name(CursorIcon::Default, scale) .unwrap() }
/// Currently used cursor_image as a cursor provider. pub fn cursor_image(&self) -> &CursorImageStatus { &self.current_cursor }
/// Set new cursor image provider. pub fn set_cursor_image(&mut self, cursor: CursorImageStatus) { self.current_cursor = cursor; }
/// Load the cursor with the given `name` from the file system picking the closest /// one to the given `size`. fn load_xcursor(theme: &CursorTheme, name: &str, size: i32) -> anyhow::Result<XCursor> { let _span = tracy_client::span!("load_xcursor");
let path = theme .load_icon(name) .ok_or_else(|| anyhow!("no default icon"))?;
let mut file = File::open(path).context("error opening cursor icon file")?; let mut buf = vec![]; file.read_to_end(&mut buf) .context("error reading cursor icon file")?;
let mut images = parse_xcursor(&buf).context("error parsing cursor icon file")?;
let (width, height) = images .iter() .min_by_key(|image| (size - image.size as i32).abs()) .map(|image| (image.width, image.height)) .unwrap();
images.retain(move |image| image.width == width && image.height == height);
let animation_duration = images.iter().fold(0, |acc, image| acc + image.delay);
Ok(XCursor { images, animation_duration, }) }
/// Set the common XCURSOR env variables. fn ensure_env(theme: &str, size: u8) { env::set_var("XCURSOR_THEME", theme); env::set_var("XCURSOR_SIZE", size.to_string()); }
fn fallback_cursor() -> XCursor { let images = vec![Image { size: 32, width: 64, height: 64, xhot: 1, yhot: 1, delay: 0, pixels_rgba: Vec::from(FALLBACK_CURSOR_DATA), pixels_argb: vec![], }];
XCursor { images, animation_duration: 0, } }}
/// The cursor prepared for renderer.pub enum RenderCursor { Hidden, Surface { hotspot: Point<i32, Logical>, surface: WlSurface, }, Named { icon: CursorIcon, scale: i32, cursor: Rc<XCursor>, },}
type TextureCache = HashMap<(CursorIcon, i32), Vec<MemoryRenderBuffer>>;
#[derive(Default)]pub struct CursorTextureCache { cache: RefCell<TextureCache>,}
impl CursorTextureCache { pub fn clear(&mut self) { self.cache.get_mut().clear(); }
pub fn get( &self, icon: CursorIcon, scale: i32, cursor: &XCursor, idx: usize, ) -> MemoryRenderBuffer { self.cache .borrow_mut() .entry((icon, scale)) .or_insert_with(|| { cursor .frames() .iter() .map(|frame| { MemoryRenderBuffer::from_slice( &frame.pixels_rgba, Fourcc::Argb8888, (frame.width as i32, frame.height as i32), scale, Transform::Normal, None, ) }) .collect() })[idx] .clone() }}
// The XCursorBuffer implementation is inspired by `wayland-rs`, thus provided under MIT license.
/// The state of the `NamedCursor`.pub struct XCursor { /// The image for the underlying named cursor. images: Vec<Image>, /// The total duration of the animation. animation_duration: u32,}
impl XCursor { /// Given a time, calculate which frame to show, and how much time remains until the next frame. /// /// Time will wrap, so if for instance the cursor has an animation lasting 100ms, /// then calling this function with 5ms and 105ms as input gives the same output. pub fn frame(&self, mut millis: u32) -> (usize, &Image) { if self.animation_duration == 0 { return (0, &self.images[0]); }
millis %= self.animation_duration;
let mut res = 0; for (i, img) in self.images.iter().enumerate() { if millis < img.delay { res = i; break; } millis -= img.delay; }
(res, &self.images[res]) }
/// Get the frames for the given `XCursor`. pub fn frames(&self) -> &[Image] { &self.images }
/// Check whether the cursor is animated. pub fn is_animated_cursor(&self) -> bool { self.images.len() > 1 }
/// Get hotspot for the given `image`. pub fn hotspot(image: &Image) -> Point<i32, Physical> { (image.xhot as i32, image.yhot as i32).into() }}