use crate::async_engine::AsyncEngine;
use crate::env::HOME;
use crate::env::XCURSOR_PATH;
use crate::env::XCURSOR_SIZE;
use crate::env::XCURSOR_THEME;
use crate::fixed::Fixed;
use crate::format::ARGB8888;
use crate::gfx_api::GfxContext;
use crate::gfx_api::GfxError;
use crate::gfx_api::GfxTexture;
use crate::rect::Rect;
use crate::renderer::Renderer;
use crate::renderer::renderer_base::RenderTexture;
use crate::scale::Scale;
use crate::state::State;
use crate::time::Time;
use crate::tree::OutputNode;
use crate::utils::bhash::BHashMap;
use crate::utils::bhash::BHashSet;
use crate::utils::errorfmt::ErrorFmt;
use crate::utils::numcell::NumCell;
use crate::utils::smallmap::SmallMapMut;
use bstr::BStr;
use bstr::BString;
use bstr::ByteSlice;
use byteorder::LittleEndian;
use byteorder::ReadBytesExt;
use isnt::std_1::primitive::IsntSliceExt;
use num_derive::FromPrimitive;
use std::cell::Cell;
use std::fmt::Debug;
use std::fmt::Formatter;
use std::fs::File;
use std::io;
use std::io::BufRead;
use std::io::BufReader;
use std::io::Seek;
use std::io::SeekFrom;
use std::mem::MaybeUninit;
use std::rc::Rc;
use std::slice;
use std::str;
use std::sync::LazyLock;
use std::time::Duration;
use thiserror::Error;
const XCURSOR_MAGIC: u32 = 0x72756358;
const XCURSOR_IMAGE_TYPE: u32 = 0xfffd0002;
const XCURSOR_PATH_DEFAULT: &str =
"~/.icons:/usr/share/icons:/usr/share/pixmaps:/usr/X11R6/lib/X11/icons";
const HEADER_SIZE: u32 = 16;
pub static DEFAULT_CURSOR_SIZE: LazyLock<u32> = LazyLock::new(|| {
if let Some(size) = *XCURSOR_SIZE
&& let Ok(val) = size.parse()
{
return val;
}
24
});
pub trait Cursor {
fn render(&self, renderer: &mut Renderer<'_>, x: Fixed, y: Fixed);
fn render_hardware_cursor(&self, renderer: &mut Renderer<'_>);
fn extents_at_scale(&self, scale: Scale) -> Rect;
fn set_output(&self, output: &Rc<OutputNode>) {
let _ = output;
}
fn handle_set(self: Rc<Self>) {}
fn handle_unset(&self) {}
fn tick(&self) {}
fn needs_tick(&self) -> bool {
false
}
fn time_until_tick(&self) -> Duration {
Duration::new(0, 0)
}
fn set_visible(&self, visible: bool) {
let _ = visible;
}
fn damage_extents(&self) -> Rect {
self.extents_at_scale(Scale::default())
}
}
pub struct ServerCursors {
pub default: ServerCursorTemplate,
pub context_menu: ServerCursorTemplate,
pub help: ServerCursorTemplate,
pub pointer: ServerCursorTemplate,
pub progress: ServerCursorTemplate,
pub wait: ServerCursorTemplate,
pub cell: ServerCursorTemplate,
pub crosshair: ServerCursorTemplate,
pub text: ServerCursorTemplate,
pub vertical_text: ServerCursorTemplate,
pub alias: ServerCursorTemplate,
pub copy: ServerCursorTemplate,
pub r#move: ServerCursorTemplate,
pub no_drop: ServerCursorTemplate,
pub not_allowed: ServerCursorTemplate,
pub grab: ServerCursorTemplate,
pub grabbing: ServerCursorTemplate,
pub e_resize: ServerCursorTemplate,
pub n_resize: ServerCursorTemplate,
pub ne_resize: ServerCursorTemplate,
pub nw_resize: ServerCursorTemplate,
pub s_resize: ServerCursorTemplate,
pub se_resize: ServerCursorTemplate,
pub sw_resize: ServerCursorTemplate,
pub w_resize: ServerCursorTemplate,
pub ew_resize: ServerCursorTemplate,
pub ns_resize: ServerCursorTemplate,
pub nesw_resize: ServerCursorTemplate,
pub nwse_resize: ServerCursorTemplate,
pub col_resize: ServerCursorTemplate,
pub row_resize: ServerCursorTemplate,
pub all_scroll: ServerCursorTemplate,
pub zoom_in: ServerCursorTemplate,
pub zoom_out: ServerCursorTemplate,
pub dnd_ask: ServerCursorTemplate,
pub all_resize: ServerCursorTemplate,
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, FromPrimitive)]
pub enum KnownCursor {
Default,
ContextMenu,
Help,
Pointer,
Progress,
Wait,
Cell,
Crosshair,
Text,
VerticalText,
Alias,
Copy,
Move,
NoDrop,
NotAllowed,
Grab,
Grabbing,
EResize,
NResize,
NeResize,
NwResize,
SResize,
SeResize,
SwResize,
WResize,
EwResize,
NsResize,
NeswResize,
NwseResize,
ColResize,
RowResize,
AllScroll,
ZoomIn,
ZoomOut,
DndAsk,
AllResize,
}
impl ServerCursors {
pub fn load(ctx: &Rc<dyn GfxContext>, state: &State) -> Result<Option<Self>, CursorError> {
let paths = find_cursor_paths();
log::debug!("Trying to load cursors from paths {paths:?}");
let sizes = state.cursor_sizes.to_vec();
let scales = state.scales.to_vec();
if sizes.is_empty() || scales.is_empty() {
return Ok(None);
}
let theme = XCURSOR_THEME.map(|theme| BStr::new(theme.as_bytes()));
let load =
|names: &[&str]| ServerCursorTemplate::load(names, theme, &scales, &sizes, &paths, ctx);
Ok(Some(Self {
default: load(&["default", "left_ptr"])?,
context_menu: load(&["context-menu"])?,
help: load(&["help"])?,
pointer: load(&["pointer", "hand2", "hand1"])?,
progress: load(&["progress"])?,
wait: load(&["wait", "watch"])?,
cell: load(&["cell"])?,
crosshair: load(&["crosshair"])?,
text: load(&["text", "xterm"])?,
vertical_text: load(&["vertical-text"])?,
alias: load(&["alias"])?,
copy: load(&["copy"])?,
r#move: load(&["move"])?,
no_drop: load(&["no-drop"])?,
not_allowed: load(&["not-allowed"])?,
grab: load(&["grab"])?,
grabbing: load(&["grabbing"])?,
e_resize: load(&["e-resize", "right_side"])?,
w_resize: load(&["w-resize", "left_side"])?,
n_resize: load(&["n-resize", "top_side"])?,
s_resize: load(&["s-resize", "bottom_side"])?,
ns_resize: load(&["ns-resize", "v_double_arrow"])?,
ew_resize: load(&["ew-resize", "h_double_arrow"])?,
nw_resize: load(&["nw-resize", "top_left_corner"])?,
ne_resize: load(&["ne-resize", "top_right_corner"])?,
sw_resize: load(&["sw-resize", "bottom_left_corner"])?,
se_resize: load(&["se-resize", "bottom_right_corner"])?,
nesw_resize: load(&["nesw-resize"])?,
nwse_resize: load(&["nwse-resize"])?,
col_resize: load(&["col-resize"])?,
row_resize: load(&["row-resize"])?,
all_scroll: load(&["all-scroll", "grabbing"])?,
zoom_in: load(&["zoom-in"])?,
zoom_out: load(&["zoom-out"])?,
dnd_ask: load(&["dnd-ask", "dnd-copy", "copy"])?,
all_resize: load(&["all-resize", "move"])?,
}))
}
}
pub struct ServerCursorTemplate {
var: ServerCursorTemplateVariant,
pub xcursor: Vec<BHashMap<(Scale, u32), Rc<XCursorImage>>>,
}
enum ServerCursorTemplateVariant {
Static(Rc<CursorImage>),
Animated(Rc<Vec<CursorImage>>),
}
impl ServerCursorTemplate {
fn load(
names: &[&str],
theme: Option<&BStr>,
scales: &[Scale],
sizes: &[u32],
paths: &[BString],
ctx: &Rc<dyn GfxContext>,
) -> Result<Self, CursorError> {
match open_cursor(names, theme, scales, sizes, paths) {
Ok(cs) => {
if cs.images.len() == 1 {
let mut sizes = SmallMapMut::new();
for (k, c) in &cs.images[0] {
sizes.insert(
*k,
CursorImageScaled::from_bytes(
ctx, &c.pixels, c.width, c.height, c.xhot, c.yhot,
)?,
);
}
let cursor = CursorImage::from_sizes(0, sizes);
Ok(ServerCursorTemplate {
var: ServerCursorTemplateVariant::Static(Rc::new(cursor)),
xcursor: cs.images,
})
} else {
let mut images = vec![];
for image in &cs.images {
let mut sizes = SmallMapMut::new();
let mut delay_ms = 0;
for (k, c) in image {
delay_ms = c.delay;
sizes.insert(
*k,
CursorImageScaled::from_bytes(
ctx, &c.pixels, c.width, c.height, c.xhot, c.yhot,
)?,
);
}
let img = CursorImage::from_sizes(delay_ms as _, sizes);
images.push(img);
}
Ok(ServerCursorTemplate {
var: ServerCursorTemplateVariant::Animated(Rc::new(images)),
xcursor: cs.images,
})
}
}
Err(e) => {
log::warn!("Could not load cursor {:?}: {}", names, ErrorFmt(e));
let empty: [Cell<u8>; 4] = unsafe { MaybeUninit::zeroed().assume_init() };
let mut img_sizes = SmallMapMut::new();
for scale in scales {
for size in sizes {
img_sizes.insert(
(*scale, *size),
CursorImageScaled::from_bytes(ctx, &empty, 1, 1, 0, 0)?,
);
}
}
let cursor = CursorImage::from_sizes(0, img_sizes);
Ok(ServerCursorTemplate {
var: ServerCursorTemplateVariant::Static(Rc::new(cursor)),
xcursor: Default::default(),
})
}
}
}
pub fn instantiate(&self, state: &State, size: u32) -> Rc<dyn Cursor> {
match &self.var {
ServerCursorTemplateVariant::Static(s) => Rc::new(StaticCursor {
image: s.for_size(size),
}),
ServerCursorTemplateVariant::Animated(a) => {
let images: Vec<_> = a.iter().map(|c| c.for_size(size)).collect();
let mut damage_extents = Rect::default();
for image in &images {
if damage_extents.is_empty() {
damage_extents = image.damage_extents;
} else {
damage_extents = damage_extents.union(image.damage_extents);
}
}
Rc::new(AnimatedCursor {
start: state.now(),
eng: state.eng.clone(),
next: NumCell::new(a[0].delay_ns),
idx: Cell::new(0),
images,
damage_extents,
})
}
}
}
}
struct CursorImageScaled {
extents: Rect,
tex: Rc<dyn GfxTexture>,
}
struct CursorImage {
delay_ns: u64,
sizes: SmallMapMut<(Scale, u32), Rc<CursorImageScaled>, 2>,
}
struct InstantiatedCursorImage {
delay_ns: u64,
scales: SmallMapMut<Scale, Rc<CursorImageScaled>, 2>,
damage_extents: Rect,
}
impl CursorImageScaled {
fn from_bytes(
ctx: &Rc<dyn GfxContext>,
data: &[Cell<u8>],
width: i32,
height: i32,
xhot: i32,
yhot: i32,
) -> Result<Rc<Self>, CursorError> {
Ok(Rc::new(Self {
extents: Rect::new_sized_saturating(-xhot, -yhot, width, height),
tex: ctx
.clone()
.shmem_texture(None, data, ARGB8888, width, height, width * 4, None)?,
}))
}
}
impl CursorImage {
fn from_sizes(
delay_ms: u64,
sizes: SmallMapMut<(Scale, u32), Rc<CursorImageScaled>, 2>,
) -> Self {
Self {
delay_ns: delay_ms.max(1) * 1_000_000,
sizes,
}
}
fn for_size(&self, size: u32) -> InstantiatedCursorImage {
let mut sizes = SmallMapMut::new();
let mut damage_extents = Rect::default();
for ((scale, isize), v) in &self.sizes {
if *isize == size {
sizes.insert(*scale, v.clone());
let normal_extents = if *scale == 1 {
v.extents
} else {
let scalef = scale.to_f64();
Rect::new_saturating(
(v.extents.x1() as f64 / scalef).floor() as i32,
(v.extents.y1() as f64 / scalef).floor() as i32,
(v.extents.x2() as f64 / scalef).ceil() as i32,
(v.extents.y2() as f64 / scalef).ceil() as i32,
)
};
if damage_extents.is_empty() {
damage_extents = normal_extents;
} else {
damage_extents = damage_extents.union(normal_extents);
}
}
}
InstantiatedCursorImage {
delay_ns: self.delay_ns,
scales: sizes,
damage_extents,
}
}
}
struct StaticCursor {
image: InstantiatedCursorImage,
}
fn render_img(image: &InstantiatedCursorImage, renderer: &mut Renderer<'_>, x: Fixed, y: Fixed) {
let scale = renderer.scale();
let Some(img) = image.scales.get(&scale) else {
return;
};
let extents = if scale == 1 {
img.extents.move_(x.round_down(), y.round_down())
} else {
let scalef = scale.to_f64();
let x = (x.to_f64() * scalef).round() as i32;
let y = (y.to_f64() * scalef).round() as i32;
img.extents.move_(x, y)
};
if extents.intersects(&renderer.pixel_extents()) {
renderer.base.render_texture(
&img.tex,
extents.x1(),
extents.y1(),
RenderTexture::default(),
);
}
}
impl Cursor for StaticCursor {
fn render(&self, renderer: &mut Renderer<'_>, x: Fixed, y: Fixed) {
render_img(&self.image, renderer, x, y);
}
fn render_hardware_cursor(&self, renderer: &mut Renderer<'_>) {
if let Some(img) = self.image.scales.get(&renderer.scale()) {
renderer
.base
.render_texture(&img.tex, 0, 0, RenderTexture::default());
}
}
fn extents_at_scale(&self, scale: Scale) -> Rect {
match self.image.scales.get(&scale) {
None => Rect::new_empty(0, 0),
Some(i) => i.extents,
}
}
fn damage_extents(&self) -> Rect {
self.image.damage_extents
}
}
struct AnimatedCursor {
start: Time,
eng: Rc<AsyncEngine>,
next: NumCell<u64>,
idx: Cell<usize>,
images: Vec<InstantiatedCursorImage>,
damage_extents: Rect,
}
impl Cursor for AnimatedCursor {
fn render(&self, renderer: &mut Renderer<'_>, x: Fixed, y: Fixed) {
let img = &self.images[self.idx.get()];
render_img(img, renderer, x, y);
}
fn render_hardware_cursor(&self, renderer: &mut Renderer<'_>) {
let img = &self.images[self.idx.get()];
if let Some(img) = img.scales.get(&renderer.scale()) {
renderer
.base
.render_texture(&img.tex, 0, 0, RenderTexture::default());
}
}
fn extents_at_scale(&self, scale: Scale) -> Rect {
let img = &self.images[self.idx.get()];
match img.scales.get(&scale) {
None => Rect::new_empty(0, 0),
Some(i) => i.extents,
}
}
fn tick(&self) {
let dist = self.eng.now() - self.start;
if (dist.as_nanos() as u64) < self.next.get() {
return;
}
let idx = (self.idx.get() + 1) % self.images.len();
self.idx.set(idx);
let image = &self.images[idx];
self.next.fetch_add(image.delay_ns);
}
fn needs_tick(&self) -> bool {
true
}
fn time_until_tick(&self) -> Duration {
let dist = self.eng.now() - self.start;
let dist = dist.as_nanos() as u64;
let nanos = self.next.get().saturating_sub(dist);
Duration::from_nanos(nanos)
}
fn damage_extents(&self) -> Rect {
self.damage_extents
}
}
struct OpenCursorResult {
images: Vec<BHashMap<(Scale, u32), Rc<XCursorImage>>>,
}
fn open_cursor(
names: &[&str],
theme: Option<&BStr>,
scales: &[Scale],
sizes: &[u32],
paths: &[BString],
) -> Result<OpenCursorResult, CursorError> {
let mut file = None;
let mut pairs_tested = BHashSet::default();
if let Some(theme) = theme {
for name in names {
let name = name.as_bytes().as_bstr();
file = open_cursor_file(&mut pairs_tested, paths, theme, name);
if file.is_some() {
break;
}
}
}
if file.is_none() {
for name in names {
let name = name.as_bytes().as_bstr();
file = open_cursor_file(&mut pairs_tested, paths, b"default".as_bstr(), name);
if file.is_some() {
break;
}
}
}
let Some(file) = file else {
return Err(CursorError::NotFound);
};
let mut file = BufReader::new(file);
parser_cursor_file(&mut file, scales, sizes)
}
fn open_cursor_file<'a>(
pairs_tested: &mut BHashSet<(BString, &'a BStr)>,
paths: &[BString],
theme: &BStr,
name: &'a BStr,
) -> Option<File> {
if !pairs_tested.insert((theme.to_owned(), name)) {
return None;
}
if paths.is_empty() {
return None;
}
let mut parents = None;
for cursor_path in paths {
let mut theme_dir = cursor_path.to_vec();
theme_dir.push(b'/');
theme_dir.extend_from_slice(theme.as_bytes());
let mut cursor_file = theme_dir.clone();
cursor_file.extend_from_slice(b"/cursors/");
cursor_file.extend_from_slice(name.as_bytes());
if let Ok(f) = File::open(cursor_file.to_os_str().unwrap()) {
return Some(f);
}
if parents.is_none() {
let mut index_file = theme_dir.clone();
index_file.extend_from_slice(b"/index.theme");
parents = find_parent_themes(&index_file);
}
}
if let Some(parents) = parents {
for parent in parents {
if let Some(file) = open_cursor_file(pairs_tested, paths, parent.as_bstr(), name) {
return Some(file);
}
}
}
None
}
fn find_cursor_paths() -> Vec<BString> {
let home = *HOME;
let cursor_paths = XCURSOR_PATH.unwrap_or(XCURSOR_PATH_DEFAULT).as_bytes();
let mut paths = vec![];
for path in <[u8]>::split(cursor_paths, |b| *b == b':') {
if path.first() == Some(&b'~') {
if let Some(home) = home {
let mut full_path = home.as_bytes().to_vec();
full_path.extend_from_slice(&path[1..]);
paths.push(full_path.into());
} else {
log::warn!(
"`HOME` is not set. Cannot expand {}. Ignoring.",
path.as_bstr()
);
}
} else {
paths.push(path.as_bstr().to_owned());
}
}
paths
}
fn find_parent_themes(path: &[u8]) -> Option<Vec<BString>> {
let Ok(file) = File::open(path.to_os_str().unwrap()) else {
return None;
};
let mut buf_reader = BufReader::new(file);
let mut buf = vec![];
loop {
buf.clear();
match buf_reader.read_until(b'\n', &mut buf) {
Ok(n) if n > 0 => {}
_ => return None,
}
let Some(mut suffix) = buf.strip_prefix(b"Inherits") else {
continue;
};
while suffix.first() == Some(&b' ') {
suffix = &suffix[1..];
}
if suffix.first() != Some(&b'=') {
continue;
}
suffix = &suffix[1..];
let parents = suffix
.split(|b| matches!(*b, b' ' | b'\t' | b'\n' | b';' | b','))
.filter(|v| v.is_not_empty())
.map(|v| v.as_bstr().to_owned())
.collect();
return Some(parents);
}
}
#[derive(Debug, Error)]
pub enum CursorError {
#[error("An IO error occurred: {0}")]
Io(#[from] io::Error),
#[error("The file is not an Xcursor file")]
NotAnXcursorFile,
#[error("The Xcursor file contains more than 0x10000 images")]
OversizedXcursorFile,
#[error("The Xcursor file is empty")]
EmptyXcursorFile,
#[error("The Xcursor file is corrupt")]
CorruptXcursorFile,
#[error("The requested cursor could not be found")]
NotFound,
#[error("Could not import the cursor as a texture")]
ImportError(#[from] GfxError),
}
#[derive(Default, Clone)]
pub struct XCursorImage {
pub width: i32,
pub height: i32,
pub xhot: i32,
pub yhot: i32,
delay: u32,
pub pixels: Vec<Cell<u8>>,
}
impl Debug for XCursorImage {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
f.debug_struct("XcbCursorImage")
.field("width", &self.width)
.field("height", &self.height)
.field("xhot", &self.xhot)
.field("yhot", &self.yhot)
.field("delay", &self.delay)
.finish_non_exhaustive()
}
}
fn parser_cursor_file<R: BufRead + Seek>(
r: &mut R,
scales: &[Scale],
sizes: &[u32],
) -> Result<OpenCursorResult, CursorError> {
let [magic, header] = read_u32_n(r)?;
if magic != XCURSOR_MAGIC || header < HEADER_SIZE {
return Err(CursorError::NotAnXcursorFile);
}
let [_version, ntoc] = read_u32_n(r)?;
r.seek(SeekFrom::Current((HEADER_SIZE - header) as i64))?;
if ntoc > 0x10000 {
return Err(CursorError::OversizedXcursorFile);
}
struct Target {
positions: Vec<u32>,
effective_size: u32,
size: u32,
scale: Scale,
best_fit: i64,
best_fit_size: u32,
}
let mut targets = Vec::new();
for scale in scales {
let scalef = scale.to_f64();
for size in sizes {
let effective_size = (*size as f64 * scalef).round() as _;
targets.push(Target {
positions: vec![],
effective_size,
size: *size,
scale: *scale,
best_fit: i64::MAX,
best_fit_size: 0,
});
}
}
let mut sizes = BHashSet::default();
for _ in 0..ntoc {
let [type_, size, position] = read_u32_n(r)?;
if type_ != XCURSOR_IMAGE_TYPE {
continue;
}
sizes.insert(size);
for target in &mut targets {
let fit = (size as i64 - target.effective_size as i64).abs();
if fit < target.best_fit {
target.best_fit = fit;
target.best_fit_size = size;
target.positions.clear();
}
if size == target.best_fit_size {
target.positions.push(position);
}
}
}
let positions: BHashSet<_> = targets
.iter()
.flat_map(|t| t.positions.iter().copied())
.collect();
if positions.is_empty() {
return Err(CursorError::EmptyXcursorFile);
}
let mut images = BHashMap::default();
for position in positions {
r.seek(SeekFrom::Start(position as u64))?;
let [
_chunk_header,
_type_,
_size,
_version,
width,
height,
xhot,
yhot,
delay,
] = read_u32_n(r)?;
let [width, height, xhot, yhot] = u32_to_i32([width, height, xhot, yhot])?;
let mut image = XCursorImage {
width,
height,
xhot,
yhot,
delay,
pixels: vec![],
};
let num_bytes = width as usize * height as usize * 4;
unsafe {
image.pixels.reserve_exact(num_bytes);
image.pixels.set_len(num_bytes);
r.read_exact(slice::from_raw_parts_mut(
image.pixels.as_mut_ptr() as _,
num_bytes,
))?;
}
images.insert(position, Rc::new(image));
}
let mut num = targets[0].positions.len();
if num > 1 && targets.iter().any(|t| t.positions.len() != num) {
log::warn!(
"Cursor file contains animated cursor but not all scales have the same number of images"
);
num = 1;
}
let mut res = vec![];
for i in 0..num {
let mut idx_images = BHashMap::default();
for target in &targets {
let image = images.get(&target.positions[i]).unwrap();
idx_images.insert((target.scale, target.size), image.clone());
}
res.push(idx_images);
}
Ok(OpenCursorResult { images: res })
}
fn read_u32_n<R: BufRead, const N: usize>(r: &mut R) -> Result<[u32; N], io::Error> {
let mut res = [0; N];
r.read_u32_into::<LittleEndian>(&mut res)?;
Ok(res)
}
fn u32_to_i32<const N: usize>(n: [u32; N]) -> Result<[i32; N], CursorError> {
let mut res = [0; N];
for i in 0..N {
res[i] = n[i]
.try_into()
.map_err(|_| CursorError::CorruptXcursorFile)?;
}
Ok(res)
}