blockworx/canvas/

view.rs

use std::cell::RefCell;
use std::rc::Rc;

use blockworx_geom::{Pos2, Rangef, Rect, Vec2, pos2};
use blockworx_paint::{Canvas as _, Color, Cursor, Event, Interaction, Palette, Zoom, ZoomStep};
use blockworx_store::record::Camera as Recorded;
use egui::{PointerButton, Sense, Stroke};

use super::egui_compat::{IntoEgui as _, IntoGeom};
use super::interaction::compute_interaction;
use super::painter::Painter;
use crate::canvas::image::ImageRegistry;
use crate::grid::GRID_SIZE;
use crate::icons::Icons;
/// Largest zoom a *framing* will apply — the navigator focusing one block, or a
/// double-click fitting the level's contents. Small content would otherwise
/// balloon to fill the view, which reads as a jump rather than a fit. Explicit
/// camera rects are not capped: a caller asking for a ten-cell window means
/// it.
const FRAME_MAX_ZOOM: f32 = 2.0;

/// The gutter a double-click fit leaves around the content, in grid cells, so
/// the outermost blocks don't sit against the viewport edge.
const FIT_BORDER_CELLS: f32 = 4.0;

/// The slack the camera framings leave around their rect, as a fraction of the
/// content's size per side. A quarter of the content overall — the same framing
/// they have always had, expressed as padding rather than as a fudge factor on
/// the computed zoom.
const CAMERA_SLACK: f32 = 0.125;

/// The band the scroll wheel zooms within — deliberately narrower than [`Zoom`]'s
/// own bounds, which the framing helpers are allowed to use in full.
const WHEEL_ZOOM_MIN: Zoom = Zoom::new(0.25);
const WHEEL_ZOOM_MAX: Zoom = Zoom::new(4.0);

/// Zoom factor exponent per pixel of scroll delta.
const SCROLL_ZOOM_RATE: f32 = 0.002;

/// Screen-space spacing below which the minor grid lines are dropped, as they
/// read as a wash of color rather than a grid.
const MIN_MINOR_GRID_SPACING: f32 = 5.0;

/// Every fourth grid line is a major one.
const MAJOR_GRID_STEP: i32 = 4;

/// The two weights the grid is drawn in.
#[derive(Clone, Copy, PartialEq, Eq)]
enum GridLine {
    Major,
    Minor,
}

impl GridLine {
    fn at(index: i32) -> Self {
        if index % MAJOR_GRID_STEP == 0 {
            Self::Major
        } else {
            Self::Minor
        }
    }

    fn stroke(self, color: Color) -> Stroke {
        match self {
            Self::Major => Stroke::new(1.0, color.egui()),
            Self::Minor => Stroke::new(0.5, color.egui()),
        }
    }
}

/// Zoom that fits a `content`-sized box within a `viewport`-sized box, clamped
/// to `[0.1, max_zoom]`. Padding is the caller's: it pads `content` before
/// framing it. Pure so it can be unit-tested without a live viewport.
fn frame_zoom(viewport: Vec2, content: Vec2, max_zoom: Zoom) -> Zoom {
    let zoom = (viewport.x / content.x).min(viewport.y / content.y);
    Zoom::new(zoom.min(max_zoom.get()))
}

/// The two raw colors the canvas paints its own chrome with (the background fill
/// and the grid lines). The app resolves these from its theme and hands them to
/// [`View::begin`], so the canvas never needs to know about roles or a theme.
#[derive(Clone, Copy)]
pub struct CanvasChrome {
    pub background: Color,
    pub grid: Color,
}

/// Focus and key results from the in-place text editor, which egui can only
/// report after the canvas closure has already run. They are held for one frame
/// and merged into the next [`Interaction`], so a tool sees them alongside the
/// keys the canvas itself reports.
#[derive(Clone, Copy, Default)]
struct EditorFeedback {
    lost_focus: bool,
    enter: bool,
    tab: bool,
    escape: bool,
}

impl EditorFeedback {
    fn merge_into(self, interaction: &mut Interaction) {
        interaction.lost_focus |= self.lost_focus;
        interaction.enter_pressed |= self.enter;
        interaction.tab_pressed |= self.tab;
        interaction.escape_pressed |= self.escape;
    }
}

/// Where the camera stands: the whole of what a `view`-kind undo entry
/// restores (spec §7.1).
///
/// The two numbers the view holds, not a world rect — a rect would have to be
/// re-framed against a viewport that may have resized since, which would land
/// the camera somewhere the user never was.
#[derive(Clone, Copy, PartialEq, Debug)]
pub struct Vantage {
    pub zoom: Zoom,
    pub translation: Vec2,
}

impl Vantage {
    /// How a manifest row records this view (§10.1 of
    /// `docs/log-vs-snapshot.md`): the world point at the centre of
    /// `viewport`, and the zoom.
    ///
    /// Centre-and-zoom rather than the translation, which is measured
    /// against a window size the reader may no longer have.
    pub fn recorded(self, viewport: Vec2) -> Recorded {
        let centre = (viewport / 2.0 - self.translation) / self.zoom.get();
        Recorded {
            x: centre.x,
            y: centre.y,
            zoom: self.zoom.get(),
        }
    }

    /// And back, against the viewport the reader has now.
    pub fn of_recorded(camera: Recorded, viewport: Vec2) -> Self {
        let zoom = Zoom::new(camera.zoom);
        Self {
            zoom,
            translation: viewport / 2.0 - Vec2::new(camera.x, camera.y) * zoom.get(),
        }
    }
}

/// Whether the camera is being worked this frame — a drag pan, or a two-finger
/// pan/pinch in flight.
///
/// One answer, two readers, because they are the same question asked twice: the
/// gesture is consumed by the view, so the active tool must not also read it as
/// a selection or a move; and the selection overlay hides while it lasts rather
/// than jittering along behind the object (§3.4).
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Camera {
    Moving,
    Settled,
}

/// Whether the key that turns a left-drag into a pan is held: **space**, the
/// convention across drawing and diagram editors (Figma, Illustrator, Inkscape,
/// Miro). A text editor owning the keyboard is typing, not panning.
fn pan_key_held(ui: &egui::Ui) -> bool {
    !ui.ctx().egui_wants_keyboard_input() && ui.input(|i| i.key_down(egui::Key::Space))
}

pub struct View {
    pub zoom: Zoom,
    pub translation: Vec2,
    editor_feedback: EditorFeedback,
    /// Id of the in-place editor rendered last frame, so a freshly-shown editor
    /// (different id, or none previously) can grab keyboard focus exactly once.
    last_edit_id: Option<egui::Id>,
    last_mouse_down: Option<Pos2>,
    /// Screen-space rect the canvas was drawn into last frame. Used by
    /// `frame_rect` to compute zoom/pan against the actual viewport size.
    viewport: Rect,
    /// The part of the viewport the floating chrome leaves clear, measured
    /// this frame (spec §2.1). Every framing centres in *this* rather than in
    /// the raw viewport, so nothing lands under a pill. `Rect::NOTHING` until
    /// a shell measures its chrome — which is what a headless caller leaves it
    /// at, and it has no chrome to clear.
    safe: Rect,
    /// Whether the pointer was over the canvas response (not a floating overlay)
    /// as of the last [`Self::begin`]. Lets the app suppress the tool cursor when
    /// the pointer sits over the nav bar, toolbar, or selection overlay.
    hovered: bool,
    /// When set, the view is easing its `(zoom, translation)` toward this target
    /// (a framing requested by `focus_on`), so navigation glides instead of
    /// snapping. Cleared once reached, or when the user zooms/pans.
    target_view: Option<(Zoom, Vec2)>,
    /// Whether the primary-button drag in progress is panning the canvas (it
    /// began with the [pan key](pan_key_held) held). Latched at drag start so
    /// releasing the key mid-drag can't hand a half-finished pan to a tool.
    primary_drag_pans: bool,
    /// Whether a two-finger gesture is in progress. `MultiTouchInfo` vanishes
    /// the instant a finger lifts, but the finger still down keeps arriving as
    /// an ordinary drag — so the latch holds the canvas until the last one
    /// leaves, rather than handing a half-finished pan to a tool.
    touch_pans: bool,
    /// What the last [`Self::begin`] made of the frame's camera input, kept for
    /// the chrome drawn after the canvas pass (§3.4).
    camera: Camera,
    /// Whether the user worked the camera themselves this frame — a wheel, a
    /// pinch, a drag pan, a zoom step. The undo stack names an entry by the
    /// move that made it (§7.2), and a fit is not a pan.
    worked: bool,
    /// Registered images, keyed by content. Shared with the per-frame `Painter`
    /// so the image/icon tools can register through it.
    images: Rc<RefCell<ImageRegistry>>,
    /// Handles for the embedded UI icons, registered once via
    /// [`Self::register_icons`] and handed to each frame's `Painter`.
    icons: Icons,
}

/// Whether a view change eases into place or jumps there.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Framing {
    Animated,
    Immediate,
}

/// Exponential approach rate for an animated view change; higher is snappier.
const VIEW_ANIMATION_RATE: f32 = 16.0;

/// How far a span reaching from `lo` to `hi` must move along one axis to sit
/// inside `visible_lo..visible_hi`. Zero when it already does; assumes it
/// fits, so it never has to choose which end to leave outside.
fn overshoot(lo: f32, hi: f32, visible_lo: f32, visible_hi: f32) -> f32 {
    if lo < visible_lo {
        lo - visible_lo
    } else if hi > visible_hi {
        hi - visible_hi
    } else {
        0.0
    }
}

impl View {
    pub fn new() -> Self {
        Self {
            zoom: Zoom::unity(),
            translation: Vec2::ZERO,
            editor_feedback: EditorFeedback::default(),
            last_edit_id: None,
            last_mouse_down: None,
            viewport: Rect::ZERO,
            safe: Rect::NOTHING,
            hovered: false,
            target_view: None,
            primary_drag_pans: false,
            touch_pans: false,
            camera: Camera::Settled,
            worked: false,
            images: Rc::new(RefCell::new(ImageRegistry::default())),
            icons: Icons::default(),
        }
    }

    /// Register the embedded UI icons. Call once at startup (see `App::update`).
    pub fn register_icons(&mut self, ctx: &egui::Context) {
        self.icons = Icons::register(ctx, &mut self.images.borrow_mut());
    }

    /// Screen-space rect the canvas occupied as of the last [`Self::begin`]. Used
    /// to place screen-space overlays (e.g. the selection bar) within the canvas.
    pub fn viewport(&self) -> Rect {
        self.viewport
    }

    /// Tell the view which part of its viewport the floating chrome leaves
    /// clear (spec §2.1). Called every frame with what the chrome actually
    /// measured, so opening or closing a piece reframes from the frame it
    /// happens; nothing is cached across the change.
    pub fn set_safe_region(&mut self, region: Rect) {
        self.safe = region;
    }

    /// Where a framing centres and sizes itself: the region the chrome left,
    /// or the whole viewport where no chrome has reported any.
    fn framing_rect(&self) -> Rect {
        if self.safe.is_positive() {
            self.safe
        } else {
            self.viewport
        }
    }

    /// Whether the pointer was over the canvas (not a floating overlay) as of the
    /// last [`Self::begin`]. The app gates the tool cursor on this so it never
    /// leaks over the nav bar, toolbar, or selection overlay.
    pub fn canvas_hovered(&self) -> bool {
        self.hovered
    }

    /// The viewport as it was last laid out — what a recorded camera is
    /// measured against, in both directions.
    pub fn viewport_size(&self) -> Vec2 {
        self.viewport.size()
    }

    /// Current world→screen scale. Lets screen-space overlays size a world-space
    /// gap (e.g. the selection bar's distance from its object) in pixels.
    pub fn zoom(&self) -> Zoom {
        self.zoom
    }

    /// Whether the camera is being worked, as of the last [`Self::begin`]. The
    /// selection overlay is drawn after the canvas pass and reads it there.
    pub fn camera(&self) -> Camera {
        self.camera
    }

    /// Where the camera stands — the whole of what a `view` undo entry holds.
    pub fn vantage(&self) -> Vantage {
        Vantage {
            zoom: self.zoom,
            translation: self.translation,
        }
    }

    /// Put the camera back where an undo entry says it stood. Any framing
    /// still easing is abandoned: the entry *is* the framing now, and letting
    /// the old one finish would walk the camera off the state the stack
    /// believes it landed on.
    pub fn stand_at(&mut self, vantage: Vantage) {
        self.zoom = vantage.zoom;
        self.translation = vantage.translation;
        self.target_view = None;
    }

    /// Whether the user moved the camera themselves since the last frame,
    /// rather than a fit or a focus moving it for them.
    pub fn worked_camera(&self) -> bool {
        self.worked
    }

    /// Id of the in-place editor rendered last frame. A fallback for surrendering
    /// editor focus when `Memory::focused` can't be trusted to name it.
    pub fn focused_edit_id(&self) -> Option<egui::Id> {
        self.last_edit_id
    }

    /// Reset zoom and pan so `content` (world space) fits within the viewport,
    /// centered, with a small margin around it.
    /// Frame `content` to fill the view, snapping immediately instead of easing.
    /// Used for layer changes (drilling into / out of a block): the block path
    /// changed underneath, so animating a pan/zoom across unrelated content is
    /// jarring rather than helpful.
    pub fn fit_to_rect_instant(&mut self, content: Rect) {
        self.frame_rect(
            content.expand2(content.size() * CAMERA_SLACK),
            Zoom::max_value(),
            Framing::Immediate,
        );
    }

    /// Fit the level's whole contents in view — the double-click gesture. Unlike
    /// an authored camera rect this leaves a fixed [`FIT_BORDER_CELLS`] gutter
    /// (so nothing sits against the edge) and is capped at [`FRAME_MAX_ZOOM`]
    /// (so a nearly empty level doesn't leap to a huge magnification).
    pub fn fit_content(&mut self, content: Rect) {
        self.frame_rect(
            content.expand(FIT_BORDER_CELLS * GRID_SIZE),
            Zoom::new(FRAME_MAX_ZOOM),
            Framing::Immediate,
        );
    }

    /// Frame a single subject — a block picked from the navigation dialog,
    /// the region an undo just changed — capping the zoom so a small one
    /// doesn't blow up to fill the whole view. A framing that crosses a
    /// scope snaps ([`Framing::Immediate`]) for the same reason a navigation
    /// does: easing across content the camera was never on is jarring.
    pub fn focus_on(&mut self, content: Rect, framing: Framing) {
        self.frame_rect(
            content.expand2(content.size() * CAMERA_SLACK),
            Zoom::new(FRAME_MAX_ZOOM),
            framing,
        );
    }

    /// Bring `content` into view with the gentlest move that reaches it:
    /// nothing at all when it is already visible, otherwise a pan — the zoom
    /// is only touched for content that cannot fit at this one. What a paste
    /// lands is content the viewer has never seen, so the alternative to this
    /// is content that arrives off-screen and reads as having not arrived.
    ///
    /// A history step frames [`Framing::Immediate`]: the undo stack pins the
    /// camera the step ended at, and a camera still easing toward its target
    /// would leave the pin and the view disagreeing for every frame of the
    /// ease.
    pub fn bring_into_view(&mut self, content: Rect, framing: Framing) {
        if !content.is_positive() || !self.viewport.is_positive() {
            return;
        }
        let visible = self.visible_world_rect();
        if visible.contains_rect(content) {
            return;
        }
        let fits = |r: Rect| r.width() <= visible.width() && r.height() <= visible.height();
        let gutter = content.expand(FIT_BORDER_CELLS * GRID_SIZE);
        let target = if fits(gutter) { gutter } else { content };
        if !fits(target) {
            self.focus_on(content, framing);
            return;
        }
        let shift = Vec2::new(
            overshoot(target.min.x, target.max.x, visible.min.x, visible.max.x),
            overshoot(target.min.y, target.max.y, visible.min.y, visible.max.y),
        );
        let panned = self.translation - shift * self.zoom.get();
        match framing {
            Framing::Animated => self.target_view = Some((self.zoom, panned)),
            Framing::Immediate => {
                self.translation = panned;
                self.target_view = None;
            }
        }
    }

    fn frame_rect(&mut self, content: Rect, max_zoom: Zoom, framing: Framing) {
        if !content.is_positive() || !self.viewport.is_positive() {
            return;
        }
        // Not the viewport: the chrome floats over it, and framing against
        // the raw rect lands the model under the tool cluster (§2.1).
        let within = self.framing_rect();
        let zoom = frame_zoom(within.size(), content.size(), max_zoom);
        // world_to_screen maps `world` to `viewport.min + translation + world * zoom`.
        // Pick translation so content.center() lands on the safe region's center.
        let translation =
            (within.center() - self.viewport.min) - content.center().to_vec2() * zoom.get();
        if framing == Framing::Animated {
            // Ease toward the framing rather than snapping (see `animate_view`).
            self.target_view = Some((zoom, translation));
        } else {
            self.zoom = zoom;
            self.translation = translation;
            self.target_view = None;
        }
    }

    /// Advance any in-progress framing animation one frame, easing `zoom` and
    /// `translation` toward the target with a frame-rate-independent exponential
    /// approach. Requests a repaint until the target is reached. Returns nothing;
    /// the user zooming or panning clears the target so manual control wins.
    fn animate_view(&mut self, ctx: &egui::Context) {
        let Some((zoom, translation)) = self.target_view else {
            return;
        };
        let dt = ctx.input(|i| i.stable_dt).clamp(0.0, 0.1);
        let t = 1.0 - (-VIEW_ANIMATION_RATE * dt).exp();
        self.zoom = Zoom::new(self.zoom.get() + (zoom.get() - self.zoom.get()) * t);
        self.translation += (translation - self.translation) * t;
        if (self.zoom.get() - zoom.get()).abs() < 1e-3
            && (self.translation - translation).length() < 0.5
        {
            self.zoom = zoom;
            self.translation = translation;
            self.target_view = None;
        } else {
            ctx.request_repaint();
        }
    }
    pub fn world_to_screen(&self, origin: Pos2, world: Pos2) -> Pos2 {
        origin + self.translation + world.to_vec2() * self.zoom.get()
    }

    /// Screen position → world position under the current transform (origin =
    /// the viewport min) — where a tool carried off the cluster was dropped.
    pub fn screen_to_world_pos(&self, screen: Pos2) -> Pos2 {
        self.screen_to_world(self.viewport.min, screen)
    }

    fn screen_to_world(&self, origin: Pos2, screen: Pos2) -> Pos2 {
        ((screen - origin - self.translation) / self.zoom.get()).to_pos2()
    }

    /// The world rect the viewport currently shows.
    pub fn visible_world_rect(&self) -> Rect {
        Rect::from_min_max(
            self.screen_to_world(self.viewport.min, self.viewport.min),
            self.screen_to_world(self.viewport.min, self.viewport.max),
        )
    }

    /// World-space point at the center of the current viewport, mapped with the
    /// same transform as [`Self::screen_to_world`] (`origin` = `viewport.min`).
    /// Falls back to the translation-based origin when the viewport hasn't been
    /// laid out yet (no positive area), so a paste before the first frame still
    /// lands somewhere sensible.
    pub fn visible_world_center(&self) -> Pos2 {
        if !self.viewport.is_positive() {
            return (-self.translation / self.zoom.get()).to_pos2();
        }
        self.screen_to_world(self.viewport.min, self.viewport.center())
    }

    /// Open the canvas frame: allocate the viewport, advance any framing
    /// animation, and take this frame's pan/zoom — everything that decides
    /// the camera, and nothing that paints under it. The returned
    /// [`Canvas`] is where a framing can still be changed; `palette` backs
    /// the `Painter`'s `Swatch → Color` resolution and `chrome` supplies
    /// the background/grid colors the caller resolved from its theme.
    pub fn begin<'a>(
        &'a mut self,
        ui: &'a mut egui::Ui,
        palette: Palette,
        chrome: CanvasChrome,
    ) -> Canvas<'a> {
        let (rect, response) = ui.allocate_exact_size(ui.available_size(), Sense::click_and_drag());
        let rect = rect.geom();
        self.viewport = rect;
        self.hovered = response.hovered();

        // Ease toward a pending framing (nav/fit) before reading manual input.
        self.animate_view(ui.ctx());
        self.worked = false;
        let pan = self.handle_pan_zoom(ui, &response, rect);
        self.camera = pan;

        if let Some(pos) = response.interact_pointer_pos() {
            if self.last_mouse_down.is_none() {
                self.last_mouse_down = Some(pos.geom());
            }
        } else {
            self.last_mouse_down = None;
        }

        Canvas {
            view: self,
            ui,
            palette,
            chrome,
            rect,
            response,
            pan,
        }
    }

    /// Wheel zoom (centered on the cursor), two-finger pan/pinch, and drag pan —
    /// right/middle button, or the primary button with the [pan key](pan_key_held)
    /// held. All are manual control, so any of them cancels a framing animation
    /// in progress.
    fn handle_pan_zoom(&mut self, ui: &egui::Ui, response: &egui::Response, rect: Rect) -> Camera {
        if let Some(pan) = self.handle_touch_gesture(ui, response, rect) {
            return pan;
        }
        // `hovered()` is false when a floating overlay (the nav tree, toolbar, …)
        // sits under the pointer, so scrolling there scrolls that overlay instead
        // of also zooming the canvas.
        if response.hovered() {
            let cursor = ui
                .ctx()
                .pointer_hover_pos()
                .map_or(rect.center(), IntoGeom::geom);
            // A bare wheel zooms — this canvas has no document flow to scroll
            // past. egui diverts ctrl/⌘+wheel and trackpad pinch into
            // `zoom_delta` instead (leaving `smooth_scroll_delta` at zero), so
            // both channels are read: the modifier is optional, not a different
            // gesture.
            let (scroll, pinch) = ui.input(|i| (i.smooth_scroll_delta.y, i.zoom_delta()));
            let factor = (scroll * SCROLL_ZOOM_RATE).exp() * pinch;
            if factor != 1.0 {
                self.zoom_about(factor, cursor, rect);
            }
        }

        // A left-drag pans while the pan key is held, for pointing devices where
        // the other buttons are awkward. Shift+left-drag stays the selection
        // marquee (handled by the tools), so it is not a pan gesture.
        if response.drag_started() {
            self.primary_drag_pans = pan_key_held(ui);
        }
        // The latch also covers the frame the drag stops on, so the gesture's
        // closing event is consumed by the pan rather than reaching a tool.
        let primary_pan = self.primary_drag_pans
            && (response.dragged_by(PointerButton::Primary) || response.drag_stopped());
        if response.drag_stopped() {
            self.primary_drag_pans = false;
        }
        if primary_pan
            || response.dragged_by(PointerButton::Secondary)
            || response.dragged_by(PointerButton::Middle)
        {
            self.target_view = None;
            self.translation += response.drag_delta().geom();
            self.worked = true;
            Camera::Moving
        } else {
            Camera::Settled
        }
    }

    /// Two fingers pan and pinch the canvas together, about the gesture's own
    /// center. `Some` means the gesture owns the frame — the primary finger also
    /// arrives as an ordinary drag, which a tool would otherwise read as a
    /// marquee or a wire.
    ///
    /// This is the only pan a touch screen has: it has no wheel, no middle
    /// button, and no space bar to hold.
    fn handle_touch_gesture(
        &mut self,
        ui: &egui::Ui,
        response: &egui::Response,
        rect: Rect,
    ) -> Option<Camera> {
        let (gesture, touching) = ui.input(|i| (i.multi_touch(), i.any_touches()));
        if !touching {
            self.touch_pans = false;
            return None;
        }
        // A gesture that began on the canvas keeps it even if a finger strays
        // over an overlay; one that began on an overlay never takes it.
        let ours = self.touch_pans || response.hovered() || response.is_pointer_button_down_on();
        let Some(gesture) = gesture.filter(|_| ours) else {
            // The latch outlives `MultiTouchInfo`, which is gone the moment the
            // gesture drops back to one finger.
            return self.touch_pans.then_some(Camera::Moving);
        };
        self.touch_pans = true;
        self.target_view = None;
        self.worked = true;
        self.translation += gesture.translation_delta.geom();
        if gesture.zoom_delta != 1.0 {
            self.zoom_about(gesture.zoom_delta, gesture.center_pos.geom(), rect);
        }
        Some(Camera::Moving)
    }

    /// Scale the zoom by `factor`, keeping the world point under `anchor` (a
    /// screen position) where it is — the "zoom about the cursor" every zoom
    /// input wants. `rect` is the canvas viewport, whose corner the translation
    /// is measured from. Manual control, so it cancels a framing animation.
    fn zoom_about(&mut self, factor: f32, anchor: Pos2, rect: Rect) {
        self.target_view = None;
        self.worked = true;
        let new_zoom = Zoom::new(self.zoom.get() * factor).clamp(WHEEL_ZOOM_MIN, WHEEL_ZOOM_MAX);
        let from_corner = anchor.to_vec2() - rect.min.to_vec2();
        let world_offset = from_corner - self.translation;
        self.translation = from_corner - world_offset * (new_zoom.get() / self.zoom.get());
        self.zoom = new_zoom;
    }

    /// One keyboard zoom step, about `anchor` (the pointer) or the viewport
    /// center when the pointer is elsewhere.
    pub fn zoom_step(&mut self, step: ZoomStep, anchor: Option<Pos2>) {
        if !self.viewport.is_positive() {
            return;
        }
        let anchor = anchor
            .filter(|p| self.viewport.contains(*p))
            .unwrap_or_else(|| self.viewport.center());
        self.zoom_about(step.factor(), anchor, self.viewport);
    }

    /// Paint the canvas background and the grid over it, drawn with the raw egui
    /// painter (outside the palette-based [`Painter`]) so they use the chrome
    /// colors the caller already resolved.
    fn draw_grid(&self, painter: &egui::Painter, rect: Rect, chrome: CanvasChrome) {
        painter.rect_filled(rect.egui(), 0.0, chrome.background.egui());

        let origin = rect.min;
        let world = Rect::from_min_max(
            self.screen_to_world(origin, rect.min),
            self.screen_to_world(origin, rect.max),
        );
        for (x, line) in self.grid_lines(world.x_range()) {
            let sx = self.world_to_screen(origin, pos2(x, 0.0)).x;
            painter.vline(sx, rect.y_range().egui(), line.stroke(chrome.grid));
        }
        for (y, line) in self.grid_lines(world.y_range()) {
            let sy = self.world_to_screen(origin, pos2(0.0, y)).y;
            painter.hline(rect.x_range().egui(), sy, line.stroke(chrome.grid));
        }
    }

    /// World coordinates of the grid lines crossing `span` on one axis, each with
    /// its weight. Minor lines are skipped once they crowd together on screen.
    fn grid_lines(&self, span: Rangef) -> impl Iterator<Item = (f32, GridLine)> {
        let draw_minor = GRID_SIZE * self.zoom.get() >= MIN_MINOR_GRID_SPACING;
        ((span.min / GRID_SIZE).floor() as i32..=(span.max / GRID_SIZE).ceil() as i32)
            .map(|i| (i as f32 * GRID_SIZE, GridLine::at(i)))
            .filter(move |&(_, line)| line == GridLine::Major || draw_minor)
    }

    /// Render the in-place `TextEdit` the closure requested, if any, remapping it
    /// from world space to screen space. Its focus and key results only exist
    /// after the widget has run, so they are returned for the next frame.
    fn render_pending_edit(&mut self, ui: &mut egui::Ui, painter: &mut Painter) -> EditorFeedback {
        let Some(edit) = painter.take_edit_text() else {
            self.last_edit_id = None;
            return EditorFeedback::default();
        };
        let edit_id = edit.id.egui();
        let screen_rect = painter.remap_rect(edit.position);
        let screen_font = painter.remap_font(&edit.font).egui();
        let mut buffer = edit.buffer.borrow_mut();
        // A wrapping editor (the text box) must wrap at exactly the width its
        // rendered box wraps at — egui's default wraps to the widget's inner
        // width, which differs by egui's margin and shifts with zoom. Pin the
        // wrap width explicitly (world units → screen) via a custom layouter so
        // the editor and the committed box break lines identically.
        let layout_font = screen_font.clone();
        let hint_font = screen_font.clone();
        let text_color = edit
            .colors
            .map(|c| c.text.egui())
            .or_else(|| ui.visuals().override_text_color)
            .unwrap_or_else(|| ui.visuals().widgets.inactive.text_color());
        let wrap_px = edit.wrap_width.map(|w| w.get() * self.zoom.get());
        let mut wrap_at = move |ui: &egui::Ui, buf: &dyn egui::TextBuffer, _avail: f32| {
            let job = egui::text::LayoutJob::simple(
                buf.as_str().to_owned(),
                layout_font.clone(),
                text_color,
                wrap_px.unwrap_or(f32::INFINITY),
            );
            ui.fonts_mut(|f| f.layout_job(job))
        };
        let mut widget = if edit.multiline {
            egui::TextEdit::multiline(&mut *buffer)
        } else {
            egui::TextEdit::singleline(&mut *buffer)
        }
        .id(edit_id)
        .desired_width(f32::INFINITY)
        .font(screen_font);
        if edit.wrap_width.is_some() {
            widget = widget.layouter(&mut wrap_at);
        }
        if let Some(limit) = edit.char_limit {
            widget = widget.char_limit(limit);
        }
        if let Some(hint) = edit.hint {
            // Render the hint at the editor's own zoom-scaled font, not egui's
            // default body font, so it tracks the text the user will type
            // instead of shrinking to an illegible size when zoomed in.
            widget = widget.hint_text(egui::RichText::new(hint).font(hint_font));
        }
        if let Some(c) = edit.colors {
            // Blend an in-body editor with the label it replaces.
            widget = widget
                .text_color(c.text.egui())
                .background_color(c.background.egui());
        }
        let resp = ui.place(screen_rect.egui(), widget);
        // Block-edit cycle editors keep Tab and Escape for themselves. egui's
        // focus system moves focus on Tab (and clears it on Escape) at the
        // *start* of the frame unless the focused widget's filter claims them
        // — so consuming them after the fact is too late. Claim both here so
        // the cycle drives them. (The editor never inserts a tab: it reads
        // events with its own default filter, which still excludes Tab.)
        if edit.tab_cycle {
            ui.memory_mut(|m| {
                m.set_focus_lock_filter(
                    edit_id,
                    egui::EventFilter {
                        tab: true,
                        escape: true,
                        ..Default::default()
                    },
                );
            });
        }
        // Auto-focus an editor the first frame it appears so the user can
        // type immediately (e.g. right after creating a text box) without a
        // separate click into the field.
        if self.last_edit_id != Some(edit_id) {
            resp.request_focus();
            if edit.tab_cycle || edit.select_all_on_focus {
                // Highlight the whole field so typing replaces it (and each
                // tab-cycle step lands selected).
                let mut state =
                    egui::text_edit::TextEditState::load(ui.ctx(), edit_id).unwrap_or_default();
                let chars = buffer.chars().count();
                state
                    .cursor
                    .set_char_range(Some(egui::text::CCursorRange::two(
                        egui::text::CCursor::new(0),
                        egui::text::CCursor::new(chars),
                    )));
                state.store(ui.ctx(), edit_id);
            }
            self.last_edit_id = Some(edit_id);
        }
        // Read the Tab/Escape the cycle editor claimed above (consume so they
        // don't leak to other widgets), to feed the tool next frame.
        let (tab, escape) = if edit.tab_cycle && resp.has_focus() {
            ui.input_mut(|i| {
                (
                    i.consume_key(egui::Modifiers::NONE, egui::Key::Tab),
                    i.consume_key(egui::Modifiers::NONE, egui::Key::Escape),
                )
            })
        } else {
            (false, false)
        };
        EditorFeedback {
            lost_focus: resp.lost_focus(),
            enter: resp.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)),
            tab,
            escape,
        }
    }
}

/// The canvas frame between deciding the camera and painting under it.
///
/// A fit-to-content framing has to be measured from a render, and the
/// measuring recorder ([`Extent`](blockworx_paint::Extent)) draws nothing — so the
/// measurement belongs *in* the frame it reframes, ahead of the grid, the
/// interaction, and the tool's passes. [`Self::paint`] consumes the handle,
/// so a framing can never arrive after the frame it would have moved.
pub struct Canvas<'a> {
    view: &'a mut View,
    ui: &'a mut egui::Ui,
    palette: Palette,
    chrome: CanvasChrome,
    rect: Rect,
    response: egui::Response,
    pan: Camera,
}

impl Canvas<'_> {
    /// Frame the view on what `measure` reports through a painter carrying
    /// this frame's transform. Its clip rect holds nothing, so a pass that
    /// draws by mistake still cannot mark the frame.
    pub fn fit_to(&mut self, measure: impl FnOnce(&mut Painter) -> Option<Rect>) {
        let mut painter = Painter::new(
            self.ui.painter().with_clip_rect(Rect::NOTHING.egui()),
            self.rect.min,
            self.view.zoom,
            self.view.translation,
            self.palette.clone(),
            self.view.images.clone(),
            self.view.icons.clone(),
        );
        if let Some(content) = measure(&mut painter) {
            self.view.fit_content(content);
        }
    }

    /// Paint the frame: the grid, then `f` with this frame's interaction
    /// (positions in world space) and a world-space-aware painter.
    pub fn paint<F>(self, f: F)
    where
        F: FnOnce(Interaction, &mut Painter),
    {
        let Canvas {
            view,
            ui,
            palette,
            chrome,
            rect,
            response,
            pan,
        } = self;
        let origin = rect.min;
        let egui_painter = ui.painter().with_clip_rect(rect.egui());
        view.draw_grid(&egui_painter, rect, chrome);

        // Bundle mouse event + keyboard flags into a single Interaction value
        let mut interaction = compute_interaction(
            &response,
            |p| view.screen_to_world(origin, p),
            view.zoom,
            ui,
        );
        if let Some(Event::DragStarted { pos }) = interaction.event.as_mut()
            && let Some(last) = view.last_mouse_down
        {
            *pos = view.screen_to_world(origin, last);
        }

        if pan == Camera::Moving {
            if matches!(
                interaction.event,
                Some(
                    Event::DragStarted { .. } | Event::Dragging { .. } | Event::DragStopped { .. }
                ),
            ) {
                interaction.event = None;
            }
            // A key-pan holds the primary button down, which would otherwise arm
            // the press-and-hold affordances (route starts, new-pin markers).
            interaction.press = None;
        }

        std::mem::take(&mut view.editor_feedback).merge_into(&mut interaction);

        // Hand off to the caller's drawing closure
        let mut painter = Painter::new(
            egui_painter,
            origin,
            view.zoom,
            view.translation,
            palette,
            view.images.clone(),
            view.icons.clone(),
        );
        f(interaction, &mut painter);

        // An armed or in-progress pan owns the cursor, so it is set after the
        // tool's own choice — the app applies the painter's last word.
        if pan == Camera::Moving {
            painter.set_cursor(Cursor::Grabbing);
        } else if view.hovered && pan_key_held(ui) {
            painter.set_cursor(Cursor::Grab);
        }

        view.editor_feedback = view.render_pending_edit(ui, &mut painter);
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use blockworx_paint::{EditId, EditText, Font};

    /// Zooming about a point leaves the world under it where it was — that is
    /// what "zoom about the cursor" means, and what the wheel, pinch, and the
    /// keyboard steps all share.
    #[test]
    fn a_zoom_step_holds_the_world_under_its_anchor() {
        let mut view = View::new();
        view.viewport = Rect::from_min_size(pos2(30.0, 20.0), Vec2::new(800.0, 600.0));
        view.translation = Vec2::new(17.0, -9.0);
        let anchor = pos2(240.0, 380.0);
        let origin = view.viewport.min;
        let before = view.screen_to_world(origin, anchor);

        view.zoom_step(ZoomStep::In, Some(anchor));
        assert!(
            view.zoom > Zoom::unity(),
            "zooming in should raise the zoom"
        );
        let after = view.screen_to_world(origin, anchor);
        assert!(
            before.distance(after) < 0.01,
            "the world under the cursor moved: {before:?} -> {after:?}"
        );

        // Out again returns to where it started (the step factors are inverses).
        view.zoom_step(ZoomStep::Out, Some(anchor));
        assert!((view.zoom.get() - 1.0).abs() < 1e-5, "{:?}", view.zoom);
    }

    /// With the pointer off the canvas the step falls back to the viewport
    /// center, so a keyboard zoom always has an anchor.
    #[test]
    fn a_zoom_step_without_a_pointer_uses_the_viewport_center() {
        let mut view = View::new();
        view.viewport = Rect::from_min_size(pos2(0.0, 0.0), Vec2::new(800.0, 600.0));
        let origin = view.viewport.min;
        let center = view.viewport.center();
        let before = view.screen_to_world(origin, center);
        // A pointer outside the canvas is ignored, like no pointer at all.
        view.zoom_step(ZoomStep::In, Some(pos2(-50.0, -50.0)));
        assert!(before.distance(view.screen_to_world(origin, center)) < 0.01);
    }

    /// The three answers [`View::bring_into_view`] gives, in the order it
    /// prefers them: nothing at all, a pan, and — only for content that
    /// cannot fit at this zoom — a reframing.
    #[test]
    fn bringing_content_into_view_moves_as_little_as_it_can() {
        let settled = |view: &mut View| {
            if let Some((zoom, translation)) = view.target_view.take() {
                view.zoom = zoom;
                view.translation = translation;
            }
            view.visible_world_rect()
        };
        let mut view = View::new();
        view.viewport = Rect::from_min_size(Pos2::ZERO, Vec2::new(800.0, 600.0));
        let visible = view.visible_world_rect();
        assert!(
            visible.width() > 0.0 && visible.height() > 0.0,
            "precondition: the view shows something to be outside of",
        );

        let inside = Rect::from_min_size(pos2(100.0, 100.0), Vec2::splat(50.0));
        assert!(visible.contains_rect(inside), "precondition: already shown");
        view.bring_into_view(inside, Framing::Animated);
        assert!(
            view.target_view.is_none(),
            "content already in view moved the camera",
        );

        let beside = Rect::from_min_size(pos2(900.0, 100.0), Vec2::splat(50.0));
        assert!(
            !visible.contains_rect(beside) && beside.width() < visible.width(),
            "precondition: outside the view, and small enough to pan to",
        );
        let zoom_before = view.zoom.get();
        view.bring_into_view(beside, Framing::Animated);
        assert_eq!(
            view.target_view.expect("the camera moves").0.get(),
            zoom_before,
            "a pan must not touch the zoom",
        );
        assert!(settled(&mut view).contains_rect(beside));

        let mut view = View::new();
        view.viewport = Rect::from_min_size(Pos2::ZERO, Vec2::new(800.0, 600.0));
        let huge = Rect::from_min_size(pos2(400.0, 0.0), Vec2::new(2000.0, 300.0));
        assert!(
            huge.width() > view.visible_world_rect().width(),
            "precondition: no pan can hold this at the current zoom",
        );
        view.bring_into_view(huge, Framing::Animated);
        assert!(
            view.target_view.expect("the camera moves").0.get() < view.zoom.get(),
            "content too wide for the view must be zoomed out to",
        );
        assert!(settled(&mut view).contains_rect(huge));
    }

    /// A double-click fit keeps a [`FIT_BORDER_CELLS`] gutter around the
    /// content and never magnifies past [`FRAME_MAX_ZOOM`].
    #[test]
    fn a_content_fit_leaves_a_border_and_caps_the_zoom() {
        let mut view = View::new();
        view.viewport = Rect::from_min_size(Pos2::ZERO, Vec2::new(800.0, 600.0));
        // Wide content: the fit is bound by the content, not the cap, so the
        // gutter is what decides where its edges land.
        let content = Rect::from_min_size(pos2(100.0, 100.0), Vec2::new(1600.0, 400.0));
        view.fit_content(content);
        assert!(
            view.zoom.get() < FRAME_MAX_ZOOM,
            "the cap should not bind here"
        );
        let origin = view.viewport.min;
        let left = view.world_to_screen(origin, content.min).x;
        let right = view.world_to_screen(origin, content.max).x;
        let gutter = FIT_BORDER_CELLS * GRID_SIZE * view.zoom.get();
        assert!(
            left - view.viewport.left() >= gutter - 0.5,
            "content starts {left} with only {} of gutter",
            left - view.viewport.left()
        );
        assert!(view.viewport.right() - right >= gutter - 0.5);

        // A nearly empty level would fit at a huge zoom; the cap holds it.
        view.fit_content(Rect::from_min_size(pos2(0.0, 0.0), Vec2::new(10.0, 10.0)));
        assert_eq!(view.zoom, Zoom::new(FRAME_MAX_ZOOM));
    }

    #[test]
    fn focus_zoom_caps_small_content_but_fit_zooms_in_further() {
        let viewport = Vec2::new(800.0, 600.0);
        let tiny = Vec2::new(10.0, 10.0);
        let focus_cap = Zoom::new(FRAME_MAX_ZOOM);
        // A tiny block would fit at a huge zoom; focus_on caps it.
        assert_eq!(frame_zoom(viewport, tiny, focus_cap), focus_cap);
        // fit_to_rect's higher cap lets the same block zoom in further.
        assert!(frame_zoom(viewport, tiny, Zoom::max_value()) > focus_cap);
    }

    /// One frame of the canvas, fed `events`, returning the interaction the
    /// drawing closure saw.
    fn frame(ctx: &egui::Context, view: &mut View, events: Vec<egui::Event>) -> Option<Event> {
        let screen = Rect::from_min_size(Pos2::ZERO, Vec2::new(800.0, 600.0));
        let input = egui::RawInput {
            screen_rect: Some(screen.egui()),
            events,
            ..Default::default()
        };
        let mut seen = None;
        let chrome = CanvasChrome {
            background: Color::BLACK,
            grid: Color::GRAY,
        };
        ctx.run_ui(input, |ui| {
            view.begin(ui, Palette::tokyo_night_moon(), chrome)
                .paint(|interaction, _painter| {
                    seen = interaction.event;
                });
        })
        .drop_without_applying_deltas();
        seen
    }

    fn key_down(key: egui::Key) -> egui::Event {
        egui::Event::Key {
            key,
            physical_key: None,
            pressed: true,
            repeat: false,
            modifiers: egui::Modifiers::default(),
        }
    }

    fn key_up(key: egui::Key) -> egui::Event {
        egui::Event::Key {
            key,
            physical_key: None,
            pressed: false,
            repeat: false,
            modifiers: egui::Modifiers::default(),
        }
    }

    /// The primary button going down at `pos` (these tests never release it —
    /// every gesture under test is judged mid-drag).
    fn press(pos: Pos2) -> egui::Event {
        egui::Event::PointerButton {
            pos: pos.egui(),
            button: PointerButton::Primary,
            pressed: true,
            modifiers: egui::Modifiers::default(),
        }
    }

    /// Space+left-drag pans (the drawing-app convention), and the tool must not
    /// also see the drag — the view consumes it.
    #[test]
    fn space_plus_left_drag_pans_instead_of_reaching_the_tool() {
        let ctx = egui::Context::default();
        let mut view = View::new();
        let start = pos2(400.0, 300.0);
        frame(&ctx, &mut view, vec![key_down(egui::Key::Space)]);
        frame(
            &ctx,
            &mut view,
            vec![egui::Event::PointerMoved(start.egui())],
        );
        frame(&ctx, &mut view, vec![press(start)]);
        let before = view.translation;
        let seen = frame(
            &ctx,
            &mut view,
            vec![egui::Event::PointerMoved(
                (start + Vec2::new(60.0, -25.0)).egui(),
            )],
        );
        assert_eq!(view.translation - before, Vec2::new(60.0, -25.0));
        assert!(
            !matches!(
                seen,
                Some(Event::DragStarted { .. } | Event::Dragging { .. })
            ),
            "the pan leaked to the tool as {seen:?}"
        );
    }

    /// The same drag without the key belongs to the tool: no pan, and the tool
    /// sees the gesture.
    #[test]
    fn a_plain_left_drag_is_left_to_the_tool() {
        let ctx = egui::Context::default();
        let mut view = View::new();
        let start = pos2(400.0, 300.0);
        frame(
            &ctx,
            &mut view,
            vec![egui::Event::PointerMoved(start.egui())],
        );
        frame(&ctx, &mut view, vec![press(start)]);
        let before = view.translation;
        let seen = frame(
            &ctx,
            &mut view,
            vec![egui::Event::PointerMoved(
                (start + Vec2::new(60.0, -25.0)).egui(),
            )],
        );
        assert_eq!(view.translation, before, "a plain drag must not pan");
        assert!(
            matches!(
                seen,
                Some(Event::DragStarted { .. } | Event::Dragging { .. })
            ),
            "the tool never saw the drag ({seen:?})"
        );
    }

    /// Releasing the key mid-drag leaves the gesture a pan: it was latched when
    /// the drag began, so no tool inherits a half-finished pan.
    #[test]
    fn releasing_the_key_mid_drag_keeps_panning() {
        let ctx = egui::Context::default();
        let mut view = View::new();
        let start = pos2(400.0, 300.0);
        frame(&ctx, &mut view, vec![key_down(egui::Key::Space)]);
        frame(
            &ctx,
            &mut view,
            vec![egui::Event::PointerMoved(start.egui())],
        );
        frame(&ctx, &mut view, vec![press(start)]);
        let mut at = start + Vec2::new(30.0, 0.0);
        frame(&ctx, &mut view, vec![egui::Event::PointerMoved(at.egui())]);
        let before = view.translation;
        at += Vec2::new(20.0, 10.0);
        let seen = frame(
            &ctx,
            &mut view,
            vec![
                key_up(egui::Key::Space),
                egui::Event::PointerMoved(at.egui()),
            ],
        );
        assert_eq!(view.translation - before, Vec2::new(20.0, 10.0));
        assert!(!matches!(seen, Some(Event::Dragging { .. })), "{seen:?}");
    }

    /// One finger's touch event. A touch screen delivers every finger; egui
    /// derives the pinch and the two-finger translation from the set.
    fn touch(id: u64, phase: egui::TouchPhase, pos: Pos2) -> egui::Event {
        egui::Event::Touch {
            device_id: egui::TouchDeviceId(0),
            id: egui::TouchId(id),
            phase,
            pos: pos.egui(),
            force: None,
        }
    }

    /// Both fingers of a two-finger gesture moving to `at`, plus the primary
    /// finger's pointer event — which is what the web backend also sends, and
    /// what a tool would read as a drag if the view didn't consume it.
    fn two_fingers(phase: egui::TouchPhase, at: [Pos2; 2]) -> Vec<egui::Event> {
        vec![
            egui::Event::PointerMoved(at[0].egui()),
            touch(0, phase, at[0]),
            touch(1, phase, at[1]),
        ]
    }

    /// Put two fingers down on `at` and hold them there for one frame. The
    /// leading empty frame gives egui the canvas rect to hit-test the press
    /// against; adding a finger makes the touch averages jump, so egui withholds
    /// a delta until the frame after that.
    fn start_two_finger_gesture(ctx: &egui::Context, view: &mut View, at: [Pos2; 2]) {
        frame(ctx, view, Vec::new());
        let mut down = two_fingers(egui::TouchPhase::Start, at);
        down.push(press(at[0]));
        frame(ctx, view, down);
        frame(ctx, view, two_fingers(egui::TouchPhase::Move, at));
    }

    /// Two fingers pan the canvas. This is the only pan a touch screen has —
    /// there is no wheel, no middle button, and no space bar — and egui reports
    /// it *only* through `multi_touch`: a touch drag leaves `smooth_scroll_delta`
    /// at zero, so a view that reads scroll alone never moves.
    #[test]
    fn two_fingers_pan_the_canvas() {
        let ctx = egui::Context::default();
        let mut view = View::new();
        let start = [pos2(360.0, 300.0), pos2(440.0, 300.0)];
        let step = Vec2::new(20.0, -12.0);

        start_two_finger_gesture(&ctx, &mut view, start);
        frame(
            &ctx,
            &mut view,
            two_fingers(egui::TouchPhase::Move, start.map(|p| p + step)),
        );
        let before = view.translation;
        let zoom_before = view.zoom;
        let seen = frame(
            &ctx,
            &mut view,
            two_fingers(egui::TouchPhase::Move, start.map(|p| p + step * 2.0)),
        );

        assert_eq!(
            view.translation - before,
            step,
            "the canvas did not follow the fingers"
        );
        assert_eq!(
            view.zoom, zoom_before,
            "the fingers held their spacing, so nothing should have zoomed"
        );
        assert!(
            !matches!(
                seen,
                Some(Event::DragStarted { .. } | Event::Dragging { .. })
            ),
            "the primary finger reached the tool as a drag ({seen:?})"
        );
    }

    /// Spreading the fingers zooms about the gesture's own center, holding the
    /// world under it — the pinch counterpart of the wheel's zoom-about-cursor.
    #[test]
    fn pinching_zooms_about_the_gesture_center() {
        let ctx = egui::Context::default();
        let mut view = View::new();
        let center = pos2(400.0, 300.0);
        let reach = Vec2::new(40.0, 0.0);
        let start = [center - reach, center + reach];

        start_two_finger_gesture(&ctx, &mut view, start);
        let origin = view.viewport.min;
        let world_before = view.screen_to_world(origin, center);

        frame(
            &ctx,
            &mut view,
            two_fingers(
                egui::TouchPhase::Move,
                [center - reach * 2.0, center + reach * 2.0],
            ),
        );

        assert!(
            view.zoom.get() > 1.5,
            "spreading the fingers should have doubled the zoom, got {:?}",
            view.zoom
        );
        let world_after = view.screen_to_world(origin, center);
        assert!(
            world_before.distance(world_after) < 0.01,
            "the world under the pinch moved: {world_before:?} -> {world_after:?}"
        );
    }

    /// Lifting one of two fingers must not hand the remaining one to a tool: the
    /// gesture owns the canvas until the last finger leaves.
    #[test]
    fn the_last_finger_of_a_pan_never_becomes_a_tool_drag() {
        let ctx = egui::Context::default();
        let mut view = View::new();
        let start = [pos2(360.0, 300.0), pos2(440.0, 300.0)];
        let step = Vec2::new(25.0, 0.0);

        start_two_finger_gesture(&ctx, &mut view, start);
        frame(
            &ctx,
            &mut view,
            two_fingers(egui::TouchPhase::Move, start.map(|p| p + step)),
        );
        // Second finger up; the first keeps sliding.
        frame(
            &ctx,
            &mut view,
            vec![touch(1, egui::TouchPhase::End, start[1] + step)],
        );
        let seen = frame(
            &ctx,
            &mut view,
            vec![
                egui::Event::PointerMoved((start[0] + step * 2.0).egui()),
                touch(0, egui::TouchPhase::Move, start[0] + step * 2.0),
            ],
        );
        assert!(
            !matches!(
                seen,
                Some(Event::DragStarted { .. } | Event::Dragging { .. })
            ),
            "the trailing finger reached the tool as a drag ({seen:?})"
        );

        // Once every finger is up the canvas is the tool's again.
        frame(
            &ctx,
            &mut view,
            vec![touch(0, egui::TouchPhase::End, start[0] + step * 2.0)],
        );
        assert!(!view.touch_pans, "the gesture latch outlived the gesture");
    }

    /// An open in-place editor must not hammer repaints. On the desktop a
    /// repaint storm is a warm fan; in a browser tab on a tablet it is an app
    /// that stops answering, and the editor is the one thing there that cannot
    /// be dismissed without a keyboard.
    #[test]
    fn an_open_editor_settles() {
        let buffer = Rc::new(RefCell::new(String::from("Amplifier")));
        let mut view = View::new();
        let chrome = CanvasChrome {
            background: Color::BLACK,
            grid: Color::GRAY,
        };
        let settle = crate::tools::settle::probe(30, |ui| {
            // The caret's own blink would otherwise vary the shape count; it is
            // a timed wake, not the hammering this is looking for.
            ui.style_mut().visuals.text_cursor.blink = false;
            view.begin(ui, Palette::tokyo_night_moon(), chrome)
                .paint(|_, painter| {
                    painter.set_edit_text(EditText {
                        position: Rect::from_min_size(pos2(100.0, 100.0), Vec2::new(120.0, 20.0)),
                        buffer: Rc::clone(&buffer),
                        font: Font::proportional(14.0),
                        id: EditId::of("settle_title_edit"),
                        multiline: false,
                        char_limit: Some(crate::grid::MAX_LABEL_CHARS),
                        tab_cycle: true,
                        select_all_on_focus: false,
                        hint: None,
                        colors: None,
                        wrap_width: None,
                    });
                });
        });
        crate::tools::settle::assert_settles(&settle, 8);
    }

    #[test]
    fn frame_zoom_clamps_huge_content_to_the_floor() {
        let viewport = Vec2::new(800.0, 600.0);
        let huge = Vec2::new(100_000.0, 100_000.0);
        assert_eq!(
            frame_zoom(viewport, huge, Zoom::max_value()),
            Zoom::min_value()
        );
    }
}