aria/feresaria
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: render named cursor images

Browse Source
This commit is contained in:
Samuel Onoja committed 2026-09-25 00:53:48 +01:00
1 parent 37eb7cb9e9
commit df884cb623
8 files changed
+239 -31
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

compositor/src/cursor.rs
+146
View File
@@ -0,0 +1,146 @@
use std::{fs, sync::OnceLock};
use smithay::{
backend::{allocator::Fourcc, renderer::element::memory::MemoryRenderBuffer},
input::pointer::CursorIcon,
utils::{Buffer, Point, Size, Transform},
};
use xcursor::{CursorTheme, parser::Image};
const DEFAULT_CURSOR_SIZE: u32 = 24;
#[derive(Debug, Clone)]
pub(crate) struct NamedCursor {
pub buffer: MemoryRenderBuffer,
pub hotspot: Point<i32, Buffer>,
}
pub(crate) fn cursor_theme() -> CursorTheme {
let name = std::env::var("XCURSOR_THEME").unwrap_or_else(|_| "default".into());
CursorTheme::load(&name)
}
pub(crate) fn load_named_cursor(theme: &CursorTheme, icon: CursorIcon) -> NamedCursor {
let requested_size = cursor_size();
let image = cursor_names(icon)
.iter()
.find_map(|name| load_image(theme, name, requested_size));
match image {
Some(image) => cursor_from_image(image),
None => fallback_cursor(),
}
}
fn cursor_size() -> u32 {
static SIZE: OnceLock<u32> = OnceLock::new();
*SIZE.get_or_init(|| {
std::env::var("XCURSOR_SIZE")
.ok()
.and_then(|value| value.parse().ok())
.filter(|size| *size > 0)
.unwrap_or(DEFAULT_CURSOR_SIZE)
})
}
fn cursor_names(icon: CursorIcon) -> [&'static str; 3] {
match icon {
CursorIcon::Default => ["default", "left_ptr", "arrow"],
CursorIcon::Pointer => ["pointer", "hand2", "left_ptr"],
CursorIcon::Text => ["text", "xterm", "left_ptr"],
_ => [icon.name(), "default", "left_ptr"],
}
}
fn load_image(theme: &CursorTheme, name: &str, requested_size: u32) -> Option<Image> {
let path = theme.load_icon(name)?;
let bytes = fs::read(path).ok()?;
xcursor::parser::parse_xcursor(&bytes)?
.into_iter()
.min_by_key(|image| {
(
image.size.abs_diff(requested_size),
image.width.abs_diff(requested_size),
)
})
}
fn cursor_from_image(image: Image) -> NamedCursor {
let size = Size::<i32, Buffer>::from((image.width as i32, image.height as i32));
let buffer = MemoryRenderBuffer::from_slice(
&image.pixels_rgba,
Fourcc::Abgr8888,
size,
1,
Transform::Normal,
None,
);
NamedCursor {
buffer,
hotspot: Point::from((image.xhot as i32, image.yhot as i32)),
}
}
fn fallback_cursor() -> NamedCursor {
const WIDTH: usize = 12;
const HEIGHT: usize = 18;
let mut pixels = vec![0_u8; WIDTH * HEIGHT * 4];
for y in 0..HEIGHT {
let body_width = (y / 2 + 1).min(8);
for x in 0..body_width {
let edge = x == 0 || x + 1 == body_width || y == 0;
let offset = (y * WIDTH + x) * 4;
let color = if edge { 0 } else { 255 };
pixels[offset..offset + 4].copy_from_slice(&[color, color, color, 255]);
}
}
NamedCursor {
buffer: MemoryRenderBuffer::from_slice(
&pixels,
Fourcc::Abgr8888,
Size::<i32, Buffer>::from((WIDTH as i32, HEIGHT as i32)),
1,
Transform::Normal,
None,
),
hotspot: Point::default(),
}
}
#[cfg(test)]
mod tests {
use smithay::input::pointer::CursorIcon;
use super::cursor_names;
#[test]
fn supplies_legacy_fallback_names_for_common_cursors() {
assert_eq!(
cursor_names(CursorIcon::Default),
["default", "left_ptr", "arrow"]
);
assert_eq!(
cursor_names(CursorIcon::Pointer),
["pointer", "hand2", "left_ptr"]
);
assert_eq!(
cursor_names(CursorIcon::Text),
["text", "xterm", "left_ptr"]
);
}
#[test]
fn falls_back_to_default_for_other_named_cursors() {
assert_eq!(
cursor_names(CursorIcon::Crosshair),
["crosshair", "default", "left_ptr"]
);
}
}
compositor/src/handlers/mod.rs
+5
View File
@@ -45,6 +45,11 @@ impl SeatHandler for Ferese {
}
fn cursor_image(&mut self, _seat: &Seat<Self>, image: CursorImageStatus) {
if let CursorImageStatus::Named(icon) = &image {
self.named_cursors
.entry(*icon)
.or_insert_with(|| crate::cursor::load_named_cursor(&self.cursor_theme, *icon));
}
self.cursor_status = image;
crate::backends::direct::render_all(self);
}
compositor/src/main.rs
+1
View File
@@ -1,6 +1,7 @@
#![allow(irrefutable_let_patterns)]
mod backends;
mod cursor;
mod grabs;
mod handlers;
mod input;
compositor/src/state.rs
+11 -1
View File
@@ -16,7 +16,10 @@ use smithay::{
LayerSurface, PopupManager, Space, Window, WindowSurfaceType, layer_map_for_output,
utils::send_frames_surface_tree,
},
input::{Seat, SeatState, pointer::CursorImageStatus},
input::{
Seat, SeatState,
pointer::{CursorIcon, CursorImageStatus},
},
output::Output,
reexports::{
calloop::{EventLoop, Interest, LoopSignal, Mode, PostAction, generic::Generic},
@@ -62,6 +65,8 @@ pub struct Ferese {
pub window_geometry: HashMap<WindowId, WindowGeometry>,
pub focused_window: Option<WindowId>,
pub cursor_status: CursorImageStatus,
pub(crate) cursor_theme: xcursor::CursorTheme,
pub(crate) named_cursors: HashMap<CursorIcon, crate::cursor::NamedCursor>,
pub intercepted_keys: HashSet<smithay::input::keyboard::Keycode>,
pub idle_inhibitors: HashMap<WlSurface, usize>,
pub direct_backend: Option<crate::backends::direct::DirectBackendState>,
@@ -122,6 +127,9 @@ impl Ferese {
let socket_name = Self::init_wayland_listener(display, event_loop)?;
let start_time = Instant::now();
let cursor_theme = crate::cursor::cursor_theme();
let default_cursor = crate::cursor::load_named_cursor(&cursor_theme, CursorIcon::Default);
let named_cursors = HashMap::from([(CursorIcon::Default, default_cursor)]);
Ok(Self {
start_time,
@@ -134,6 +142,8 @@ impl Ferese {
window_geometry: HashMap::new(),
focused_window: None,
cursor_status: CursorImageStatus::default_named(),
cursor_theme,
named_cursors,
intercepted_keys: HashSet::new(),
idle_inhibitors: HashMap::new(),
direct_backend: None,
compositor/src/winit.rs
+73 -30
View File
@@ -9,6 +9,8 @@ use smithay::{
damage::OutputDamageTracker,
element::{
AsRenderElements, Kind as RenderElementKind,
memory::MemoryRenderBufferRenderElement,
render_elements,
surface::{WaylandSurfaceRenderElement, render_elements_from_surface_tree},
utils::{
ConstrainAlign, ConstrainScaleBehavior, CropRenderElement, Relocate,
@@ -35,10 +37,20 @@ use smithay::{
use crate::Ferese;
pub(crate) type AnimatedWindowRenderElement = CropRenderElement<
type SurfaceRenderElement = CropRenderElement<
RelocateRenderElement<RescaleRenderElement<WaylandSurfaceRenderElement<GlesRenderer>>>,
>;
type MemoryRenderElement = CropRenderElement<
RelocateRenderElement<RescaleRenderElement<MemoryRenderBufferRenderElement<GlesRenderer>>>,
>;
render_elements! {
pub(crate) AnimatedWindowRenderElement<=GlesRenderer>;
Surface=SurfaceRenderElement,
Memory=MemoryRenderElement,
}
pub fn init(event_loop: &mut EventLoop<Ferese>, state: &mut Ferese) -> Result<(), Box<dyn Error>> {
let (mut backend, event_source) = winit::init()?;
let initial_scale = normalized_scale(backend.scale_factor());
@@ -281,7 +293,7 @@ fn layer_elements(
let element = RescaleRenderElement::from_element(element, origin, 1.0);
let element = RelocateRenderElement::from_element(element, origin, Relocate::Relative);
CropRenderElement::from_element(element, scale, output_crop)
CropRenderElement::from_element(element, scale, output_crop).map(Into::into)
})
.collect()
}
@@ -292,42 +304,73 @@ fn cursor_elements(
output_geometry: Rectangle<i32, Logical>,
scale: f64,
) -> Vec<AnimatedWindowRenderElement> {
let CursorImageStatus::Surface(surface) = &state.cursor_status else {
return Vec::new();
};
let Some(pointer) = state.seat.get_pointer() else {
return Vec::new();
};
let hotspot = with_states(surface, |states| {
states
.data_map
.get::<CursorImageSurfaceData>()
.map(|attributes| attributes.lock().unwrap().hotspot)
.unwrap_or_default()
});
let logical_location =
pointer.current_location() - output_geometry.loc.to_f64() - hotspot.to_f64();
let physical_location = logical_location.to_physical_precise_round(scale);
let output_crop =
Rectangle::<i32, Logical>::from_size(output_geometry.size).to_physical_precise_round(scale);
let origin = Point::<i32, Physical>::default();
let pointer_location = pointer.current_location() - output_geometry.loc.to_f64();
match &state.cursor_status {
CursorImageStatus::Surface(surface) => {
let hotspot = with_states(surface, |states| {
states
.data_map
.get::<CursorImageSurfaceData>()
.map(|attributes| attributes.lock().unwrap().hotspot)
.unwrap_or_default()
});
let physical_location =
(pointer_location - hotspot.to_f64()).to_physical_precise_round(scale);
render_elements_from_surface_tree::<GlesRenderer, WaylandSurfaceRenderElement<GlesRenderer>>(
renderer,
surface,
physical_location,
scale,
1.0,
RenderElementKind::Cursor,
)
.into_iter()
.filter_map(|element| {
let element = RescaleRenderElement::from_element(element, origin, 1.0);
let element = RelocateRenderElement::from_element(element, origin, Relocate::Relative);
render_elements_from_surface_tree::<
GlesRenderer,
WaylandSurfaceRenderElement<GlesRenderer>,
>(
renderer,
surface,
physical_location,
scale,
1.0,
RenderElementKind::Cursor,
)
.into_iter()
.filter_map(|element| {
let element = RescaleRenderElement::from_element(element, origin, 1.0);
let element =
RelocateRenderElement::from_element(element, origin, Relocate::Relative);
CropRenderElement::from_element(element, scale, output_crop)
})
.collect()
CropRenderElement::from_element(element, scale, output_crop).map(Into::into)
})
.collect()
}
CursorImageStatus::Named(icon) => {
let Some(cursor) = state.named_cursors.get(icon) else {
return Vec::new();
};
let hotspot = Point::<i32, Physical>::from((cursor.hotspot.x, cursor.hotspot.y));
let physical_location = pointer_location.to_physical_precise_round(scale) - hotspot;
let Ok(element) = MemoryRenderBufferRenderElement::from_buffer(
renderer,
physical_location.to_f64(),
&cursor.buffer,
None,
None,
None,
RenderElementKind::Cursor,
) else {
return Vec::new();
};
let element = RescaleRenderElement::from_element(element, origin, 1.0);
let element = RelocateRenderElement::from_element(element, origin, Relocate::Relative);
CropRenderElement::from_element(element, scale, output_crop)
.map(|element| vec![element.into()])
.unwrap_or_default()
}
CursorImageStatus::Hidden => Vec::new(),
}
}
fn normalized_scale(scale: f64) -> f64 {