GitCorner

Code

ossartcraftlightcraft🌐
5a24289898fd
use super::geometry::CanvasMap;
use super::{
    Color32, DevelopSettings, Gesture, LightcraftApp, MaskShape, Point, Pos2, Rect, Sense, Stroke, StrokeKind, Tokens, ToolOverlay, json, pos2,
    register, vec2,
};

/// What the user did to a face box this frame.
pub(super) enum RegionEdit {
    /// The × was clicked.
    Remove(usize),
    /// A handle drag ended: the region's new box (normalized, upright frame).
    Resize(usize, lightcraft_geom::Rect),
    /// A name was typed or picked for the face.
    Name(usize, String),
    /// The name box's offer to set up face recognition was pressed.
    SetUp,
}

/// Handles of a box: (x, y) as fractions of its width and height, and the cursor they show.
const REGION_HANDLES: [(f32, f32, egui::CursorIcon); 8] = [
    (0.0, 0.0, egui::CursorIcon::ResizeNwSe),
    (0.5, 0.0, egui::CursorIcon::ResizeVertical),
    (1.0, 0.0, egui::CursorIcon::ResizeNeSw),
    (1.0, 0.5, egui::CursorIcon::ResizeHorizontal),
    (1.0, 1.0, egui::CursorIcon::ResizeNwSe),
    (0.5, 1.0, egui::CursorIcon::ResizeVertical),
    (0.0, 1.0, egui::CursorIcon::ResizeNeSw),
    (0.0, 0.5, egui::CursorIcon::ResizeHorizontal),
];

/// Face/pet/focus regions read from XMP (MWG-RS), drawn as boxes over the photo. Hovering a box shows
/// a × in its corner and eight resize handles, and dragging its body moves it (not under a tool that
/// draws on the photo). A drag previews the new box live and is reported once,
/// on release (one undo step); the × reports the region to remove. Both are catalog-only edits:
/// LightCraft doesn't write regions to XMP. Regions are stored on the upright (EXIF-oriented) photo;
/// `orient` is the user's Rotate / Flip on top of it, which the loupe's normalized frame includes.
/// What the face/pet/focus regions of a photo are drawn from.
pub(super) struct RegionContext<'a> {
    pub photo: &'a lightcraft_catalog::Photo,
    /// the user's Rotate / Flip on top of the upright photo
    pub orient: lightcraft_geom::Orientation,
    pub hints: Option<&'a crate::panels::faces::Hints>,
    /// the names to offer when a region is named
    pub people: &'a [String],
    pub setup: crate::panels::faces::Setup,
    /// Dragging a box's body moves it: not while a tool that works on the photo owns the drag.
    pub movable: bool,
}

/// Dragging the body of a box moves it. It is laid out before the handles and the × so they win an
/// overlapping press. The press point and the box at press time are remembered, so the box follows the
/// pointer from where it was grabbed. The move is reported on release, unless the box ends where it began.
fn region_body_drag(
    ui: &egui::Ui,
    map: &CanvasMap,
    rect: Rect,
    (index, norm): (usize, lightcraft_geom::Rect),
    orient: lightcraft_geom::Orientation,
    drag_key: egui::Id,
) -> Option<RegionEdit> {
    let body_key = egui::Id::unique(("region-body", index));
    let body_resp = ui.interact(rect, body_key, Sense::drag());
    if body_resp.drag_started() {
        let press = ui.input(|i| i.pointer.press_origin()).unwrap_or(body_resp.interact_pointer_pos().unwrap_or(rect.center()));
        let start = map.norm(press);
        ui.data_mut(|d| d.insert_temp(body_key, (start, norm)));
    }
    // (the release frame reports `dragged()` too, so the last position is taken before the stop)
    if body_resp.dragged() || body_resp.drag_stopped() {
        let pp = body_resp.interact_pointer_pos();
        let shown = ui.data(|d| d.get_temp::<(Point, lightcraft_geom::Rect)>(body_key));
        if let (Some(pp), Some((start, shown))) = (pp, shown) {
            let now = map.norm(pp);
            let (w, h) = (shown.x1 - shown.x0, shown.y1 - shown.y0);
            let (x0, y0) = ((shown.x0 + now.x - start.x).clamp(0.0, (1.0 - w).max(0.0)), (shown.y0 + now.y - start.y).clamp(0.0, (1.0 - h).max(0.0)));
            let moved = lightcraft_geom::Rect { x0, y0, x1: x0 + w, y1: y0 + h };
            if moved == shown {
                ui.data_mut(|d| d.remove_temp::<(usize, lightcraft_geom::Rect)>(drag_key));
            } else {
                ui.data_mut(|d| d.insert_temp(drag_key, (index, orient.inverse().map_norm_rect(moved))));
            }
            ui.ctx().request_repaint();
        }
    }
    if !body_resp.drag_stopped() {
        return None;
    }
    let edit = ui.data(|d| d.get_temp::<(usize, lightcraft_geom::Rect)>(drag_key)).map(|(i, new)| RegionEdit::Resize(i, new));
    ui.data_mut(|d| d.remove_temp::<(usize, lightcraft_geom::Rect)>(drag_key));
    ui.data_mut(|d| d.remove_temp::<(Point, lightcraft_geom::Rect)>(body_key));
    edit
}

pub(super) fn region_overlay(
    ui: &egui::Ui,
    p: &egui::Painter,
    map: &CanvasMap,
    regions: &RegionContext,
    editing: &mut Option<crate::state::NameEdit>,
) -> Option<RegionEdit> {
    let RegionContext { photo, orient, hints, people, setup, movable } = *regions;
    let t = Tokens::get(p.ctx());
    let clip = p.clip_rect();
    let pointer = ui.input(|i| i.pointer.hover_pos());
    // the box being dragged: (region index, its box so far)
    let drag_key = egui::Id::unique("region-drag");
    let live: Option<(usize, lightcraft_geom::Rect)> = ui.data(|d| d.get_temp(drag_key));
    let mut edit = None;
    for (index, r) in photo.meta.regions.iter().enumerate() {
        let dragging = live.filter(|(i, _)| *i == index);
        let norm = orient.map_norm_rect(dragging.map_or(r.rect, |(_, n)| n));
        let rect = Rect::from_two_pos(map.screen(Point::new(norm.x0, norm.y0)), map.screen(Point::new(norm.x1, norm.y1)));
        // white with a black keyline just outside it, so the box shows on any background
        p.rect_stroke(rect.expand(1.0), 0.0, Stroke::new(1.0, Color32::from_black_alpha(190)), StrokeKind::Outside);
        p.rect_stroke(rect, 0.0, Stroke::new(1.0, Color32::WHITE), StrokeKind::Outside);
        if movable && let Some(moved) = region_body_drag(ui, map, rect, (index, norm), orient, drag_key) {
            edit = Some(moved);
        }
        if dragging.is_some() || (live.is_none() && pointer.is_some_and(|h| rect.expand(8.0).contains(h))) {
            for (h, (fx, fy, cursor)) in REGION_HANDLES.iter().enumerate() {
                let c = pos2(rect.left() + fx * rect.width(), rect.top() + fy * rect.height());
                let resp = ui.interact(Rect::from_center_size(c, vec2(14.0, 14.0)), egui::Id::unique(("region-handle", index, h)), Sense::drag());
                crate::widgets::announce(&resp, crate::i18n::tr("Resize region"));
                if resp.hovered() || resp.dragged() {
                    ui.ctx().set_cursor_icon(*cursor);
                }
                let sq = Rect::from_center_size(c, vec2(7.0, 7.0));
                p.rect_filled(sq, 0.0, if resp.hovered() || resp.dragged() { Color32::from_rgb(120, 190, 255) } else { Color32::WHITE });
                p.rect_stroke(sq, 0.0, Stroke::new(1.0, Color32::from_black_alpha(220)), StrokeKind::Outside);
                if resp.dragged()
                    && let Some(pp) = resp.interact_pointer_pos()
                {
                    // move the dragged edge(s) to the pointer, never closer than 12 px to the opposite one
                    let mut n = rect;
                    if *fx == 0.0 {
                        n.min.x = pp.x.min(n.max.x - 12.0);
                    } else if *fx == 1.0 {
                        n.max.x = pp.x.max(n.min.x + 12.0);
                    }
                    if *fy == 0.0 {
                        n.min.y = pp.y.min(n.max.y - 12.0);
                    } else if *fy == 1.0 {
                        n.max.y = pp.y.max(n.min.y + 12.0);
                    }
                    let (a, b) = (map.norm(n.min), map.norm(n.max));
                    let shown = lightcraft_geom::Rect {
                        x0: a.x.min(b.x).clamp(0.0, 1.0),
                        y0: a.y.min(b.y).clamp(0.0, 1.0),
                        x1: a.x.max(b.x).clamp(0.0, 1.0),
                        y1: a.y.max(b.y).clamp(0.0, 1.0),
                    };
                    // back to the upright frame the region is stored in
                    let new = orient.inverse().map_norm_rect(shown);
                    ui.data_mut(|d| d.insert_temp(drag_key, (index, new)));
                    ui.ctx().request_repaint();
                }
                if resp.drag_stopped() {
                    if let Some((i, new)) = ui.data(|d| d.get_temp::<(usize, lightcraft_geom::Rect)>(drag_key)) {
                        edit = Some(RegionEdit::Resize(i, new));
                    }
                    ui.data_mut(|d| d.remove_temp::<(usize, lightcraft_geom::Rect)>(drag_key));
                }
            }
        }
        if dragging.is_none() && live.is_none() && pointer.is_some_and(|h| rect.expand(3.0).contains(h)) {
            let xr = Rect::from_center_size(pos2(rect.right() - 13.0, rect.top() + 13.0), vec2(16.0, 16.0));
            let resp = ui.interact(xr, egui::Id::unique(("region-x", index)), Sense::click());
            crate::widgets::announce(&resp, crate::i18n::tr("Remove region"));
            register(ui, format!("regionRemove:{index}"), xr);
            let fill = Color32::from_black_alpha(if resp.hovered() { 235 } else { 190 });
            p.rect_filled(xr, 2.0, fill);
            p.rect_stroke(xr, 2.0, Stroke::new(1.0, Color32::from_white_alpha(120)), StrokeKind::Inside);
            let (c, m) = (xr.center(), 3.5);
            let cross = Stroke::new(1.4, if resp.hovered() { Color32::WHITE } else { Color32::from_gray(210) });
            p.line_segment([c - vec2(m, m), c + vec2(m, m)], cross);
            p.line_segment([c - vec2(m, -m), c + vec2(m, -m)], cross);
            if resp.on_hover_text(crate::i18n::tr("Remove this face box (undo with Edit ▸ Undo)")).clicked() {
                edit = Some(RegionEdit::Remove(index));
            }
        }
        // what the label says: the name, a guess to confirm ("Jane Doe?"), or on hover an invitation to name the face
        let is_face = r.kind == lightcraft_meta::RegionKind::Face;
        let hint = hints.and_then(|h| h.by_index.get(&index));
        let hovered = pointer.is_some_and(|h| rect.expand(3.0).contains(h));
        let editing_this = editing.as_ref().is_some_and(|e| e.photo == photo.id.0 && e.index == index);
        let (text, text_color, fill_alpha, invitation) = match (&r.name, hint.and_then(|h| h.suggestion.as_ref())) {
            (Some(n), _) => (n.clone(), Color32::from_gray(225), 235, false),
            (None, Some((n, _))) if is_face => (format!("{n}?"), Color32::from_gray(185), 200, false),
            (None, None) if is_face && live.is_none() => ("Add name".to_string(), Color32::from_gray(150), 190, true),
            _ => continue,
        };
        // the name in a dark label with a caret, centred above the box (below it when there is no room)
        let name = &text;
        let g = p.layout_no_wrap(name.clone(), t.font(13.0), text_color);
        let (pad, caret) = (vec2(14.0, 7.0), 5.0);
        let size = g.size() + pad * 2.0;
        let above = rect.top() - caret - size.y >= clip.top();
        let (top, tip, base) = if above {
            (rect.top() - caret - size.y, rect.top() - 1.0, rect.top() - caret - 1.0)
        } else {
            (rect.bottom() + caret, rect.bottom() + 1.0, rect.bottom() + caret + 1.0)
        };
        let left = (rect.center().x - size.x / 2.0).clamp(clip.left(), (clip.right() - size.x).max(clip.left()));
        let label = Rect::from_min_size(pos2(left, top), size);
        // the invitation shows while the pointer is on the box *or on the label* (and the gap between), so it can be reached
        if invitation && !(hovered || editing_this || pointer.is_some_and(|h| rect.union(label).expand(3.0).contains(h))) {
            continue;
        }
        let fill = Color32::from_rgba_unmultiplied(56, 56, 56, fill_alpha);
        p.rect_filled(label, 3.0, fill);
        p.rect_stroke(label, 3.0, Stroke::new(1.0, Color32::from_black_alpha(160)), StrokeKind::Inside);
        let cx = rect.center().x.clamp(label.left() + caret + 4.0, label.right() - caret - 4.0);
        p.add(egui::Shape::convex_polygon(vec![pos2(cx - caret, base), pos2(cx + caret, base), pos2(cx, tip)], fill, Stroke::NONE));
        p.galley(label.min + pad, g, text_color);
        if is_face && live.is_none() {
            // a click on the label opens the name box, filled with the name or the guess
            let resp = ui.interact(label, egui::Id::unique(("region-label", index)), Sense::click());
            crate::widgets::announce(&resp, crate::i18n::tr("Click to name this face"));
            register(ui, format!("regionLabel:{index}"), label);
            if resp.on_hover_text(crate::i18n::tr("Click to name this face")).clicked() {
                let start = r.name.clone().or_else(|| hint.and_then(|h| h.suggestion.as_ref().map(|(n, _)| n.clone()))).unwrap_or_default();
                *editing = Some(crate::state::NameEdit { photo: photo.id.0, index, text: start, fresh: true });
            }
        }
        if editing_this && let Some(e) = editing.as_mut() {
            let candidates = hint.map(|h| h.candidates.as_slice()).unwrap_or(&[]);
            match crate::panels::faces::name_editor(ui.ctx(), pos2(label.left(), rect.bottom() + 8.0), e, candidates, people, setup) {
                crate::panels::faces::Editor::Submit(name) => edit = Some(RegionEdit::Name(index, name)),
                crate::panels::faces::Editor::Setup => edit = Some(RegionEdit::SetUp),
                crate::panels::faces::Editor::Cancel => *editing = None,
                crate::panels::faces::Editor::Open => {}
            }
        }
    }
    edit
}

// ------------------------------------------------------------------------ masks

/// Where a mask component's pin sits (normalized), for shapes that have a place on the photo: an
/// Object at its first click, a Describe mask on what its segmentation found (issue #3049).
pub(crate) fn component_pin(shape: &MaskShape) -> Option<Point> {
    match shape {
        MaskShape::Radial { center, .. } => Some(*center),
        MaskShape::Linear { start, end } => Some(Point::new((start.x + end.x) / 2.0, (start.y + end.y) / 2.0)),
        MaskShape::Brush { strokes } => strokes.iter().find(|s| !s.erase).and_then(|s| s.points.first()).copied(),
        MaskShape::Object { hint, seg, .. } => hint.first().copied().or_else(|| seg.as_ref().and_then(seg_center)),
        MaskShape::Prompt { seg, .. } => seg.as_ref().and_then(seg_center),
        _ => None,
    }
}

/// The middle of what a segmentation selects (the mean of its cells inside the mask), else of the
/// part of the image it covers; `None` when it is damaged.
fn seg_center(seg: &lightcraft_develop::SegMask) -> Option<Point> {
    let [x0, y0, x1, y1] = seg.bounds()?;
    let logits = seg.logits()?;
    let side = seg.side as usize;
    let (mut sx, mut sy, mut n) = (0.0, 0.0, 0usize);
    for (i, _) in logits.iter().enumerate().filter(|(_, l)| **l > 0.0) {
        sx += (i % side) as f64 + 0.5;
        sy += (i / side) as f64 + 0.5;
        n += 1;
    }
    let cells = n as f64 * side as f64;
    let (u, v) = if n == 0 { (0.5, 0.5) } else { (sx / cells, sy / cells) };
    Some(Point::new(x0 + u * (x1 - x0), y0 + v * (y1 - y0)))
}

/// `shape` moved by `dn` (normalized); `handle` 1/2 = a linear gradient's start/end set to `at`.
fn moved_shape(shape: &MaskShape, handle: u8, dn: Point, at: Point, map: &CanvasMap, alt: bool) -> MaskShape {
    let mv = |p: Point| Point::new(p.x + dn.x, p.y + dn.y);
    match shape.clone() {
        MaskShape::Radial { center, rx, ry, angle, feather, invert } => match handle {
            1 | 3 => {
                let l = frame_long_norm(map);
                let dx = (at.x - center.x) / l.0;
                let dy = (at.y - center.y) / l.1;
                let (s, co) = angle.to_radians().sin_cos();
                let new_rx = (dx * co + dy * s).abs().max(0.01);
                let mut new_ry = ry;
                if alt {
                    new_ry = ry * (new_rx / rx.max(0.01));
                }
                if (new_rx - new_ry).abs() / new_rx.max(new_ry) < 0.05 {
                    new_ry = new_rx;
                }
                MaskShape::Radial { center, rx: new_rx, ry: new_ry, angle, feather, invert }
            }
            2 | 4 => {
                let l = frame_long_norm(map);
                let dx = (at.x - center.x) / l.0;
                let dy = (at.y - center.y) / l.1;
                let (s, co) = angle.to_radians().sin_cos();
                let new_ry = (dx * (-s) + dy * co).abs().max(0.01);
                let mut new_rx = rx;
                if alt {
                    new_rx = rx * (new_ry / ry.max(0.01));
                }
                if (new_rx - new_ry).abs() / new_rx.max(new_ry) < 0.05 {
                    new_rx = new_ry;
                }
                MaskShape::Radial { center, rx: new_rx, ry: new_ry, angle, feather, invert }
            }
            5 => {
                let l = frame_long_norm(map);
                let dx = (at.x - center.x) / l.0;
                let dy = (at.y - center.y) / l.1;
                let new_angle = dy.atan2(dx).to_degrees();
                MaskShape::Radial { center, rx, ry, angle: new_angle, feather, invert }
            }
            _ => MaskShape::Radial { center: mv(center), rx, ry, angle, feather, invert },
        },
        MaskShape::Linear { start, end } => match handle {
            1 => MaskShape::Linear { start: at, end },
            2 => MaskShape::Linear { start, end: at },
            _ => MaskShape::Linear { start: mv(start), end: mv(end) },
        },
        MaskShape::Brush { mut strokes } => {
            for st in &mut strokes {
                st.points.iter_mut().for_each(|p| *p = mv(*p));
            }
            MaskShape::Brush { strokes }
        }
        s => s,
    }
}

/// Hit the geometric ellipse, independently of feather/inversion. Radii use long-edge units,
/// so undo the same scaling and rotation used to draw its outline before testing containment.
fn radial_body_contains(shape: &MaskShape, at: Point, map: &CanvasMap) -> bool {
    let MaskShape::Radial { center, rx, ry, angle, .. } = shape else { return false };
    if !rx.is_finite() || !ry.is_finite() || *rx <= 0.0 || *ry <= 0.0 {
        return false;
    }
    let l = frame_long_norm(map);
    let dx = (at.x - center.x) / l.0;
    let dy = (at.y - center.y) / l.1;
    let (s, co) = angle.to_radians().sin_cos();
    let x = (dx * co + dy * s) / rx;
    let y = (-dx * s + dy * co) / ry;
    x * x + y * y <= 1.0
}

/// Colour Range eyedropper: a click samples the colour under it for the selected mask's
/// colour range, at normalized frame coordinates (crop, rotation and zoom aware);
/// ⇧-click adds a sample (up to 5).
pub(super) fn color_range_pick(app: &mut LightcraftApp, ui: &egui::Ui, resp: &egui::Response, map: &CanvasMap) {
    if resp.clicked()
        && let Some(q) = resp.interact_pointer_pos()
    {
        let n = map.norm(q);
        let add = ui.input(|i| i.modifiers.shift);
        if let Err(e) = app.run("mask.sampleColor", json!({"x": n.x, "y": n.y, "add": add})) {
            app.toast(ui.ctx(), e);
        }
    }
}

/// The Masking tool on the photo: outlines and handles of the selected mask, a pin per mask
/// component (click selects its mask, drag moves the component), and brush painting. The mask
/// itself shows as a rendered overlay ([`view_overlay`]).
pub(super) fn mask_overlay(app: &mut LightcraftApp, ui: &mut egui::Ui, resp: &egui::Response, map: &CanvasMap, d: &DevelopSettings) {
    let active = app.session.active_mask;
    let clip = app.canvas_rect.unwrap_or(map.rect);
    let p = &ui.painter_at(clip);
    // (mask, component, handle, screen position) of everything that can be grabbed
    let mut grips: Vec<(u32, usize, u8, Pos2)> = Vec::new();
    // pins follow Show Pins and the Tool Overlay mode (Shift+H); Auto hides them while brushing
    let (mode, live) = (app.ui.tool_overlay, pins_live(app, resp, map));
    let mut pins = p.clone();
    if mode == ToolOverlay::Auto && matches!(app.gesture, Some(Gesture::Brush { .. })) {
        pins.set_invisible();
    }
    for m in &d.masks {
        let sel = Some(m.id) == active;
        // (its coordinates on the photo, or an old mask's on the corrected frame)
        let map = &map.for_mask(m.on_photo);
        // Ctrl+Shift+O (`mask_overlay_all`) shows every visible mask's region; outline each one
        // too, not just the selected mask. Handles and the rotation grip stay on the selected
        // mask so nothing else becomes draggable. The component check keeps this in step with the
        // painted region (`view_overlay` at detail.rs:1354 only covers masks with components).
        let show_outline = sel || (app.ui.mask_overlay_all && m.visible && !m.components.is_empty());
        for (ci, c) in m.components.iter().enumerate() {
            if show_outline {
                component_outline(ui, p, map, (m.id, ci), &c.shape, sel, &mut grips);
            }
            if app.ui.mask_pins
                && mode.shows(sel, live)
                && let Some(at) = component_pin(&c.shape)
            {
                let q = map.screen(at);
                pin(&pins, q, sel);
                register(ui, format!("maskPin:{}:{ci}", m.id), Rect::from_center_size(q, vec2(14.0, 14.0)));
                grips.push((m.id, ci, 0, q));
            }
        }
    }
    mask_keys(app, ui, map, d, &grips);
    object_marks(app, p, map, d, active);
    // Colour Range "Pick": the Masking panel owns the loupe's clicks (general_interaction
    // never runs while it is open), so the eyedropper is handled here too.
    if app.ui.tool == "colorRange" {
        if resp.hovered() {
            ui.ctx().set_cursor_icon(egui::CursorIcon::Crosshair);
        }
        color_range_pick(app, ui, resp, map);
        return;
    }
    if app.ui.tool == "object" {
        object_tool(app, ui, resp, map, d, &grips);
        return;
    }
    if app.ui.tool == "brush" {
        brush_tool(app, ui, resp, map, p, clip, d);
        return;
    }
    grip_gestures(app, ui, resp, map, d, &grips);
}

/// The outline of one mask component, and (on the selected mask) its grips, registered and
/// collected into `grips`.
fn component_outline(
    ui: &egui::Ui,
    p: &egui::Painter,
    map: &CanvasMap,
    at: (u32, usize),
    shape: &MaskShape,
    sel: bool,
    grips: &mut Vec<(u32, usize, u8, Pos2)>,
) {
    let (mask, ci) = at;
    let stroke_a: u8 = if sel { 230 } else { 170 };
    match shape {
        MaskShape::Radial { center, rx, ry, angle, .. } => {
            let pts: Vec<Pos2> = (0..64)
                .map(|i| {
                    let a = i as f64 / 64.0 * std::f64::consts::TAU;
                    let (s, co) = angle.to_radians().sin_cos();
                    let (x, y) = (rx * a.cos(), ry * a.sin());
                    let l = frame_long_norm(map);
                    map.screen(Point::new(center.x + (x * co - y * s) * l.0, center.y + (x * s + y * co) * l.1))
                })
                .collect();
            p.add(egui::Shape::closed_line(pts, Stroke::new(1.5, Color32::from_white_alpha(stroke_a))));

            if sel {
                let l = frame_long_norm(map);
                for (i, a_deg) in [0.0_f64, 90.0_f64, 180.0_f64, 270.0_f64].into_iter().enumerate() {
                    let a_local = a_deg.to_radians();
                    let (s, co) = angle.to_radians().sin_cos();
                    let (x, y) = (rx * a_local.cos(), ry * a_local.sin());
                    let q = map.screen(Point::new(center.x + (x * co - y * s) * l.0, center.y + (x * s + y * co) * l.1));
                    p.circle_stroke(q, 5.0, Stroke::new(1.5, Color32::WHITE));
                    register(ui, format!("maskHandle:{}:{ci}:{}", mask, i + 1), Rect::from_center_size(q, vec2(14.0, 14.0)));
                    grips.push((mask, ci, i as u8 + 1, q));
                }

                let (s, co) = angle.to_radians().sin_cos();
                let rot_r = rx + 0.08;
                let rot_q = map.screen(Point::new(center.x + (rot_r * co) * l.0, center.y + (rot_r * s) * l.1));
                let h1_q = map.screen(Point::new(center.x + (rx * co) * l.0, center.y + (rx * s) * l.1));
                p.line_segment([h1_q, rot_q], Stroke::new(1.0, Color32::from_white_alpha(200)));
                p.circle_stroke(rot_q, 4.0, Stroke::new(1.5, Color32::WHITE));
                register(ui, format!("maskHandle:{}:{ci}:5", mask), Rect::from_center_size(rot_q, vec2(14.0, 14.0)));
                grips.push((mask, ci, 5, rot_q));
            }
        }
        MaskShape::Linear { start, end } => {
            let (a, b) = (map.screen(*start), map.screen(*end));
            let (a1, a2): (u8, u8) = if sel { (230, 110) } else { (170, 80) };
            for (at, alpha) in [(*start, a1), (*end, a2)] {
                for run in linear_guide(map, *start, *end, at) {
                    p.add(egui::Shape::line(run, Stroke::new(1.0, Color32::from_white_alpha(alpha))));
                }
            }
            if sel {
                for (i, q) in [a, b].iter().enumerate() {
                    p.circle_stroke(*q, 5.0, Stroke::new(1.5, Color32::WHITE));
                    register(ui, format!("maskHandle:{}:{ci}:{i}", mask), Rect::from_center_size(*q, vec2(14.0, 14.0)));
                    grips.push((mask, ci, i as u8 + 1, *q));
                }
            }
        }
        _ => {}
    }
}

/// A linear gradient's guide through `at` (its start or end): the line at right angles to it, as
/// screen points. In a mask's coordinates on the photo, a lens or perspective warp bends and
/// turns it on screen, so it is drawn through the warp in steps; else it is a straight line.
pub(super) fn linear_guide(map: &CanvasMap, start: Point, end: Point, at: Point) -> Vec<Vec<Pos2>> {
    let (a, b) = (map.screen(start), map.screen(end));
    if !map.warped() {
        let dir = (b - a).normalized();
        let perp = vec2(-dir.y, dir.x) * 3000.0;
        let q = map.screen(at);
        return vec![vec![q - perp, q + perp]];
    }
    // in long-edge units the perpendicular is a right angle; it spans the whole photo
    let l = frame_long_norm(map);
    let d = ((end.x - start.x) / l.0, (end.y - start.y) / l.1);
    let n = d.0.hypot(d.1);
    if !(n.is_finite() && n > 1e-12) {
        return Vec::new();
    }
    let perp = (-d.1 / n * l.0, d.0 / n * l.1);
    // from where the line enters the photo to where it leaves it (with a margin), measured from
    // `at`, so a guide whose end lies off the photo still reaches it
    let pp = perp.0 * perp.0 + perp.1 * perp.1;
    let ts = [(0.0, 0.0), (1.0, 0.0), (0.0, 1.0), (1.0, 1.0)].map(|(x, y)| ((x - at.x) * perp.0 + (y - at.y) * perp.1) / pp);
    let (lo, hi) = ts.iter().fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), t| (lo.min(*t), hi.max(*t)));
    let pad = 0.1 * (hi - lo);
    let (lo, hi) = (lo - pad, hi + pad);
    if !(lo.is_finite() && hi.is_finite() && hi > lo) {
        return Vec::new();
    }
    // 48 steps across about a photo's width, at most 256
    let steps = ((hi - lo) * 16.0).ceil().clamp(48.0, 256.0) as usize;
    split_jumps(runs((0..=steps).map(|i| {
        let t = lo + (hi - lo) * i as f64 / steps as f64;
        map.try_screen(Point::new(at.x + perp.0 * t, at.y + perp.1 * t))
    })))
}

/// `runs` cut again where a step is far longer than the run's usual one: a strong warp can fold
/// the line, and a chord across the fold isn't part of it.
pub(super) fn split_jumps(runs: Vec<Vec<Pos2>>) -> Vec<Vec<Pos2>> {
    let mut out = Vec::new();
    for run in runs {
        let mut steps: Vec<f32> = run.windows(2).filter_map(|w| Some(w.first()?.distance(*w.get(1)?))).collect();
        steps.sort_by(f32::total_cmp);
        let usual = steps.get(steps.len() / 2).copied().unwrap_or(0.0);
        let limit = (8.0 * usual).max(2.0);
        let mut cur: Vec<Pos2> = Vec::new();
        for q in run {
            if cur.last().is_some_and(|p: &Pos2| p.distance(q) > limit) {
                if cur.len() >= 2 {
                    out.push(std::mem::take(&mut cur));
                }
                cur.clear();
            }
            cur.push(q);
        }
        if cur.len() >= 2 {
            out.push(cur);
        }
    }
    out
}

/// The unbroken runs (two points or more) of a sampled line whose missing samples (`None`) cut it.
pub(super) fn runs(samples: impl IntoIterator<Item = Option<Pos2>>) -> Vec<Vec<Pos2>> {
    let mut out: Vec<Vec<Pos2>> = Vec::new();
    let mut cur: Vec<Pos2> = Vec::new();
    for s in samples {
        match s {
            Some(q) => cur.push(q),
            None => {
                if cur.len() >= 2 {
                    out.push(std::mem::take(&mut cur));
                }
                cur.clear();
            }
        }
    }
    if cur.len() >= 2 {
        out.push(cur);
    }
    out
}

/// Object selections (SAM 3) of the selected mask: each click, green to include, red to exclude
/// (clicks still on their way to the model included).
fn object_marks(app: &LightcraftApp, p: &egui::Painter, map: &CanvasMap, d: &DevelopSettings, active: Option<u32>) {
    let pending = app.session.segmenter.pending_clicks().cloned();
    for m in d.masks.iter().filter(|m| Some(m.id) == active) {
        let map = &map.for_mask(m.on_photo);
        for (k, c) in m.components.iter().enumerate() {
            if let MaskShape::Object { hint, exclude, .. } = &c.shape {
                let (hint, exclude) = match pending.as_ref().filter(|q| (q.mask, q.comp) == (m.id, k)) {
                    Some(q) => (&q.hint, &q.exclude),
                    None => (hint, exclude),
                };
                for (pts, col) in [(hint, Color32::from_rgb(40, 200, 90)), (exclude, Color32::from_rgb(230, 60, 60))] {
                    for q in pts {
                        let q = map.screen(*q);
                        p.circle_filled(q, 5.0, col);
                        p.circle_stroke(q, 5.0, Stroke::new(1.5, Color32::WHITE));
                    }
                }
            }
        }
    }
}

/// The mask whose pin is under `q` (within the 10 px [`grip_gestures`] grabs at), not counting
/// the `active` mask's own pins.
fn other_pin_at(grips: &[(u32, usize, u8, Pos2)], active: Option<u32>, q: Pos2) -> Option<u32> {
    grips
        .iter()
        .filter(|g| Some(g.0) != active && g.2 == 0 && g.3.distance(q) < 10.0)
        .min_by(|a, b| a.3.distance(q).total_cmp(&b.3.distance(q)))
        .map(|g| g.0)
}

/// Whether `q` is on one of the `active` mask's own pins (within the same 10 px).
fn own_pin_at(grips: &[(u32, usize, u8, Pos2)], active: Option<u32>, q: Pos2) -> bool {
    active.is_some_and(|a| grips.iter().any(|g| g.0 == a && g.2 == 0 && g.3.distance(q) < 10.0))
}

/// Object tool: a click includes what's under it, ⌥-click leaves it out. A click on another
/// mask's pin selects that mask instead of adding a click to the selected one (issue #3049);
/// the tool then stays on only if the newly selected mask has an Object selection to refine. A
/// click on the selected mask's own pin does nothing: its first click is already there, and a
/// near-copy of it would use up one of the mask's limited Object clicks.
fn object_tool(
    app: &mut LightcraftApp,
    ui: &mut egui::Ui,
    resp: &egui::Response,
    map: &CanvasMap,
    d: &DevelopSettings,
    grips: &[(u32, usize, u8, Pos2)],
) {
    if resp.hovered() {
        ui.ctx().set_cursor_icon(egui::CursorIcon::Crosshair);
    }
    if resp.clicked()
        && let Some(q) = resp.interact_pointer_pos()
    {
        if let Some(mid) = other_pin_at(grips, app.session.active_mask, q) {
            let _ = app.run("mask.select", json!({"id": mid}));
            let has_object =
                d.masks.iter().find(|m| m.id == mid).is_some_and(|m| m.components.iter().any(|c| matches!(c.shape, MaskShape::Object { .. })));
            if !has_object {
                app.ui.tool.clear();
            }
            return;
        }
        if own_pin_at(grips, app.session.active_mask, q) {
            return;
        }
        // (a click goes into the selected mask, or a new one: in its coordinates)
        let n = map.for_mask_id(d, app.session.active_mask).norm(q);
        let exclude = ui.input(|i| i.modifiers.alt);
        match app.run_typed("mask.objectPoint", json!({"x": n.x, "y": n.y, "exclude": exclude})) {
            Ok(_) => {
                if let Some(mid) = app.session.active_mask {
                    app.ui.detail_due = Some((app.tick_now() + 1.0, mid));
                }
            }
            Err(e) => app.ai_error(ui.ctx(), e, Some(("object", "new"))),
        }
    }
}

/// Brush tool: the cursor, the stroke being painted and its commit.
fn brush_tool(
    app: &mut LightcraftApp,
    ui: &mut egui::Ui,
    resp: &egui::Response,
    map: &CanvasMap,
    p: &egui::Painter,
    clip: Rect,
    d: &DevelopSettings,
) {
    let active = app.session.active_mask;
    // the stroke goes into the selected mask (or a new one): in its coordinates
    let map = &map.for_mask_id(d, active);
    let long = (map.rect.width().max(map.rect.height())) as f64;
    let r = (app.ui.brush_size as f64 * long) as f32;
    if let Some(h) = resp.hover_pos() {
        ui.ctx().set_cursor_icon(egui::CursorIcon::None);
        p.circle_stroke(h, r, Stroke::new(1.0, Color32::WHITE));
        p.circle_stroke(h, r * (1.0 - app.ui.brush_feather / 100.0).max(0.05), Stroke::new(1.0, Color32::from_white_alpha(120)));
    }
    if let Some(q) = resp.interact_pointer_pos()
        && (resp.drag_started() || resp.dragged() || resp.clicked())
    {
        let n = map.norm(q);
        let force = if app.ui.brush_pressure { ui.input(pen_force) } else { None };
        match &mut app.gesture {
            // a held, unmoving pointer records nothing: coverage builds by passes, not time (#518)
            Some(Gesture::Brush { points, .. }) if points.last() == Some(&n) => {}
            Some(Gesture::Brush { points, pressure }) => {
                record_pressure(pressure, points.len(), force);
                points.push(n);
            }
            _ => {
                let mut pressure = Vec::new();
                record_pressure(&mut pressure, 0, force);
                app.gesture = Some(Gesture::Brush { points: vec![n], pressure });
            }
        }
    }
    // the stroke being painted (the render shows it once it's committed), with the committed
    // stroke's dab spacing, feather and flow (issue #517), tinted only when the overlay will
    // show it: with the overlay hidden (O, or a mask slider hid it) or a colour overlay at
    // opacity 0, the photo stays untinted while painting, so dodging and burning is judged on
    // the photo (issue #2549)
    use lightcraft_pipeline::MaskView;
    let colored = matches!(MaskView::parse(&app.ui.mask_overlay_mode).unwrap_or_default(), MaskView::Color | MaskView::ColorOnBw);
    // the all-masks overlay ([`view_overlay`]) shows only visible masks, and gives way to the
    // selected mask's when none has anything in it (a stroke goes into the selected mask, or a new one)
    let visible = active.and_then(|id| d.masks.iter().find(|m| m.id == id)).is_none_or(|m| m.visible);
    let all = app.ui.mask_overlay_all && (visible || d.masks.iter().any(|m| m.visible && !m.components.is_empty()));
    let shown = if all { visible } else { app.ui.mask_overlay } && !(colored && app.ui.mask_overlay_opacity <= 0.0);
    if shown && let Some(Gesture::Brush { points, pressure }) = &app.gesture {
        let screen: Vec<Pos2> = points.iter().map(|q| map.screen(*q)).collect();
        // opacity 0 only gets here in the image views, which ignore it: a fixed tint there
        let opacity = if app.ui.mask_overlay_opacity > 0.0 { app.ui.mask_overlay_opacity / 100.0 } else { 110.0 / 255.0 };
        let params = crate::brush_live::LiveParams {
            clip,
            scale: ui.ctx().pixels_per_point(),
            r,
            hard: r * (1.0 - (app.ui.brush_feather / 100.0).clamp(0.0, 1.0)),
            flow: (app.ui.brush_flow / 100.0).clamp(0.0, 1.0),
            density: 1.0,
            color: app.ui.mask_overlay_color,
            opacity: opacity.clamp(0.0, 1.0),
        };
        crate::brush_live::paint(&mut app.brush_live, ui.ctx(), p, params, &screen, pressure);
    } else {
        app.brush_live = None;
    }
    if (resp.drag_stopped() || resp.clicked())
        && let Some(Gesture::Brush { points, pressure }) = app.gesture.take()
    {
        app.brush_live = None;
        let pts: Vec<[f64; 2]> = points.iter().map(|q| [q.x, q.y]).collect();
        // holding ⌥ (Alt) paints with the other mode: Erase while adding, Add while erasing
        let (alt, shift) = resp.ctx.input(|i| (i.modifiers.alt, i.modifiers.shift));
        let erase = app.ui.brush_erase != alt;
        // a ⇧-click draws a straight line from where the last stroke ended, as in Lightroom
        let connect = shift && resp.clicked() && pts.len() == 1;
        let _ = app.run(
            "mask.brushStroke",
            json!({"points": pts, "size": app.ui.brush_size, "feather": app.ui.brush_feather, "flow": app.ui.brush_flow,
                   "erase": erase, "autoMask": app.ui.brush_auto_mask, "pressure": pressure, "connect": connect}),
        );
    }
}

/// Grabbing mask grips and component bodies: select, drag, release.
fn grip_gestures(
    app: &mut LightcraftApp,
    ui: &egui::Ui,
    resp: &egui::Response,
    map: &CanvasMap,
    d: &DevelopSettings,
    grips: &[(u32, usize, u8, Pos2)],
) {
    let active = app.session.active_mask;
    // the grip under the pointer: the selected mask's first, then the nearest
    let hit = |q: Pos2| {
        grips
            .iter()
            .filter(|g| g.3.distance(q) < 10.0)
            .min_by(|a, b| {
                (Some(a.0) != active, a.3.distance(q)).partial_cmp(&(Some(b.0) != active, b.3.distance(q))).unwrap_or(std::cmp::Ordering::Equal)
            })
            .copied()
    };
    if resp.clicked()
        && let Some(q) = resp.interact_pointer_pos()
        && let Some((mid, ..)) = hit(q)
        && Some(mid) != active
    {
        let _ = app.run("mask.select", json!({"id": mid}));
    }
    if resp.drag_started()
        && let Some(q) = ui.input(|i| i.pointer.press_origin()).or(resp.interact_pointer_pos())
    {
        let grip = hit(q).map(|(m, c, h, _)| (m, c, h)).or_else(|| {
            let m = d.masks.iter().find(|m| Some(m.id) == active)?;
            // Handles take precedence; otherwise grab the selected radial component under
            // the press, including components after the first in compound masks.
            let map = &map.for_mask(m.on_photo);
            let at = map.norm(q);
            if let Some(ci) = m.components.iter().position(|c| radial_body_contains(&c.shape, at, map)) {
                return Some((m.id, ci, 0));
            }
            // anywhere on the photo drags the selected linear gradient
            matches!(m.components.first()?.shape, MaskShape::Linear { .. }).then_some((m.id, 0, 0))
        });
        if let Some((mask, comp, handle)) = grip
            && d.masks.iter().find(|m| m.id == mask).and_then(|m| m.components.get(comp)).is_some()
        {
            if Some(mask) != active {
                let _ = app.run("mask.select", json!({"id": mask}));
            }
            let _ = app.run("develop.beginInteraction", json!({"label": "Edit Mask"}));
            // (read after it begins: an old mask is on the photo from then on, in its coordinates)
            if let Some(original_shape) = current_shape(app, mask, comp)
                .or_else(|| d.masks.iter().find(|m| m.id == mask).and_then(|m| m.components.get(comp)).map(|c| c.shape.clone()))
            {
                app.gesture = Some(Gesture::MaskHandle { mask, comp, handle, original_shape });
            }
        }
    }
    if resp.dragged()
        && let (Some(Gesture::MaskHandle { mask, comp, handle, original_shape }), Some(q)) = (app.gesture.clone(), resp.interact_pointer_pos())
    {
        // (the live flag: the drag's first frame began the interaction, which put an old mask on the photo)
        let map = &current_on_photo(app, mask).map_or_else(|| map.for_mask_id(d, Some(mask)), |on| map.for_mask(on));
        let n = map.norm(q);
        let press_origin = ui.input(|i| i.pointer.press_origin()).unwrap_or(q);
        let n0 = map.norm(press_origin);
        let dn = Point::new(n.x - n0.x, n.y - n0.y);
        let alt = ui.input(|i| i.modifiers.alt);
        let new_shape = moved_shape(&original_shape, handle, dn, n, map, alt);
        let _ = app.run("mask.update", json!({"id": mask, "component": comp, "shape": new_shape}));
    }
    if resp.drag_stopped() && matches!(app.gesture, Some(Gesture::MaskHandle { .. })) {
        app.gesture = None;
        let _ = app.run("develop.endInteraction", json!({}));
    }
}

/// A mask handle's name for screen readers: `handle` 0 is the component's pin, 1..5 a radial
/// gradient's right / bottom / left / top edge and rotation, 1..2 a linear gradient's start and end.
fn mask_handle_name(mask: &str, shape: &MaskShape, handle: u8) -> String {
    let part = match (shape, handle) {
        (_, 0) => "pin",
        (MaskShape::Radial { .. }, 1) => "right edge",
        (MaskShape::Radial { .. }, 2) => "bottom edge",
        (MaskShape::Radial { .. }, 3) => "left edge",
        (MaskShape::Radial { .. }, 4) => "top edge",
        (MaskShape::Radial { .. }, _) => "rotation",
        (MaskShape::Linear { .. }, 1) => "start",
        (MaskShape::Linear { .. }, _) => "end",
        _ => "handle",
    };
    format!("{mask} {}", crate::i18n::tr(part))
}

/// Keyboard stand-ins for the mask handles and pins: an arrow press moves the focused one by a
/// step (one undo step), as dragging it would; Return on a pin selects its mask.
fn mask_keys(app: &mut LightcraftApp, ui: &mut egui::Ui, map: &CanvasMap, d: &DevelopSettings, grips: &[(u32, usize, u8, Pos2)]) {
    for &(mid, ci, handle, q) in grips {
        let Some(m) = d.masks.iter().find(|m| m.id == mid) else { continue };
        let Some(shape) = m.components.get(ci).map(|c| &c.shape) else { continue };
        let map = &map.for_mask(m.on_photo);
        let at = map.norm(q);
        let mask_name = if m.name.trim().is_empty() { format!("{} {mid}", crate::i18n::tr("Mask")) } else { m.name.clone() };
        let name = mask_handle_name(&mask_name, shape, handle);
        let keys = crate::canvas_keys::handle(ui, &format!("mask:{mid}:{ci}:{handle}"), &name, crate::canvas_keys::position_text(at.x, at.y), q);
        if keys.activated && app.session.active_mask != Some(mid) {
            let _ = app.run("mask.select", json!({"id": mid}));
        }
        let Some((dx, dy)) = keys.delta else { continue };
        if app.session.active_mask != Some(mid) {
            let _ = app.run("mask.select", json!({"id": mid}));
        }
        let _ = app.run("develop.beginInteraction", json!({"label": "Edit Mask"}));
        // (read after it begins: an old mask is on the photo from then on, in its coordinates)
        let (shape, map) = match (current_shape(app, mid, ci), current_on_photo(app, mid)) {
            (Some(s), Some(on)) => (s, map.for_mask(on)),
            _ => (shape.clone(), map.clone()),
        };
        let at = map.norm(q);
        let to = Point::new(at.x + dx, at.y + dy);
        let new_shape = moved_shape(&shape, handle, Point::new(dx, dy), to, &map, false);
        let _ = app.run("mask.update", json!({"id": mid, "component": ci, "shape": new_shape}));
        let _ = app.run("develop.endInteraction", json!({}));
    }
}

/// The shape of component `comp` of mask `mask` of the active photo as the session has it now.
fn current_shape(app: &LightcraftApp, mask: u32, comp: usize) -> Option<MaskShape> {
    let d = app.session.develop_of(app.session.active()?)?;
    d.masks.iter().find(|m| m.id == mask)?.components.get(comp).map(|c| c.shape.clone())
}

/// Whether mask `mask` of the active photo is on the photo now (`Mask::on_photo`).
fn current_on_photo(app: &LightcraftApp, mask: u32) -> Option<bool> {
    let d = app.session.develop_of(app.session.active()?)?;
    d.masks.iter().find(|m| m.id == mask).map(|m| m.on_photo)
}

/// Long-edge units → normalized units for x and y.
pub(super) fn frame_long_norm(map: &CanvasMap) -> (f64, f64) {
    // derive from the mapping: 1 normalized unit in x and y in screen points (of the frame's
    // proportions, which a lens or perspective warp doesn't change)
    let map = map.for_mask(false);
    let o = map.screen(Point::new(0.0, 0.0));
    let x = map.screen(Point::new(1.0, 0.0)).distance(o) as f64;
    let y = map.screen(Point::new(0.0, 1.0)).distance(o) as f64;
    let l = x.max(y);
    (l / x.max(1e-9), l / y.max(1e-9))
}

/// Auto's condition for the Tool Overlay (Shift+H): the pointer is over the photo, or a pin is
/// being dragged.
pub(super) fn pins_live(app: &LightcraftApp, resp: &egui::Response, map: &CanvasMap) -> bool {
    resp.hover_pos().is_some_and(|q| map.rect.contains(q))
        || matches!(app.gesture, Some(Gesture::SpotMove { .. } | Gesture::MaskHandle { .. }))
        // a handle moved with the keyboard stays shown while it has the focus
        || crate::canvas_keys::has_focus(&resp.ctx)
}

pub(super) fn pin(p: &egui::Painter, c: Pos2, sel: bool) {
    p.circle_filled(c, 6.0, if sel { Color32::from_rgb(1, 101, 221) } else { Color32::from_gray(200) });
    p.circle_stroke(c, 6.0, Stroke::new(1.5, Color32::WHITE));
}

/// The pen pressure (0..1) reported this frame: the force of the latest touch or pen event that carries one (winit
/// reports a pen's pressure as a touch force, on the platforms that give it), `None` for a mouse.
pub(crate) fn pen_force(i: &egui::InputState) -> Option<f32> {
    i.events.iter().rev().find_map(|e| match e {
        egui::Event::Touch { force: Some(f), .. } if f.is_finite() => Some(f.clamp(0.0, 1.0)),
        _ => None,
    })
}

/// Record the pressure of the stroke's point `index`: `force` when the pen reported one this frame, else the last
/// known one. Points before the first reported force take it too; a stroke without any keeps no pressure list.
pub(crate) fn record_pressure(pressure: &mut Vec<f32>, index: usize, force: Option<f32>) {
    match (force, pressure.last().copied()) {
        (Some(f), _) if pressure.is_empty() => pressure.extend(std::iter::repeat_n(f, index + 1)),
        (Some(f), _) => pressure.push(f),
        (None, Some(last)) => pressure.push(last),
        (None, None) => {}
    }
}

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

    #[test]
    fn pen_pressure_is_recorded_per_point_and_absent_for_a_mouse() {
        let mut p = Vec::new();
        record_pressure(&mut p, 0, None);
        record_pressure(&mut p, 1, None);
        assert!(p.is_empty(), "a mouse: no pressure list");
        // the first force covers the points before it, a frame without one repeats the last
        record_pressure(&mut p, 2, Some(0.4));
        record_pressure(&mut p, 3, None);
        record_pressure(&mut p, 4, Some(0.9));
        assert_eq!(p, vec![0.4, 0.4, 0.4, 0.4, 0.9]);

        let mut i = egui::InputState::default();
        assert_eq!(pen_force(&i), None);
        let touch = |force| egui::Event::Touch {
            device_id: egui::TouchDeviceId(1),
            id: egui::TouchId(1),
            phase: egui::TouchPhase::Move,
            pos: egui::pos2(1.0, 1.0),
            force,
        };
        i.events = vec![touch(Some(0.3)), touch(Some(f32::NAN)), touch(None)];
        assert_eq!(pen_force(&i), Some(0.3), "the latest usable force");
        i.events = vec![touch(Some(4.0))];
        assert_eq!(pen_force(&i), Some(1.0));
    }
}

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

    /// Dragging the body of a face box (not a handle) moves the whole box by the drag, keeps its
    /// size, and stays inside the photo; the move is reported once, on release.
    #[test]
    fn a_moved_face_box_keeps_its_size_and_stays_inside_the_photo() {
        let ctx = egui::Context::default();
        crate::theme::install_fonts(&ctx);
        crate::theme::apply(&ctx);
        let canvas = Rect::from_min_size(pos2(0.0, 0.0), vec2(400.0, 400.0));
        let frame = lightcraft_pipeline::geometry::Frame::new(100, 100, &DevelopSettings::default(), true);
        let map = CanvasMap::new(&frame, canvas);
        let mut photo = lightcraft_catalog::Photo::new(
            lightcraft_catalog::PhotoId(1),
            lightcraft_catalog::Source::Demo { scene: 0 },
            "a.jpg",
            "JPEG",
            100,
            100,
            "2026-10-01T00:00:00",
        );
        photo.meta.regions = vec![lightcraft_meta::Region {
            rect: lightcraft_geom::Rect { x0: 0.2, y0: 0.2, x1: 0.4, y1: 0.4 },
            kind: lightcraft_meta::RegionKind::Face,
            name: Some("Jane".to_string()),
            description: None,
        }];
        let mut editing = None;
        let mut run_frame = |events: &[egui::Event]| -> Option<RegionEdit> {
            let mut edit = None;
            let mut output = ctx.run_ui(egui::RawInput { screen_rect: Some(canvas), events: events.to_vec(), ..Default::default() }, |ui| {
                egui::CentralPanel::default().frame(egui::Frame::NONE).show(ui, |ui| {
                    let p = ui.painter_at(canvas);
                    let regions = RegionContext {
                        photo: &photo,
                        orient: lightcraft_geom::Orientation::Normal,
                        hints: None,
                        people: &[],
                        setup: crate::panels::faces::Setup::Running,
                        movable: true,
                    };
                    edit = region_overlay(ui, &p, &map, &regions, &mut editing);
                });
            });
            output.textures_delta.clear();
            edit
        };
        // the box is at 80..160 px on screen; drag its centre (120, 120) by 40 x 20 px
        let press =
            |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE };
        run_frame(&[egui::Event::PointerMoved(pos2(120.0, 120.0))]);
        run_frame(&[press(pos2(120.0, 120.0), true)]);
        run_frame(&[egui::Event::PointerMoved(pos2(140.0, 130.0))]);
        run_frame(&[egui::Event::PointerMoved(pos2(160.0, 140.0))]);
        let edit = run_frame(&[press(pos2(160.0, 140.0), false)]);
        assert!(matches!(edit, Some(RegionEdit::Resize(0, _))), "dragging the face box body reports the moved box");
        let Some(RegionEdit::Resize(index, moved)) = edit else { return };
        assert_eq!(index, 0);
        assert!(((moved.x1 - moved.x0) - 0.2).abs() < 0.02, "width kept: {moved:?}");
        assert!(((moved.y1 - moved.y0) - 0.2).abs() < 0.02, "height kept: {moved:?}");
        assert!((moved.x0 - 0.3).abs() < 0.02 && (moved.y0 - 0.25).abs() < 0.02, "moved by the drag: {moved:?}");
        assert!(moved.x0 >= 0.0 && moved.y0 >= 0.0 && moved.x1 <= 1.0 && moved.y1 <= 1.0, "inside the photo: {moved:?}");
    }
}