computer-use-linux 0.7.21

//! `computer-use-linux-indicator`: a click-through overlay that shows when an
//! agent drives the desktop through computer-use-linux.
//!
//! The MCP server sends one JSON datagram per action (see
//! `computer_use_linux::indicator`). While actions arrive this draws, on
//! `wlr-layer-shell` overlay surfaces:
//!
//! - a software cursor that glides along an arc to each target and ripples on
//!   click (moving it only changes surface margins, nothing is redrawn);
//! - keycaps or a typing line next to the cursor for keyboard input;
//! - a glow along every screen edge and a status pill.
//!
//! Surfaces exist only while the agent is active and fade out after a few idle
//! seconds. The process exits after ten idle minutes; the server restarts it
//! on demand.

mod draw;
mod font;
mod gnome;

use std::{
    collections::hash_map::DefaultHasher,
    f32::consts::PI,
    fs::{File, OpenOptions, TryLockError},
    hash::{Hash, Hasher},
    os::unix::net::UnixDatagram,
    process::ExitCode,
    sync::{Arc, OnceLock},
    time::{Duration, Instant},
};

use computer_use_linux::indicator::{
    capture_lock_path, socket_path, Capture, IndicatorEvent, CAPTURE_REPLY_EMPTY,
    CAPTURE_REPLY_SHOWN, GLIDE, HIDE_SETTLE,
};
use smithay_client_toolkit::{
    compositor::{CompositorHandler, CompositorState, Region},
    delegate_registry,
    dispatch2::Dispatch2,
    output::{OutputHandler, OutputState},
    reexports::{
        calloop::{
            generic::Generic,
            timer::{TimeoutAction, Timer},
            EventLoop, Interest, LoopHandle, Mode, PostAction,
        },
        calloop_wayland_source::WaylandSource,
    },
    registry::{ProvidesRegistryState, RegistryState},
    registry_handlers,
    shell::{
        wlr_layer::{
            Anchor, KeyboardInteractivity, Layer, LayerShell, LayerShellHandler, LayerSurface,
            LayerSurfaceConfigure,
        },
        WaylandSurface,
    },
    shm::{slot::SlotPool, Shm, ShmHandler},
};
use tiny_skia::{Color, Pixmap};
use wayland_client::{
    globals::registry_queue_init,
    protocol::{wl_output::WlOutput, wl_shm, wl_surface::WlSurface},
    Connection, QueueHandle,
};
use wayland_protocols::wp::{
    fractional_scale::v1::client::{
        wp_fractional_scale_manager_v1::WpFractionalScaleManagerV1,
        wp_fractional_scale_v1::{self, WpFractionalScaleV1},
    },
    viewporter::client::{wp_viewport::WpViewport, wp_viewporter::WpViewporter},
};

use draw::{Edge, CURSOR_SIZE};

/// Idle time before fading out.
const IDLE_BEFORE_FADE: Duration = Duration::from_secs(8);
const FADE_IN: f32 = 0.2;
const FADE_OUT: f32 = 0.35;
const PULSE: f32 = 0.45;
/// Sway and breathing stop this long after an action, so a resting overlay
/// stops redrawing.
const SETTLE: f32 = 2.0;
const KEYS_SHOWN: f32 = 2.2;
const EXIT_AFTER_IDLE: Duration = Duration::from_secs(600);
const EDGE: u32 = 26;
const PILL_SIZE: (u32, u32) = (560, 56);
const PILL_TOP: i32 = 34;
const BUBBLE_SIZE: (u32, u32) = (460, 48);
const FRAME: Duration = Duration::from_millis(16);
const RESTING_FRAME: Duration = Duration::from_millis(250);
/// How often to look for the end of a capture that holds the overlay back.
const HOLD_POLL: Duration = Duration::from_millis(40);

fn agent_color(agent: &str) -> Color {
    let rgb = match agent.to_ascii_lowercase().as_str() {
        "claude" => (0xE0, 0x8A, 0x67),
        "codex" => (0x4C, 0x9D, 0xFF),
        "opencode" => (0x8B, 0xD4, 0x7E),
        "gemini" | "antigravity" => (0x8A, 0xB4, 0xF8),
        "hermes" => (0xF2, 0xC1, 0x4E),
        "pi" => (0xC0, 0x8A, 0xF0),
        _ => (0x9B, 0x8C, 0xFF),
    };
    Color::from_rgba8(rgb.0, rgb.1, rgb.2, 255)
}

fn tool_label(tool: &str) -> &str {
    match tool {
        "click" => "click",
        "drag" => "drag",
        "scroll" => "scroll",
        "type_text" => "typing",
        "press_key" => "key press",
        "set_value" => "entering a value",
        "perform_action" => "action",
        "activate_window" => "switching window",
        "move_window" => "moving window",
        "resize_window" => "resizing window",
        "screenshot" | "get_app_state" => "looking at the screen",
        other => other,
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
enum Kind {
    Cursor,
    Pill,
    Bubble,
    Edge(EdgeKind),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
enum EdgeKind {
    Top,
    Bottom,
    Left,
    Right,
}

impl EdgeKind {
    const ALL: [Self; 4] = [Self::Top, Self::Bottom, Self::Left, Self::Right];

    fn edge(self) -> Edge {
        match self {
            Self::Top => Edge::Top,
            Self::Bottom => Edge::Bottom,
            Self::Left => Edge::Left,
            Self::Right => Edge::Right,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq)]
struct Rect {
    x: f32,
    y: f32,
    w: f32,
    h: f32,
}

impl Rect {
    fn contains(&self, (x, y): (f32, f32)) -> bool {
        x >= self.x && x < self.x + self.w && y >= self.y && y < self.y + self.h
    }

    fn distance(&self, (x, y): (f32, f32)) -> f32 {
        let dx = (self.x - x).max(0.0).max(x - (self.x + self.w));
        let dy = (self.y - y).max(0.0).max(y - (self.y + self.h));
        dx.hypot(dy)
    }
}

struct Panel {
    kind: Kind,
    output: WlOutput,
    layer: LayerSurface,
    viewport: Option<WpViewport>,
    fractional: Option<WpFractionalScaleV1>,
    /// Logical size, as configured.
    size: (u32, u32),
    /// Buffer scale: fractional when the compositor reports one.
    scale: f32,
    configured: bool,
    margin: (i32, i32),
    /// Signature of the last drawn frame; redraw only when it changes.
    drawn: Option<u64>,
}

impl Drop for Panel {
    fn drop(&mut self) {
        if let Some(viewport) = self.viewport.take() {
            viewport.destroy();
        }
        if let Some(fractional) = self.fractional.take() {
            fractional.destroy();
        }
    }
}

struct Glide {
    from: (f32, f32),
    ctrl: (f32, f32),
    to: (f32, f32),
    start: Instant,
    duration: f32,
    press: bool,
}

impl Glide {
    fn new(from: (f32, f32), to: (f32, f32), press: bool) -> Self {
        let (dx, dy) = (to.0 - from.0, to.1 - from.1);
        let dist = dx.hypot(dy);
        // A gentle arc, like a hand moving a mouse, rather than a straight slide.
        let bend = 0.16 * dist;
        let (nx, ny) = if dist > 0.0 {
            (-dy / dist, dx / dist)
        } else {
            (0.0, 0.0)
        };
        Self {
            from,
            ctrl: (
                (from.0 + to.0) / 2.0 + nx * bend,
                (from.1 + to.1) / 2.0 + ny * bend,
            ),
            to,
            start: Instant::now(),
            // Never longer than the server waits before the real input.
            duration: (0.16 + dist / 4000.0).clamp(0.2, GLIDE.as_secs_f32() - 0.03),
            press,
        }
    }

    fn progress(&self) -> f32 {
        (self.start.elapsed().as_secs_f32() / self.duration).min(1.0)
    }

    fn position(&self) -> (f32, f32) {
        // Critically damped spring shape, normalised to land exactly at t = 1.
        let spring = |t: f32| 1.0 - (1.0 + 6.0 * t) * (-6.0 * t).exp();
        let e = spring(self.progress()) / spring(1.0);
        let u = 1.0 - e;
        let bezier = |a: f32, c: f32, b: f32| u * u * a + 2.0 * u * e * c + e * e * b;
        (
            bezier(self.from.0, self.ctrl.0, self.to.0),
            bezier(self.from.1, self.ctrl.1, self.to.1),
        )
    }
}

enum Keyboard {
    Keys(Vec<String>),
    Text(String),
}

struct App {
    registry: RegistryState,
    outputs: OutputState,
    compositor: CompositorState,
    layer_shell: LayerShell,
    shm: Shm,
    pool: SlotPool,
    viewporter: Option<WpViewporter>,
    fractional: Option<WpFractionalScaleManagerV1>,
    /// Loaded on a worker thread: scanning system fonts can take a second.
    fonts: Arc<OnceLock<font::Fonts>>,
    active: bool,
    handle: LoopHandle<'static, App>,
    qh: QueueHandle<App>,
    panels: Vec<Panel>,
    agent: String,
    tool: String,
    cursor: Option<(f32, f32)>,
    glide: Option<Glide>,
    pulse: Option<(Instant, (f32, f32))>,
    keyboard: Option<(Instant, Keyboard)>,
    last_action: Instant,
    shown_at: Instant,
    fading: Option<Instant>,
    /// When surfaces were last removed; the compositor may still show them.
    removed_at: Option<Instant>,
    /// Held shared by servers while they capture the screen.
    capture_lock: File,
    watching_hold: bool,
    sprite: Option<(u64, Pixmap)>,
    animating: bool,
    exit: bool,
}

impl App {
    fn output_rects(&self) -> Vec<(WlOutput, Rect)> {
        self.outputs
            .outputs()
            .filter_map(|output| {
                let info = self.outputs.info(&output)?;
                let (x, y) = info.logical_position?;
                let (w, h) = info.logical_size?;
                Some((
                    output,
                    Rect {
                        x: x as f32,
                        y: y as f32,
                        w: w as f32,
                        h: h as f32,
                    },
                ))
            })
            .collect()
    }

    /// Maps an event point to logical desktop coordinates. Points come in
    /// screenshot pixels with the capture size; the capture covers the
    /// bounding box of all outputs, like the server's absolute pointer.
    fn logical_point(&self, point: (i32, i32), space: Option<(u32, u32)>) -> (f32, f32) {
        let rects: Vec<Rect> = self
            .output_rects()
            .into_iter()
            .map(|(_, rect)| rect)
            .collect();
        spread(point, space, bounding_box(&rects))
    }

    fn output_for(&self, point: (f32, f32)) -> Option<(WlOutput, Rect)> {
        let rects = self.output_rects();
        rects
            .iter()
            .find(|(_, rect)| rect.contains(point))
            .or_else(|| {
                rects.iter().min_by(|a, b| {
                    a.1.distance(point)
                        .partial_cmp(&b.1.distance(point))
                        .unwrap_or(std::cmp::Ordering::Equal)
                })
            })
            .cloned()
    }

    fn rect_of(&self, output: &WlOutput) -> Option<Rect> {
        self.output_rects()
            .into_iter()
            .find(|(candidate, _)| candidate == output)
            .map(|(_, rect)| rect)
    }

    fn visible(&self) -> bool {
        self.active
    }

    /// Whether a capture taken now could contain the overlay: it is shown, or
    /// its surfaces were removed too recently for the compositor to drop them.
    fn on_screen(&self) -> bool {
        !self.panels.is_empty() || self.removed_at.is_some_and(|at| at.elapsed() < HIDE_SETTLE)
    }

    fn capture_held(&self) -> bool {
        lock_held(&self.capture_lock)
    }

    /// Takes every surface off the screen until no capture holds the overlay
    /// back. State keeps updating meanwhile, so it reappears up to date.
    fn suspend(&mut self) {
        if !self.panels.is_empty() {
            self.removed_at = Some(Instant::now());
        }
        self.panels.clear();
        if self.watching_hold {
            return;
        }
        self.watching_hold = true;
        let started = self
            .handle
            .insert_source(Timer::from_duration(HOLD_POLL), |_, _, app| {
                if app.capture_held() {
                    return TimeoutAction::ToDuration(HOLD_POLL);
                }
                app.watching_hold = false;
                let qh = app.qh();
                app.resume(&qh);
                TimeoutAction::Drop
            });
        if started.is_err() {
            self.watching_hold = false;
        }
    }

    fn resume(&mut self, qh: &QueueHandle<Self>) {
        if self.visible() {
            self.sync_panels(qh);
            self.render_all(qh);
            self.ensure_animation();
        }
    }

    fn cursor_position(&self) -> Option<(f32, f32)> {
        self.glide.as_ref().map(Glide::position).or(self.cursor)
    }

    fn settling(&self) -> bool {
        self.last_action.elapsed().as_secs_f32() < SETTLE + GLIDE.as_secs_f32()
    }

    fn busy(&self) -> bool {
        self.glide.is_some()
            || self.pulse.is_some()
            || self.fading.is_some()
            || self.settling()
            || self.shown_at.elapsed().as_secs_f32() < FADE_IN
            || self.keyboard.is_some()
    }

    /// 0..1 envelope: fade in on show, fade out after idling.
    fn opacity(&self) -> f32 {
        let fade_in = (self.shown_at.elapsed().as_secs_f32() / FADE_IN).min(1.0);
        let fade_out = self.fading.map_or(1.0, |at| {
            1.0 - (at.elapsed().as_secs_f32() / FADE_OUT).min(1.0)
        });
        fade_in * fade_out
    }

    fn on_event(&mut self, event: IndicatorEvent, qh: &QueueHandle<Self>) {
        self.agent = event.agent;
        self.tool = event.tool;
        self.last_action = Instant::now();
        self.fading = None;
        self.keyboard = if !event.keys.is_empty() {
            Some((Instant::now(), Keyboard::Keys(event.keys)))
        } else {
            event
                .text
                .map(|text| (Instant::now(), Keyboard::Text(text)))
        };
        if let (Some(x), Some(y)) = (event.x, event.y) {
            let to = self.logical_point((x, y), event.space);
            // First appearance glides in from a short distance away.
            let from = self
                .cursor_position()
                .unwrap_or((to.0 + 90.0, to.1 + 120.0));
            let press = matches!(self.tool.as_str(), "click" | "drag");
            self.glide = Some(Glide::new(from, to, press));
        }
        if !self.visible() {
            self.show(qh);
        }
        self.sync_panels(qh);
        self.render_all(qh);
        self.ensure_animation();
    }

    fn show(&mut self, _qh: &QueueHandle<Self>) {
        self.active = true;
        self.shown_at = Instant::now();
    }

    /// Gives every known output its four edge strips, including outputs that
    /// appear while the agent is active.
    fn ensure_edges(&mut self, qh: &QueueHandle<Self>) {
        for (output, _) in self.output_rects() {
            if self
                .panels
                .iter()
                .any(|panel| panel.output == output && matches!(panel.kind, Kind::Edge(_)))
            {
                continue;
            }
            for edge in EdgeKind::ALL {
                let (anchor, size) = match edge {
                    EdgeKind::Top => (Anchor::TOP | Anchor::LEFT | Anchor::RIGHT, (0, EDGE)),
                    EdgeKind::Bottom => (Anchor::BOTTOM | Anchor::LEFT | Anchor::RIGHT, (0, EDGE)),
                    EdgeKind::Left => (Anchor::LEFT | Anchor::TOP | Anchor::BOTTOM, (EDGE, 0)),
                    EdgeKind::Right => (Anchor::RIGHT | Anchor::TOP | Anchor::BOTTOM, (EDGE, 0)),
                };
                self.create_panel(qh, Kind::Edge(edge), &output, anchor, size, (0, 0));
            }
        }
    }

    fn hide(&mut self) {
        // A hidden cursor reappears where it was, like a resting hand.
        if let Some(glide) = self.glide.take() {
            self.cursor = Some(glide.to);
        }
        self.pulse = None;
        self.keyboard = None;
        self.fading = None;
        self.active = false;
        if !self.panels.is_empty() {
            self.removed_at = Some(Instant::now());
        }
        self.panels.clear();
    }

    fn create_panel(
        &mut self,
        qh: &QueueHandle<Self>,
        kind: Kind,
        output: &WlOutput,
        anchor: Anchor,
        size: (u32, u32),
        margin: (i32, i32),
    ) {
        let surface = self.compositor.create_surface(qh);
        // Click-through: an empty input region.
        if let Ok(region) = Region::new(&self.compositor) {
            surface.set_input_region(Some(region.wl_region()));
        }
        let layer = self.layer_shell.create_layer_surface(
            qh,
            surface,
            Layer::Overlay,
            Some("computer-use-linux-indicator"),
            Some(output),
        );
        layer.set_anchor(anchor);
        layer.set_size(size.0, size.1);
        layer.set_exclusive_zone(-1);
        layer.set_keyboard_interactivity(KeyboardInteractivity::None);
        layer.set_margin(margin.0, 0, 0, margin.1);
        let viewport = self
            .viewporter
            .as_ref()
            .map(|viewporter| viewporter.get_viewport(layer.wl_surface(), qh, Quiet));
        let fractional = self.fractional.as_ref().map(|manager| {
            manager.get_fractional_scale(
                layer.wl_surface(),
                qh,
                ScaleOf(layer.wl_surface().clone()),
            )
        });
        let scale = self
            .outputs
            .info(output)
            .map_or(1, |info| info.scale_factor.max(1)) as f32;
        layer.commit();
        self.panels.push(Panel {
            kind,
            output: output.clone(),
            layer,
            viewport,
            fractional,
            size,
            scale,
            configured: false,
            margin,
            drawn: None,
        });
    }

    /// Places a fixed-size panel with its top-left at a desktop point,
    /// clamped to the output under `on`, and returns the offset of `point`
    /// inside it. `on` is separate because a sprite's top-left can lie on a
    /// neighbouring output, which would clip the sprite away.
    fn place(
        &mut self,
        qh: &QueueHandle<Self>,
        kind: Kind,
        size: (u32, u32),
        top_left: (f32, f32),
        on: (f32, f32),
    ) -> Option<(f32, f32)> {
        let (output, rect) = self.output_for(on)?;
        let left = (top_left.0 - rect.x)
            .clamp(0.0, (rect.w - size.0 as f32).max(0.0))
            .round();
        let top = (top_left.1 - rect.y)
            .clamp(0.0, (rect.h - size.1 as f32).max(0.0))
            .round();
        let margin = (top as i32, left as i32);
        match self.panels.iter().position(|panel| panel.kind == kind) {
            Some(index) if self.panels[index].output != output => {
                self.panels.remove(index);
                self.create_panel(qh, kind, &output, Anchor::TOP | Anchor::LEFT, size, margin);
            }
            Some(index) => {
                let panel = &mut self.panels[index];
                if panel.margin != margin {
                    panel.margin = margin;
                    panel.layer.set_margin(margin.0, 0, 0, margin.1);
                    if panel.configured {
                        // Margins are double-buffered: a bare commit moves the
                        // surface without redrawing it.
                        panel.layer.commit();
                    }
                }
            }
            None => self.create_panel(qh, kind, &output, Anchor::TOP | Anchor::LEFT, size, margin),
        }
        Some((top_left.0 - (rect.x + left), top_left.1 - (rect.y + top)))
    }

    /// Creates, moves or removes the cursor, pill and bubble panels.
    fn sync_panels(&mut self, qh: &QueueHandle<Self>) {
        if !self.visible() {
            return;
        }
        // Covers captures that began before this overlay started, too.
        if self.capture_held() {
            self.suspend();
            return;
        }
        self.ensure_edges(qh);
        let half = CURSOR_SIZE / 2.0;
        let cursor = self.cursor_position();
        match cursor {
            Some((x, y)) => {
                let size = (CURSOR_SIZE as u32, CURSOR_SIZE as u32);
                self.place(qh, Kind::Cursor, size, (x - half, y - half), (x, y));
            }
            None => self.panels.retain(|panel| panel.kind != Kind::Cursor),
        }

        // The pill sits at the top of the screen the agent is working on.
        let pill_output = cursor
            .and_then(|point| self.output_for(point))
            .or_else(|| self.output_rects().into_iter().next());
        if let Some((_, rect)) = pill_output {
            let left = rect.x + (rect.w - PILL_SIZE.0 as f32) / 2.0;
            let top_left = (left, rect.y + PILL_TOP as f32);
            self.place(qh, Kind::Pill, PILL_SIZE, top_left, top_left);
        }

        match (&self.keyboard, cursor, pill_output) {
            // Keystrokes go to the focused field, usually where the cursor last clicked.
            (Some(_), Some((x, y)), _) => {
                self.place(qh, Kind::Bubble, BUBBLE_SIZE, (x + 18.0, y + 22.0), (x, y));
            }
            (Some(_), None, Some((_, rect))) => {
                let left = rect.x + (rect.w - BUBBLE_SIZE.0 as f32) / 2.0;
                let top = rect.y + (PILL_TOP + PILL_SIZE.1 as i32) as f32;
                self.place(qh, Kind::Bubble, BUBBLE_SIZE, (left, top), (left, top));
            }
            _ => self.panels.retain(|panel| panel.kind != Kind::Bubble),
        }
    }

    fn tick(&mut self, qh: &QueueHandle<Self>) {
        if let Some(glide) = &self.glide {
            if glide.progress() >= 1.0 {
                if glide.press {
                    self.pulse = Some((Instant::now(), glide.to));
                }
                self.cursor = Some(glide.to);
                self.glide = None;
            }
        }
        if self
            .pulse
            .is_some_and(|(at, _)| at.elapsed().as_secs_f32() > PULSE)
        {
            self.pulse = None;
        }
        if self
            .keyboard
            .as_ref()
            .is_some_and(|(at, _)| at.elapsed().as_secs_f32() > KEYS_SHOWN)
        {
            self.keyboard = None;
        }
        match self.fading {
            Some(at) if at.elapsed().as_secs_f32() > FADE_OUT => {
                self.hide();
                return;
            }
            None if self.visible() && self.last_action.elapsed() > IDLE_BEFORE_FADE => {
                self.fading = Some(Instant::now());
            }
            _ => {}
        }
        self.sync_panels(qh);
        self.render_all(qh);
    }

    fn ensure_animation(&mut self) {
        if self.animating {
            return;
        }
        self.animating = true;
        let started = self
            .handle
            .insert_source(Timer::from_duration(FRAME), |_, _, app| {
                let qh = app.qh();
                app.tick(&qh);
                if !app.visible() {
                    app.animating = false;
                    return TimeoutAction::Drop;
                }
                TimeoutAction::ToDuration(if app.busy() { FRAME } else { RESTING_FRAME })
            });
        if started.is_err() {
            self.animating = false;
        }
    }

    fn qh(&self) -> QueueHandle<Self> {
        self.qh.clone()
    }

    fn render_all(&mut self, _qh: &QueueHandle<Self>) {
        for index in 0..self.panels.len() {
            self.render(index);
        }
    }

    fn sprite(&mut self, scale: f32) -> Option<&Pixmap> {
        let color = agent_color(&self.agent);
        let mut hasher = DefaultHasher::new();
        (
            color.to_color_u8().red(),
            color.to_color_u8().green(),
            color.to_color_u8().blue(),
        )
            .hash(&mut hasher);
        ((scale * 120.0).round() as u32).hash(&mut hasher);
        let key = hasher.finish();
        if self.sprite.as_ref().map(|(k, _)| *k) != Some(key) {
            self.sprite = draw::cursor_sprite(color, scale).map(|pixmap| (key, pixmap));
        }
        self.sprite.as_ref().map(|(_, pixmap)| pixmap)
    }

    /// Draws one panel if its visual state changed since the last frame.
    fn render(&mut self, index: usize) {
        let Some(panel) = self.panels.get(index) else {
            return;
        };
        if !panel.configured || panel.size.0 == 0 || panel.size.1 == 0 {
            return;
        }
        let (kind, size, scale, margin) = (panel.kind, panel.size, panel.scale, panel.margin);
        let Some(rect) = self.rect_of(&panel.output) else {
            return;
        };
        let alpha = self.opacity();
        let color = agent_color(&self.agent);
        let now = self.last_action.elapsed().as_secs_f32();

        // Everything that changes the picture goes into the signature.
        let mut signature = DefaultHasher::new();
        kind.hash(&mut signature);
        size.hash(&mut signature);
        ((scale * 120.0).round() as u32).hash(&mut signature);
        ((alpha * 100.0).round() as u32).hash(&mut signature);
        self.agent.hash(&mut signature);

        let panel_origin = (rect.x + margin.1 as f32, rect.y + margin.0 as f32);
        let cursor = self.cursor_position();
        let sway = if self.glide.is_none() && self.settling() {
            // Damped pendulum around the tip after landing.
            4.0 * (now * 5.0).sin() * (-now / 0.7).exp()
        } else {
            0.0
        };
        let pressed = self
            .pulse
            .is_some_and(|(at, _)| at.elapsed().as_secs_f32() < 0.12);
        let pulse = self.pulse.map(|(at, point)| {
            (
                (at.elapsed().as_secs_f32() / PULSE).min(1.0),
                (point.0 - panel_origin.0, point.1 - panel_origin.1),
            )
        });
        let breath = if self.settling() {
            0.65 + 0.35 * (now * PI).sin().abs()
        } else {
            1.0
        };
        let blink = self
            .keyboard
            .as_ref()
            .is_some_and(|(at, _)| ((at.elapsed().as_secs_f32() * 2.5) as u32).is_multiple_of(2));
        let keyboard_alpha = self.keyboard.as_ref().map_or(0.0, |(at, _)| {
            let age = at.elapsed().as_secs_f32();
            (age / 0.12).min(1.0) * ((KEYS_SHOWN - age) / 0.3).clamp(0.0, 1.0)
        });

        match kind {
            Kind::Cursor => {
                let Some(point) = cursor else { return };
                let tip = (point.0 - panel_origin.0, point.1 - panel_origin.1);
                ((tip.0 * 4.0) as i32, (tip.1 * 4.0) as i32).hash(&mut signature);
                ((sway * 10.0) as i32, pressed).hash(&mut signature);
                pulse.map(|(t, _)| (t * 60.0) as u32).hash(&mut signature);
            }
            Kind::Pill => {
                (self.tool.as_str(), (breath * 20.0) as u32).hash(&mut signature);
                self.fonts.get().is_some().hash(&mut signature);
            }
            Kind::Bubble => {
                ((keyboard_alpha * 50.0) as u32, blink).hash(&mut signature);
                self.fonts.get().is_some().hash(&mut signature);
                match self.keyboard.as_ref().map(|(_, keyboard)| keyboard) {
                    Some(Keyboard::Keys(keys)) => keys.hash(&mut signature),
                    Some(Keyboard::Text(text)) => text.hash(&mut signature),
                    None => {}
                }
            }
            Kind::Edge(_) => {}
        }
        let signature = signature.finish();
        if self.panels[index].drawn == Some(signature) {
            return;
        }

        let (pw, ph) = (
            (size.0 as f32 * scale).round().max(1.0) as u32,
            (size.1 as f32 * scale).round().max(1.0) as u32,
        );
        let Some(mut pixmap) = Pixmap::new(pw, ph) else {
            return;
        };
        match kind {
            Kind::Cursor => {
                if let Some((t, center)) = pulse {
                    let radius = 10.0 + 30.0 * (1.0 - (1.0 - t).powi(3));
                    draw::ring(
                        &mut pixmap,
                        scale,
                        center,
                        radius,
                        2.5,
                        draw::with_alpha(color, 0.9 * (1.0 - t) * alpha),
                    );
                }
                if let Some(point) = cursor {
                    let tip = (point.0 - panel_origin.0, point.1 - panel_origin.1);
                    let factor = if pressed { 0.88 } else { 1.0 };
                    if let Some(sprite) = self.sprite(scale) {
                        let sprite = sprite.clone();
                        draw::draw_sprite(&mut pixmap, &sprite, scale, tip, sway, factor, alpha);
                    }
                }
            }
            Kind::Edge(edge) => draw::edge_glow(&mut pixmap, edge.edge(), color, alpha),
            Kind::Pill => self.draw_pill(&mut pixmap, scale, size, color, alpha, breath),
            Kind::Bubble => {
                self.draw_bubble(&mut pixmap, scale, color, alpha * keyboard_alpha, blink)
            }
        }

        let panel = &mut self.panels[index];
        let Ok((buffer, canvas)) = self.pool.create_buffer(
            pw as i32,
            ph as i32,
            pw as i32 * 4,
            wl_shm::Format::Argb8888,
        ) else {
            return;
        };
        draw::to_argb8888(&pixmap, canvas);
        let surface = panel.layer.wl_surface();
        match &panel.viewport {
            Some(viewport) => viewport.set_destination(size.0 as i32, size.1 as i32),
            None => surface.set_buffer_scale(scale.round().max(1.0) as i32),
        }
        surface.damage_buffer(0, 0, pw as i32, ph as i32);
        if buffer.attach_to(surface).is_ok() {
            panel.layer.commit();
            panel.drawn = Some(signature);
        }
    }

    fn draw_pill(
        &self,
        pixmap: &mut Pixmap,
        scale: f32,
        size: (u32, u32),
        color: Color,
        alpha: f32,
        breath: f32,
    ) {
        let Some(fonts) = self.fonts.get() else {
            return;
        };
        let title = format!("{} is using your computer", self.agent);
        let label = tool_label(&self.tool);
        let text_size = 14.0;
        let title_w = font::measure(&fonts.semibold, text_size, &title);
        let label_w = font::measure(&fonts.regular, text_size, label);
        let (ascent, line) = font::line_metrics(&fonts.regular, text_size);
        let (pad_x, pad_y, dot, gap) = (18.0, 9.0, 8.0, 10.0);
        let w = pad_x * 2.0 + dot + gap + title_w + gap + label_w;
        let h = pad_y * 2.0 + line;
        let x = ((size.0 as f32 - w) / 2.0).max(0.0);
        let y = 6.0;
        draw::panel(
            pixmap,
            scale,
            (x, y, w, h),
            h / 2.0,
            Color::from_rgba(0.09, 0.09, 0.11, 0.86 * alpha).unwrap_or(Color::BLACK),
            Color::from_rgba(1.0, 1.0, 1.0, 0.12 * alpha).unwrap_or(Color::WHITE),
            0.35 * alpha,
        );
        let cy = y + h / 2.0;
        draw::circle(
            pixmap,
            scale,
            (x + pad_x + dot / 2.0, cy),
            dot,
            draw::with_alpha(color, 0.25 * breath * alpha),
        );
        draw::circle(
            pixmap,
            scale,
            (x + pad_x + dot / 2.0, cy),
            dot / 2.0,
            draw::with_alpha(color, breath * alpha),
        );
        let baseline = y + pad_y + ascent;
        let text_x = x + pad_x + dot + gap;
        font::draw(
            pixmap,
            &fonts.semibold,
            text_size * scale,
            (text_x * scale, baseline * scale),
            &title,
            white(0.95 * alpha),
        );
        font::draw(
            pixmap,
            &fonts.regular,
            text_size * scale,
            ((text_x + title_w + gap) * scale, baseline * scale),
            label,
            white(0.6 * alpha),
        );
    }

    fn draw_bubble(&self, pixmap: &mut Pixmap, scale: f32, color: Color, alpha: f32, blink: bool) {
        let (Some(fonts), Some((_, keyboard))) = (self.fonts.get(), &self.keyboard) else {
            return;
        };
        if alpha <= 0.0 {
            return;
        }
        let (x, y, pad) = (8.0, 6.0, 8.0);
        let (ascent, line) = font::line_metrics(&fonts.regular, 13.0);
        let h = line + 2.0 * pad;
        match keyboard {
            Keyboard::Keys(keys) => {
                let cap_pad = 9.0;
                let plus_w = font::measure(&fonts.regular, 12.0, "+");
                let widths: Vec<f32> = keys
                    .iter()
                    .map(|key| font::measure(&fonts.semibold, 13.0, key) + 2.0 * cap_pad)
                    .collect();
                let inner = widths.iter().sum::<f32>()
                    + (keys.len().saturating_sub(1)) as f32 * (plus_w + 10.0);
                let w = inner + 2.0 * pad;
                self.bubble_frame(pixmap, scale, (x, y, w, h), color, alpha);
                let mut cx = x + pad;
                let cap_h = line + 4.0;
                let cap_y = y + (h - cap_h) / 2.0;
                for (i, (key, width)) in keys.iter().zip(&widths).enumerate() {
                    if i > 0 {
                        cx += 5.0;
                        font::draw(
                            pixmap,
                            &fonts.regular,
                            12.0 * scale,
                            (cx * scale, (cap_y + 2.0 + ascent) * scale),
                            "+",
                            white(0.5 * alpha),
                        );
                        cx += plus_w + 5.0;
                    }
                    draw::fill_rounded(
                        pixmap,
                        scale,
                        (cx, cap_y + 2.0, *width, cap_h),
                        6.0,
                        Color::from_rgba(0.0, 0.0, 0.0, 0.5 * alpha).unwrap_or(Color::BLACK),
                    );
                    draw::fill_rounded(
                        pixmap,
                        scale,
                        (cx, cap_y, *width, cap_h),
                        6.0,
                        Color::from_rgba(1.0, 1.0, 1.0, 0.10 * alpha).unwrap_or(Color::WHITE),
                    );
                    draw::stroke_rounded(
                        pixmap,
                        scale,
                        (cx, cap_y, *width, cap_h),
                        6.0,
                        1.0,
                        Color::from_rgba(1.0, 1.0, 1.0, 0.30 * alpha).unwrap_or(Color::WHITE),
                    );
                    font::draw(
                        pixmap,
                        &fonts.semibold,
                        13.0 * scale,
                        ((cx + cap_pad) * scale, (cap_y + 2.0 + ascent) * scale),
                        key,
                        white(0.95 * alpha),
                    );
                    cx += width;
                }
            }
            Keyboard::Text(text) => {
                let shown: String = {
                    let chars: Vec<char> = text.chars().collect();
                    if chars.len() > 40 {
                        std::iter::once('…')
                            .chain(chars[chars.len() - 40..].iter().copied())
                            .collect()
                    } else {
                        text.clone()
                    }
                };
                let text_w = font::measure(&fonts.regular, 13.0, &shown);
                let w = pad + text_w + 4.0 + 2.0 + pad;
                self.bubble_frame(pixmap, scale, (x, y, w, h), color, alpha);
                let baseline = y + pad + ascent;
                let tx = x + pad;
                font::draw(
                    pixmap,
                    &fonts.regular,
                    13.0 * scale,
                    (tx * scale, baseline * scale),
                    &shown,
                    white(0.95 * alpha),
                );
                if blink {
                    draw::fill_rounded(
                        pixmap,
                        scale,
                        (tx + text_w + 3.0, y + pad, 2.0, line),
                        1.0,
                        draw::with_alpha(color, alpha),
                    );
                }
            }
        }
    }

    fn bubble_frame(
        &self,
        pixmap: &mut Pixmap,
        scale: f32,
        rect: (f32, f32, f32, f32),
        color: Color,
        alpha: f32,
    ) {
        draw::panel(
            pixmap,
            scale,
            rect,
            10.0,
            Color::from_rgba(0.09, 0.09, 0.11, 0.88 * alpha).unwrap_or(Color::BLACK),
            draw::with_alpha(color, 0.55 * alpha),
            0.35 * alpha,
        );
    }

    fn panel_for_surface(&mut self, surface: &WlSurface) -> Option<usize> {
        self.panels
            .iter()
            .position(|panel| panel.layer.wl_surface() == surface)
    }
}

fn bounding_box(rects: &[Rect]) -> Option<Rect> {
    let first = rects.first()?;
    let (mut left, mut top) = (first.x, first.y);
    let (mut right, mut bottom) = (first.x + first.w, first.y + first.h);
    for rect in &rects[1..] {
        left = left.min(rect.x);
        top = top.min(rect.y);
        right = right.max(rect.x + rect.w);
        bottom = bottom.max(rect.y + rect.h);
    }
    Some(Rect {
        x: left,
        y: top,
        w: right - left,
        h: bottom - top,
    })
}

/// Spreads a point in a `space`-sized capture over the logical `layout`; a
/// point without a capture size is already logical.
fn spread((x, y): (i32, i32), space: Option<(u32, u32)>, layout: Option<Rect>) -> (f32, f32) {
    match (space, layout) {
        (Some((width, height)), Some(layout)) if width > 0 && height > 0 => (
            layout.x + x as f32 * layout.w / width as f32,
            layout.y + y as f32 * layout.h / height as f32,
        ),
        _ => (x as f32, y as f32),
    }
}

/// Whether a server holds the capture lock. Probing takes it exclusively for
/// an instant; servers retry past that.
fn lock_held(lock: &File) -> bool {
    match lock.try_lock() {
        Ok(()) => {
            let _ = lock.unlock();
            false
        }
        Err(TryLockError::WouldBlock) => true,
        // A failed probe cannot authorize drawing into an in-progress capture.
        Err(TryLockError::Error(_)) => true,
    }
}

fn white(alpha: f32) -> Color {
    Color::from_rgba(1.0, 1.0, 1.0, alpha.clamp(0.0, 1.0)).unwrap_or(Color::WHITE)
}

impl CompositorHandler for App {
    fn scale_factor_changed(
        &mut self,
        _: &Connection,
        _: &QueueHandle<Self>,
        surface: &WlSurface,
        factor: i32,
    ) {
        // Integer fallback when the compositor lacks fractional scaling.
        if self.fractional.is_some() {
            return;
        }
        if let Some(index) = self.panel_for_surface(surface) {
            self.panels[index].scale = factor.max(1) as f32;
            self.panels[index].drawn = None;
            self.render(index);
        }
    }

    fn transform_changed(
        &mut self,
        _: &Connection,
        _: &QueueHandle<Self>,
        _: &WlSurface,
        _: wayland_client::protocol::wl_output::Transform,
    ) {
    }

    fn frame(&mut self, _: &Connection, _: &QueueHandle<Self>, _: &WlSurface, _: u32) {}

    fn surface_enter(
        &mut self,
        _: &Connection,
        _: &QueueHandle<Self>,
        _: &WlSurface,
        _: &WlOutput,
    ) {
    }

    fn surface_leave(
        &mut self,
        _: &Connection,
        _: &QueueHandle<Self>,
        _: &WlSurface,
        _: &WlOutput,
    ) {
    }
}

impl OutputHandler for App {
    fn output_state(&mut self) -> &mut OutputState {
        &mut self.outputs
    }

    fn new_output(&mut self, _: &Connection, _: &QueueHandle<Self>, _: WlOutput) {}

    fn update_output(&mut self, _: &Connection, _: &QueueHandle<Self>, _: WlOutput) {}

    fn output_destroyed(&mut self, _: &Connection, _: &QueueHandle<Self>, output: WlOutput) {
        self.panels.retain(|panel| panel.output != output);
    }
}

impl LayerShellHandler for App {
    fn closed(&mut self, _: &Connection, _: &QueueHandle<Self>, layer: &LayerSurface) {
        self.panels.retain(|panel| &panel.layer != layer);
    }

    fn configure(
        &mut self,
        _: &Connection,
        _: &QueueHandle<Self>,
        layer: &LayerSurface,
        configure: LayerSurfaceConfigure,
        _: u32,
    ) {
        let Some(index) = self.panels.iter().position(|panel| &panel.layer == layer) else {
            return;
        };
        let panel = &mut self.panels[index];
        let (w, h) = configure.new_size;
        if w > 0 {
            panel.size.0 = w;
        }
        if h > 0 {
            panel.size.1 = h;
        }
        panel.configured = true;
        panel.drawn = None;
        self.render(index);
    }
}

impl ShmHandler for App {
    fn shm_state(&mut self) -> &mut Shm {
        &mut self.shm
    }
}

impl ProvidesRegistryState for App {
    fn registry(&mut self) -> &mut RegistryState {
        &mut self.registry
    }
    registry_handlers![OutputState];
}

/// User data for protocol objects that send no events we use.
struct Quiet;

impl Dispatch2<WpViewporter, App> for Quiet {
    fn event(
        &self,
        _: &mut App,
        _: &WpViewporter,
        _: <WpViewporter as wayland_client::Proxy>::Event,
        _: &Connection,
        _: &QueueHandle<App>,
    ) {
    }
}

impl Dispatch2<WpViewport, App> for Quiet {
    fn event(
        &self,
        _: &mut App,
        _: &WpViewport,
        _: <WpViewport as wayland_client::Proxy>::Event,
        _: &Connection,
        _: &QueueHandle<App>,
    ) {
    }
}

impl Dispatch2<WpFractionalScaleManagerV1, App> for Quiet {
    fn event(
        &self,
        _: &mut App,
        _: &WpFractionalScaleManagerV1,
        _: <WpFractionalScaleManagerV1 as wayland_client::Proxy>::Event,
        _: &Connection,
        _: &QueueHandle<App>,
    ) {
    }
}

/// Fractional scale object user data: the surface it scales.
struct ScaleOf(WlSurface);

impl Dispatch2<WpFractionalScaleV1, App> for ScaleOf {
    fn event(
        &self,
        app: &mut App,
        _: &WpFractionalScaleV1,
        event: wp_fractional_scale_v1::Event,
        _: &Connection,
        _: &QueueHandle<App>,
    ) {
        if let wp_fractional_scale_v1::Event::PreferredScale { scale } = event {
            if let Some(index) = app.panel_for_surface(&self.0) {
                app.panels[index].scale = scale as f32 / 120.0;
                app.panels[index].drawn = None;
                app.render(index);
            }
        }
    }
}

delegate_registry!(App);
smithay_client_toolkit::delegate_dispatch2!(App);

fn run() -> Result<(), String> {
    if std::env::var_os("WAYLAND_DISPLAY").is_none()
        && computer_use_linux::indicator::is_gnome_session()
    {
        return gnome::run().map_err(|error| format!("{error:#}"));
    }
    match run_layer_shell() {
        Err(error) if error == "the compositor has no wlr-layer-shell" => {
            gnome::run().map_err(|error| format!("{error:#}"))
        }
        result => result,
    }
}

fn run_layer_shell() -> Result<(), String> {
    let path = socket_path().ok_or("XDG_RUNTIME_DIR is not set")?;
    // One overlay per session. Agents may start it at the same moment, so a
    // lock, not a probe of the socket, decides which instance stays. The lock
    // lives as long as the process.
    let lock = std::fs::File::create(path.with_extension("lock"))
        .map_err(|error| format!("lock file: {error}"))?;
    if lock.try_lock().is_err() {
        return Ok(());
    }
    let capture_lock = OpenOptions::new()
        .create(true)
        .truncate(false)
        .write(true)
        .open(capture_lock_path(&path))
        .map_err(|error| format!("capture lock file: {error}"))?;

    let conn =
        Connection::connect_to_env().map_err(|error| format!("no Wayland session: {error}"))?;
    let (globals, queue) = registry_queue_init(&conn).map_err(|error| error.to_string())?;
    let qh = queue.handle();
    let compositor = CompositorState::bind(&globals, &qh).map_err(|error| error.to_string())?;
    // GNOME has no layer-shell; exiting before the socket exists tells the
    // server not to retry.
    let layer_shell =
        LayerShell::bind(&globals, &qh).map_err(|_| "the compositor has no wlr-layer-shell")?;
    let shm = Shm::bind(&globals, &qh).map_err(|error| error.to_string())?;
    let pool = SlotPool::new(256 * 256 * 4, &shm).map_err(|error| error.to_string())?;
    let viewporter = globals.bind::<WpViewporter, _, _>(&qh, 1..=1, Quiet).ok();
    let fractional = viewporter.as_ref().and_then(|_| {
        globals
            .bind::<WpFractionalScaleManagerV1, _, _>(&qh, 1..=1, Quiet)
            .ok()
    });

    let mut event_loop: EventLoop<'static, App> =
        EventLoop::try_new().map_err(|error| error.to_string())?;
    let handle = event_loop.handle();
    let fonts = Arc::new(OnceLock::new());
    {
        let fonts = Arc::clone(&fonts);
        std::thread::spawn(move || {
            if let Some(loaded) = font::Fonts::load() {
                let _ = fonts.set(loaded);
            }
        });
    }
    let mut app = App {
        registry: RegistryState::new(&globals),
        outputs: OutputState::new(&globals, &qh),
        compositor,
        layer_shell,
        shm,
        pool,
        viewporter,
        fractional,
        fonts,
        active: false,
        handle: handle.clone(),
        qh: qh.clone(),
        panels: Vec::new(),
        agent: String::new(),
        tool: String::new(),
        cursor: None,
        glide: None,
        pulse: None,
        keyboard: None,
        last_action: Instant::now(),
        shown_at: Instant::now(),
        fading: None,
        removed_at: None,
        capture_lock,
        watching_hold: false,
        sprite: None,
        animating: false,
        exit: false,
    };
    // Learn the output layout (wl_output, then xdg-output) before accepting
    // events, so the first action already knows where to draw.
    let mut queue = queue;
    for _ in 0..2 {
        queue
            .roundtrip(&mut app)
            .map_err(|error| error.to_string())?;
    }
    WaylandSource::new(conn, queue)
        .insert(handle.clone())
        .map_err(|error| error.to_string())?;

    let _ = std::fs::remove_file(&path);
    let socket =
        UnixDatagram::bind(&path).map_err(|error| format!("bind {}: {error}", path.display()))?;
    socket
        .set_nonblocking(true)
        .map_err(|error| error.to_string())?;
    handle
        .insert_source(
            Generic::new(socket, Interest::READ, Mode::Level),
            |_, socket, app| {
                let mut buf = [0u8; 4096];
                let qh = app.qh();
                while let Ok((len, sender)) = socket.recv_from(&mut buf) {
                    let Ok(event) = serde_json::from_slice::<IndicatorEvent>(&buf[..len]) else {
                        continue;
                    };
                    match event.capture {
                        Some(Capture::Begin) => {
                            // Tell the capturing server whether it has to wait
                            // for the compositor to drop our surfaces.
                            let shown = app.on_screen();
                            app.suspend();
                            let reply = if shown {
                                CAPTURE_REPLY_SHOWN
                            } else {
                                CAPTURE_REPLY_EMPTY
                            };
                            let _ = socket.send_to_addr(reply, &sender);
                        }
                        Some(Capture::End) if !app.capture_held() => app.resume(&qh),
                        Some(Capture::End) => {}
                        // Every action names its tool; anything else is noise.
                        None if !event.tool.is_empty() => app.on_event(event, &qh),
                        None => {}
                    }
                }
                Ok(PostAction::Continue)
            },
        )
        .map_err(|error| error.to_string())?;
    // Leave nothing resident when no agent has used the desktop for a while.
    handle
        .insert_source(Timer::from_duration(EXIT_AFTER_IDLE), |_, _, app| {
            if !app.visible() && app.last_action.elapsed() >= EXIT_AFTER_IDLE {
                app.exit = true;
                return TimeoutAction::Drop;
            }
            // Check again when the latest action turns ten minutes old.
            TimeoutAction::ToDuration(
                EXIT_AFTER_IDLE
                    .saturating_sub(app.last_action.elapsed())
                    .max(Duration::from_secs(1)),
            )
        })
        .map_err(|error| error.to_string())?;

    while !app.exit {
        if let Err(error) = event_loop.dispatch(None, &mut app) {
            let _ = std::fs::remove_file(&path);
            return Err(error.to_string());
        }
    }
    let _ = std::fs::remove_file(&path);
    Ok(())
}

fn main() -> ExitCode {
    match run() {
        Ok(()) => ExitCode::SUCCESS,
        Err(error) => {
            eprintln!("[computer-use-linux-indicator] {error}");
            ExitCode::FAILURE
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn rect(x: f32, y: f32, w: f32, h: f32) -> Rect {
        Rect { x, y, w, h }
    }

    #[test]
    fn capture_points_spread_over_the_logical_layout() {
        // A 2x output: a 3840x2160 capture over a 1920x1080 logical desktop.
        let layout = bounding_box(&[rect(0.0, 0.0, 1920.0, 1080.0)]);
        assert_eq!(
            spread((3000, 1500), Some((3840, 2160)), layout),
            (1500.0, 750.0)
        );
        // Without a capture size the point is already logical.
        assert_eq!(spread((300, 150), None, layout), (300.0, 150.0));
    }

    #[test]
    fn any_capturing_server_holds_the_overlay_back() {
        let path =
            std::env::temp_dir().join(format!("cul-overlay-hold-{}.capture", std::process::id()));
        let open = || {
            OpenOptions::new()
                .create(true)
                .truncate(false)
                .write(true)
                .open(&path)
                .unwrap()
        };
        let overlay = open();
        assert!(!lock_held(&overlay));
        let (first, second) = (open(), open());
        first.try_lock_shared().unwrap();
        second.try_lock_shared().unwrap();
        assert!(lock_held(&overlay));
        drop(first);
        assert!(lock_held(&overlay), "one capture still runs");
        drop(second);
        assert!(!lock_held(&overlay));
        // Probing must not leave the lock taken.
        let third = open();
        third.try_lock_shared().unwrap();
        let _ = std::fs::remove_file(&path);
    }

    #[test]
    fn layouts_span_every_output() {
        let layout = bounding_box(&[
            rect(1920.0, 0.0, 1280.0, 720.0),
            rect(0.0, 0.0, 1920.0, 1080.0),
        ]);
        assert_eq!(layout, Some(rect(0.0, 0.0, 3200.0, 1080.0)));
        assert_eq!(spread((4800, 0), Some((6400, 2160)), layout), (2400.0, 0.0));
        assert_eq!(bounding_box(&[]), None);
    }
}