GitCorner

Code

ossartcraftvectorcraft🌐
2bc41aeb8602
//! The Dimension tool. Hover a segment (linear), a corner (angular) or a circle or perfect arc
//! (radial) and drag outwards: releasing places the linked dimension. Plain clicks pick what to
//! measure instead: two points (linear) or two straight lines (angular), then a click places it;
//! a click on a circle or arc gives its radius. Escape cancels without leaving any artwork.
use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey};
use serde_json::{Value, json};
use std::collections::HashMap;
use vectorcraft_doc::{
    Node, NodeId, NodeKind,
    dimension::{self, Dimension, DimensionMode, DimensionOptions, DimensionSource, FreePoint, Orientation, PointRef, SegmentRef},
};
use vectorcraft_geom::{BezPath, Point, Rect, Vec2};

/// The three kinds of dimension the tool draws.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Kind {
    #[default]
    Linear,
    Angular,
    Radial,
}

impl Kind {
    pub fn id(self) -> &'static str {
        match self {
            Kind::Linear => "linear",
            Kind::Angular => "angular",
            Kind::Radial => "radial",
        }
    }
    /// `radius` and `diameter` are the radial kind.
    pub fn parse(s: &str) -> Option<Kind> {
        match s {
            "linear" => Some(Kind::Linear),
            "angular" => Some(Kind::Angular),
            "radial" | "radius" | "diameter" => Some(Kind::Radial),
            _ => None,
        }
    }
}

/// What the pointer is over.
#[derive(Clone, Debug, PartialEq)]
enum Target {
    Segment(SegmentRef),
    Corner { first: SegmentRef, second: SegmentRef, at: Point },
    Radial { source: DimensionSource, center: Point, radius: f64 },
}

#[derive(Default)]
pub struct DimensionTool {
    kind: Kind,
    style: DimensionOptions,
    /// Where the button went down, and what was under it.
    press: Option<(Point, Option<Target>)>,
    /// Plain-click picks: points (linear) or straight lines (angular).
    points: Vec<(Point, Option<PointRef>)>,
    lines: Vec<SegmentRef>,
    /// A dimension being placed: previews follow the pointer.
    pending: Option<Dimension>,
    dragging: bool,
    hover: Option<Target>,
    at: Point,
    /// Whether Shift was down at the last pointer event: the picked line shows constrained.
    shift: bool,
    began: bool,
    /// Smart Guides for the Linear picks, hovering too: the guides show before each click.
    snap: crate::guides::DrawSnap,
    /// Where the next Linear pick lands, as last worked out for the pointer (for the overlays).
    snapped: Option<(Point, Option<PointRef>)>,
    /// Whether the last Linear pick worked out landed on the end of a line of a dimension already
    /// drawn, or on a corner of a path's preview bounds (shown as an anchor).
    on_end: bool,
    /// The path that holds the last Linear pick worked out, when it landed on a corner of that
    /// path's preview bounds.
    corner: Option<NodeId>,
    /// The path that holds the first Linear point, when it was picked on a corner of that path's
    /// preview bounds.
    first_corner: Option<NodeId>,
    /// Whether the press under way began on an anchor a Linear click picks.
    press_on_anchor: bool,
    /// The second point clicked for the Linear dimension being placed, and where the pointer was
    /// for that click (a snap or Shift can move the point away from it): placed with the pointer
    /// still at either, it is aligned.
    second: Option<(Point, Point)>,
    /// The preview bounds the Linear picks measured, for the document's revision.
    preview_boxes: PreviewBoxes,
    /// While a Linear dimension is placed with its line on the level of another dimension's line:
    /// the ends of that other line. A Smart Guide runs along the level across both lines.
    level_guide: Option<(Point, Point)>,
    /// While a linear dimension is placed: the lines of the visible, unlocked linear dimensions in
    /// the document ([`dimension_lines`]), which its line can line up with while Smart Guides are
    /// on. With Smart Guides on, they are read again when the document they come from has changed.
    levels: Vec<DimensionLine>,
    /// Which document `levels` were read from: the open document's id and revision, or, while an
    /// interaction is in progress, the open document's id and the address of the document the
    /// interaction began with.
    levels_at: (u64, u64, usize),
    /// The document's next object id at the dimension's first preview: the id its preview takes
    /// (`dimension.create` gives the dimension the next id). The preview is not a level.
    preview_id: u64,
}

/// What a linear dimension between `a` and `b` measures with the pointer at `p` while it is
/// placed (VectorCraft's own rule). Beside the points, where the nearest point of the line
/// through them lies between them, the dimension is aligned: it measures the distance between
/// them. Past either point it measures along an axis. The line through the points and the
/// perpendicular at that point bound a quarter on each side; the pointer's quarter holds either
/// the straight up or down direction, which gives the horizontal distance, or the straight left
/// or right direction, which gives the vertical distance. Points on one horizontal or vertical
/// line only give an aligned dimension.
fn orientation_at(a: Point, b: Point, p: Point) -> Orientation {
    let u = b - a;
    let len = u.hypot();
    if len < 1e-9 {
        return Orientation::Aligned;
    }
    let along = (p - a).dot(u) / (len * len);
    if (0.0..=1.0).contains(&along) {
        return Orientation::Aligned;
    }
    // Out past the nearer point, and the side of the line the pointer is on.
    let (out, side) = (if along > 1.0 { u } else { -u }, u.cross(p - a));
    let axes = [
        (Vec2::new(0.0, 1.0), Orientation::Horizontal),
        (Vec2::new(0.0, -1.0), Orientation::Horizontal),
        (Vec2::new(1.0, 0.0), Orientation::Vertical),
        (Vec2::new(-1.0, 0.0), Orientation::Vertical),
    ];
    let within = len * 1e-9;
    axes.into_iter()
        .find(|(axis, _)| axis.dot(out) > within && u.cross(*axis).abs() > within && u.cross(*axis) * side > 0.0)
        .map_or(Orientation::Aligned, |(_, orientation)| orientation)
}

/// How near an anchor (screen pixels) a pick snaps to it.
const ANCHOR_REACH: f64 = 8.0;

/// `at` as a Shift click picks it: the direction from `last` snapped to 45° steps (from the
/// constrain angle), the distance kept.
fn constrained(cx: &ToolContext, last: Point, at: Point) -> Point {
    last + vectorcraft_geom::constrain_angle_from(at - last, 45.0, cx.constrain_angle)
}

/// Nearest editable segment, with bounded work and no snapping to dimension artwork itself.
pub fn pick(cx: &ToolContext, p: Point) -> Option<SegmentRef> {
    let mut best = None;
    let mut dist = cx.tol(8.0);
    let mut budget = 20_000usize;
    fn visit(n: &Node, p: Point, budget: &mut usize, dist: &mut f64, best: &mut Option<SegmentRef>) {
        if *budget == 0 || !n.visible || n.locked || n.extras().dimension.is_some() {
            return;
        }
        if let Some(path) = n.path_data() {
            for (si, sp) in path.subpaths.iter().enumerate() {
                for i in 0..sp.segment_count() {
                    if *budget == 0 {
                        return;
                    }
                    *budget -= 1;
                    use vectorcraft_geom::kurbo::ParamCurveNearest;
                    let near = sp.segment(i).nearest(p, 1e-4);
                    if near.distance_sq < *dist * *dist {
                        *dist = near.distance_sq.sqrt();
                        *best = Some(SegmentRef { node: n.id, subpath: si, segment: i });
                    }
                }
            }
        }
        if let Some(ch) = n.children() {
            for c in ch.iter().rev() {
                visit(c, p, budget, dist, best);
            }
        }
    }
    for n in cx.doc.layers.iter().rev() {
        visit(n, p, &mut budget, &mut dist, &mut best);
    }
    best
}

/// The anchor of `edge` within reach of `p`, if any.
fn anchor_near(cx: &ToolContext, edge: &SegmentRef, p: Point) -> Option<(usize, Point)> {
    let sp = cx.doc.node(edge.node)?.path_data()?.subpaths.get(edge.subpath)?;
    let next = if edge.segment + 1 < sp.anchors.len() { edge.segment + 1 } else { 0 };
    [edge.segment, next]
        .into_iter()
        .filter_map(|i| Some((i, sp.anchors.get(i)?.p)))
        .filter(|(_, a)| a.distance(p) <= cx.tol(ANCHOR_REACH))
        .min_by(|(_, a), (_, b)| a.distance(p).total_cmp(&b.distance(p)))
}

/// The anchor nearest `p` within reach, on any editable path (the topmost on a tie), as a link to
/// its path. Bounded work, and dimension artwork is skipped, as in [`pick`].
fn anchor_under(cx: &ToolContext, p: Point) -> Option<(Point, PointRef)> {
    anchor_under_where(cx, p, |_| true)
}

/// [`anchor_under`] outside the objects `keep` turns down, and outside everything in them.
fn anchor_under_where(cx: &ToolContext, p: Point, keep: impl Fn(NodeId) -> bool) -> Option<(Point, PointRef)> {
    type Best = Option<(f64, Point, PointRef)>;
    fn visit(n: &Node, p: Point, reach: f64, keep: &dyn Fn(NodeId) -> bool, budget: &mut usize, best: &mut Best) {
        if *budget == 0 || !n.visible || n.locked || n.extras().dimension.is_some() || !keep(n.id) {
            return;
        }
        if let Some(path) = n.path_data() {
            for (subpath, sp) in path.subpaths.iter().enumerate() {
                for (anchor, a) in sp.anchors.iter().enumerate() {
                    if *budget == 0 {
                        return;
                    }
                    *budget -= 1;
                    let d = a.p.distance(p);
                    if d <= reach && best.as_ref().is_none_or(|(nearest, ..)| d < *nearest) {
                        *best = Some((d, a.p, PointRef { node: n.id, subpath, anchor }));
                    }
                }
            }
        }
        if let Some(ch) = n.children() {
            for c in ch.iter().rev() {
                visit(c, p, reach, keep, budget, best);
            }
        }
    }
    let (reach, mut budget, mut best) = (cx.tol(ANCHOR_REACH), 20_000usize, None);
    for n in cx.doc.layers.iter().rev() {
        visit(n, p, reach, &keep, &mut budget, &mut best);
    }
    best.map(|(_, at, r)| (at, r))
}

/// The geometric bounds of the paths [`preview_corner`] looked at, and the preview bounds of
/// those it measured, kept while the document is unchanged, so that the pointer moving over the
/// art measures each path once.
#[derive(Default)]
struct PreviewBoxes {
    revision: Option<(u64, u64)>,
    geometric: HashMap<NodeId, Option<Rect>>,
    preview: HashMap<NodeId, Option<Rect>>,
    /// Whether a point at each corner (by object and corner number) can be held against its path.
    holdable: HashMap<(NodeId, usize), bool>,
}

/// A corner of an object's preview bounds that a Linear pick can land on.
#[derive(Clone, Copy, Debug)]
struct PreviewCorner {
    at: Point,
    /// The path the point is held against.
    holder: NodeId,
    /// The same corner of the object's geometric bounds: an anchor of `holder` there is the
    /// anchor the corner stands in for.
    stands_for: Point,
}

/// With Use Preview Bounds on, the corner of a path's or compound path's preview bounds (its
/// strokes and effects included) nearest `p` within reach, on any editable one whose preview
/// bounds differ from its geometric bounds. In a compound path, the member whose own box reaches
/// nearest to the corner holds it. The work is bounded, and dimension artwork is skipped, as in
/// [`pick`]. `cache` keeps the bounds measured for the document's revision.
fn preview_corner(cx: &ToolContext, p: Point, cache: &mut PreviewBoxes) -> Option<PreviewCorner> {
    struct Walk<'a, 'c> {
        symbols: Option<vectorcraft_doc::SymbolBoxes<'a>>,
        doc: &'a vectorcraft_doc::Document,
        cache: &'c mut PreviewBoxes,
        p: Point,
        reach: f64,
        budget: usize,
        best: Option<(f64, PreviewCorner)>,
    }
    fn visit(n: &Node, w: &mut Walk) {
        if w.budget == 0 || !n.visible || n.locked || n.extras().dimension.is_some() {
            return;
        }
        w.budget -= 1;
        // Only effects, on the object or on one of its fills or strokes, paint further out than
        // its strokes reach.
        let effects = !n.appearance.effects.is_empty() || n.appearance.items.iter().any(|i| !i.effects().is_empty());
        let reach = n.appearance.outset() + w.reach;
        let corners = |r: Rect| [Point::new(r.x0, r.y0), Point::new(r.x1, r.y0), Point::new(r.x1, r.y1), Point::new(r.x0, r.y1)];
        // A path is its own member; a compound path's members are its paths.
        let compound = match &n.kind {
            NodeKind::Compound { children, .. } => Some(children.as_slice()),
            _ => None,
        };
        let members =
            || compound.into_iter().flatten().map(|c| c.as_ref()).chain(compound.is_none().then_some(n)).filter(|m| m.path_data().is_some());
        // A path made into a guide draws as a guide, without its strokes or effects. The pointer
        // test includes the right and bottom edges, as the distance test below does.
        let within = |r: Rect| (r.x0..=r.x1).contains(&w.p.x) && (r.y0..=r.y1).contains(&w.p.y);
        if !n.is_guide()
            && members().next().is_some()
            && let Some(geometric) = *w.cache.geometric.entry(n.id).or_insert_with(|| n.geometric_bounds())
            && (effects || within(geometric.inflate(reach, reach)))
        {
            let doc = w.doc;
            let measured = match w.cache.preview.get(&n.id) {
                Some(r) => *r,
                None => {
                    let symbols = w.symbols.get_or_insert_with(|| doc.symbol_boxes());
                    let r = vectorcraft_effects::preview::visual_bounds(symbols, n);
                    w.cache.preview.insert(n.id, r);
                    r
                }
            };
            if let Some(r) = measured
                && r != geometric
            {
                for (k, q) in corners(r).into_iter().enumerate() {
                    let d = q.distance(w.p);
                    if d > w.reach || w.best.is_some_and(|(nearest, ..)| d >= nearest) {
                        continue;
                    }
                    // The path whose own box reaches furthest towards the corner holds it: in a
                    // compound path, the member that puts that corner where it is. A hidden or
                    // locked member gives no corner.
                    let mut holder: Option<(f64, NodeId, bool)> = None;
                    for m in members() {
                        let Some(b) = *w.cache.geometric.entry(m.id).or_insert_with(|| m.geometric_bounds()) else { continue };
                        let gap = corners(b).get(k).map_or(f64::INFINITY, |c| c.distance(q));
                        let editable = m.visible && !m.locked;
                        if holder.is_none_or(|(near, _, was)| gap < near || (gap == near && editable && !was)) {
                            holder = Some((gap, m.id, editable));
                        }
                    }
                    let holder = holder.filter(|(.., editable)| *editable).map(|(gap, id, _)| (gap, id));
                    // A path that cannot hold a point at the corner (a stroked dot, whose anchors
                    // all coincide) gives no corner.
                    let holdable = |id: NodeId, cache: &mut PreviewBoxes| {
                        *cache.holdable.entry((n.id, k)).or_insert_with(|| FreePoint::on(doc, id, q).is_some())
                    };
                    let holder = holder.filter(|(_, id)| holdable(*id, w.cache));
                    if let Some(((_, holder), stands_for)) = holder.zip(corners(geometric).get(k).copied()) {
                        w.best = Some((d, PreviewCorner { at: q, holder, stands_for }));
                    }
                }
            }
        }
        // A compound path draws its members with its own appearance: they give no corners of
        // their own.
        if compound.is_none()
            && let Some(ch) = n.children()
        {
            for c in ch.iter().rev() {
                visit(c, w);
            }
        }
    }
    // Anchors take a pick whatever the snapping options, and so do the corners standing in for them.
    if !cx.preview_bounds {
        return None;
    }
    if cache.revision != Some(cx.revision) {
        *cache = PreviewBoxes { revision: Some(cx.revision), ..Default::default() };
    }
    let mut w = Walk { symbols: None, doc: cx.doc, cache, p, reach: cx.tol(ANCHOR_REACH), budget: 20_000, best: None };
    for n in cx.doc.layers.iter().rev() {
        visit(n, &mut w);
    }
    w.best.map(|(_, corner)| corner)
}

/// The anchor a pick at `p` lands on instead of `corner`, given `anchor`, the nearest anchor
/// within reach; `None` when the corner takes it (VectorCraft's own rule). The corner takes the
/// pick from the anchors of the path holding it at the same corner of the object's geometric
/// bounds, which sit on the stroke's centerline. An anchor right on the corner takes it, and so
/// does the nearest other anchor, of this object or of other art, when it is nearer the pointer
/// than the corner. The holder's anchors and the other art are searched with a budget each, and
/// `anchor` wins a tie, as the topmost.
fn anchor_over_corner(cx: &ToolContext, p: Point, corner: &PreviewCorner, anchor: Option<(Point, PointRef)>) -> Option<(Point, PointRef)> {
    if anchor.as_ref().is_some_and(|(at, _)| at.distance(corner.at) <= 1e-9) {
        return anchor;
    }
    let stands_in = |(at, nearest): &(Point, PointRef)| nearest.node == corner.holder && at.distance(corner.stands_for) <= 1e-9;
    let first = anchor.filter(|a| !stands_in(a));
    let reach = cx.tol(ANCHOR_REACH);
    let own = cx.doc.node(corner.holder).and_then(|n| n.path_data()).and_then(|path| {
        let anchors = path.subpaths.iter().enumerate().flat_map(|(subpath, sp)| sp.anchors.iter().enumerate().map(move |(i, a)| (subpath, i, a.p)));
        anchors
            .take(20_000)
            .filter(|(.., q)| q.distance(p) <= reach && q.distance(corner.stands_for) > 1e-9)
            .min_by(|(.., a), (.., b)| a.distance(p).total_cmp(&b.distance(p)))
            .map(|(subpath, anchor, q)| (q, PointRef { node: corner.holder, subpath, anchor }))
    });
    let other = anchor_under_where(cx, p, |id| id != corner.holder);
    first
        .into_iter()
        .chain(other)
        .chain(own)
        .filter(|(q, _)| q.distance(p) < corner.at.distance(p) || q.distance(corner.at) <= 1e-9)
        .min_by(|(a, _), (b, _)| a.distance(p).total_cmp(&b.distance(p)))
}

/// Where a pick at `p` lands on the artwork of the visible, unlocked dimensions already drawn,
/// with no link to it: the nearest end of one of their lines (dimension and extension lines)
/// within the anchor reach, as an anchor (`true`); else the nearest point of one of those lines
/// within 8 pixels (`false`). The end of an extension line next to the point it measures is not
/// an end here: it lies a few points off that point. Only with Smart Guides or Snap to Point on.
/// Bounded work, and the topmost dimension wins a tie, as in [`anchor_under`].
fn on_dimensions(cx: &ToolContext, p: Point) -> Option<(Point, bool)> {
    use vectorcraft_geom::kurbo::{ParamCurve, ParamCurveNearest};
    #[derive(Default)]
    struct Best {
        end: Option<(f64, Point)>,
        line: Option<(f64, Point)>,
    }
    /// `measured`: a linear dimension's measured points and how far its extension lines start
    /// from them.
    fn lines(n: &Node, measured: Option<([Point; 2], f64)>, p: Point, reach: [f64; 2], budget: &mut usize, best: &mut Best) {
        if *budget == 0 || !n.visible || n.locked {
            return;
        }
        if let Some(path) = n.path_data() {
            // Open subpaths only: the lines, not a filled arrowhead.
            for sp in path.subpaths.iter().filter(|sp| !sp.closed) {
                // An extension line starts at the offset from its measured point and runs straight
                // away from it; the dimension line runs across that direction. With no offset its
                // start is the measured point itself, and stays an end.
                let extension_start = |a: Point, b: Point| {
                    measured.is_some_and(|(points, offset)| {
                        points.iter().any(|m| {
                            let (out, along) = (a - *m, b - a);
                            offset > 1e-6 && (out.hypot() - offset).abs() <= 1e-6 && out.dot(along) >= (1.0 - 1e-6) * out.hypot() * along.hypot()
                        })
                    })
                };
                let (Some(first), Some(last)) = (sp.anchors.first(), sp.anchors.last()) else { continue };
                let skip_first = extension_start(first.p, last.p);
                for a in [first, last].into_iter().skip(usize::from(skip_first)) {
                    let d = a.p.distance(p);
                    if d <= reach[0] && best.end.is_none_or(|(near, _)| d < near) {
                        best.end = Some((d, a.p));
                    }
                }
                for i in 0..sp.segment_count() {
                    if *budget == 0 {
                        return;
                    }
                    *budget -= 1;
                    let c = sp.segment(i);
                    let q = c.eval(c.nearest(p, 1e-4).t);
                    let d = q.distance(p);
                    if q.x.is_finite() && q.y.is_finite() && d <= reach[1] && best.line.is_none_or(|(near, _)| d < near) {
                        best.line = Some((d, q));
                    }
                }
            }
        }
        for c in n.children().into_iter().flatten().rev() {
            if *budget == 0 {
                return;
            }
            lines(c, measured, p, reach, budget, best);
        }
    }
    fn visit(n: &Node, p: Point, reach: [f64; 2], budget: &mut usize, best: &mut Best) {
        if *budget == 0 || !n.visible || n.locked {
            return;
        }
        *budget -= 1;
        if let Some(d) = &n.extras().dimension {
            let measured = (d.mode == DimensionMode::Linear).then_some(([d.a, d.b], d.options.extension_offset));
            lines(n, measured, p, reach, budget, best);
            return;
        }
        for c in n.children().into_iter().flatten().rev() {
            if *budget == 0 {
                return;
            }
            visit(c, p, reach, budget, best);
        }
    }
    if !(cx.smart_guides || cx.snap_to_point) {
        return None;
    }
    let (reach, mut budget, mut best) = ([cx.tol(ANCHOR_REACH), cx.tol(8.0)], 20_000usize, Best::default());
    for n in cx.doc.layers.iter().rev() {
        if budget == 0 {
            break;
        }
        visit(n, p, reach, &mut budget, &mut best);
    }
    best.end.map(|(_, q)| (q, true)).or_else(|| best.line.map(|(_, q)| (q, false)))
}

/// The line of a linear dimension already drawn: its ends and its direction.
type DimensionLine = ((Point, Point), Vec2);

/// The lines of the visible, unlocked linear dimensions in `doc`, except the preview of the
/// dimension being placed: a dimension with the id `preview.0` that measures the points
/// `preview.1`. Bounded work, as in [`on_dimensions`].
fn dimension_lines(doc: &vectorcraft_doc::Document, preview: (u64, [Point; 2])) -> Vec<DimensionLine> {
    fn visit(n: &Node, preview: (u64, [Point; 2]), budget: &mut usize, out: &mut Vec<DimensionLine>) {
        let is_preview = n.id.0 == preview.0
            && n.extras().dimension.as_ref().is_some_and(|d| d.a.distance(preview.1[0]) < 1e-9 && d.b.distance(preview.1[1]) < 1e-9);
        if *budget == 0 || !n.visible || n.locked || is_preview {
            return;
        }
        *budget -= 1;
        if let Some(d) = &n.extras().dimension {
            if d.mode == DimensionMode::Linear {
                out.push((d.line_ends(), d.direction()));
            }
            return;
        }
        for c in n.children().into_iter().flatten().rev() {
            if *budget == 0 {
                return;
            }
            visit(c, preview, budget, out);
        }
    }
    let (mut budget, mut out) = (20_000usize, vec![]);
    for n in doc.layers.iter().rev() {
        if budget == 0 {
            break;
        }
        visit(n, preview, &mut budget, &mut out);
    }
    out
}

/// Where the line of the linear dimension `d`, placed through `p`, lands on the level of one of
/// the `levels` that runs parallel to it, within `reach` of `p` across the line: the point to
/// place `d` through, and the ends of that other line. The nearest level wins, then the line
/// nearest `p` along it (none nearer than a line that `p` lies across).
fn line_level(levels: &[DimensionLine], d: &Dimension, p: Point, reach: f64) -> Option<(Point, (Point, Point))> {
    if d.mode != DimensionMode::Linear {
        return None;
    }
    let (u, normal) = (d.direction(), d.normal());
    let mut best: Option<(f64, f64, f64, (Point, Point))> = None;
    for &(ends, direction) in levels {
        if u.cross(direction).abs() > 1e-6 {
            continue;
        }
        let shift = (ends.0 - p).dot(normal);
        let (s0, s1) = ((ends.0 - p).dot(u), (ends.1 - p).dot(u));
        let along = if s0 * s1 <= 0.0 { 0.0 } else { s0.abs().min(s1.abs()) };
        if shift.is_finite() && along.is_finite() && shift.abs() <= reach && best.is_none_or(|(s, a, _, _)| (shift.abs(), along) < (s, a)) {
            best = Some((shift.abs(), along, shift, ends));
        }
    }
    best.map(|(_, _, shift, ends)| (p + normal * shift, ends))
}

/// The point of `edge` closest to `p`.
fn nearest_on(cx: &ToolContext, edge: &SegmentRef, p: Point) -> Option<Point> {
    use vectorcraft_geom::kurbo::ParamCurveNearest;
    let sp = cx.doc.node(edge.node)?.path_data()?.subpaths.get(edge.subpath)?;
    if edge.segment >= sp.segment_count() {
        return None;
    }
    let c = sp.segment(edge.segment);
    let t = c.nearest(p, 1e-4).t;
    use vectorcraft_geom::kurbo::ParamCurve;
    let q = c.eval(t);
    (q.x.is_finite() && q.y.is_finite()).then_some(q)
}

/// What a dimension between two picked points links to. A point on an anchor links to the anchor.
/// A point on a segment keeps its place along the segment. Any other point is held
/// against the anchors of the path under it, or, with no path under it, the path of the other
/// point, so that it moves with that path. None when neither point has a path to link to.
/// `held_a` and `held_b` name the path holding a point picked on a corner of that path's
/// preview bounds: such a point is held against that path, however far its strokes or effects
/// put the corner from the path and whatever other segment lies there.
fn points_source(
    cx: &ToolContext,
    (a, ra, held_a): (Point, &Option<PointRef>, Option<NodeId>),
    (b, rb, held_b): (Point, &Option<PointRef>, Option<NodeId>),
) -> Option<DimensionSource> {
    // A path deleted since the pick holds nothing.
    let holder = |held: Option<NodeId>| held.filter(|node| cx.doc.node(*node).is_some());
    let (corner_a, corner_b) = (holder(held_a), holder(held_b));
    let edge = |p: Point, corner: Option<NodeId>| if corner.is_some() { None } else { pick(cx, p) };
    let (edge_a, edge_b) = (edge(a, corner_a), edge(b, corner_b));
    let node = |r: &Option<PointRef>, corner: Option<NodeId>, e: &Option<SegmentRef>| {
        r.as_ref().map(|r| r.node).or(corner).or_else(|| e.as_ref().map(|e| e.node))
    };
    let (path_a, path_b) = (node(ra, corner_a, &edge_a), node(rb, corner_b, &edge_b));
    let free = |p: Point, r: &Option<PointRef>, edge: &Option<SegmentRef>, own: Option<NodeId>, other: Option<NodeId>| {
        if r.is_some() {
            return None;
        }
        edge.as_ref().and_then(|e| FreePoint::on_segment(cx.doc, e, p)).or_else(|| own.or(other).and_then(|node| FreePoint::on(cx.doc, node, p)))
    };
    let (free_a, free_b) = (free(a, ra, &edge_a, path_a, path_b), free(b, rb, &edge_b, path_b, path_a));
    (ra.is_some() || rb.is_some() || free_a.is_some() || free_b.is_some()).then(|| DimensionSource::Points {
        a: ra.clone(),
        b: rb.clone(),
        vertex: None,
        free_a,
        free_b,
    })
}

impl DimensionTool {
    /// Where a Linear pick at `p` lands: with Use Preview Bounds on, on the nearest corner of a
    /// path's preview bounds within reach, where they differ from its anchors, unless another
    /// anchor is nearer (held against the path, labeled "anchor"; [`anchor_over_corner`]); else on the
    /// nearest anchor of any path, within reach (kept as
    /// a link to its path), labeled "anchor"; else on the nearest end of a line of a dimension
    /// already drawn, within the same reach (no link), also labeled "anchor"; else where Smart Guides put it (another object's anchor or centre, in
    /// line with one, or for the second point square to a segment or grazing a curve from the
    /// first with Snap to Perpendicular or Snap to Tangent on, or on a construction guide through
    /// a first point picked on an anchor), its guides showing; else on the closest point of the
    /// line under the pointer, of the art or of a dimension, labeled "path"; else `p` itself. A
    /// first point not on an anchor has no construction guides through it.
    /// A point the guides leave where the pointer is (right on a guide line) stays there, and with
    /// Snap to Pixel or Snap to Grid on a point stays where they place it.
    fn snap_linear(&mut self, cx: &ToolContext, p: Point) -> (Point, Option<PointRef>) {
        let leave = self.points.last().map(|(first, anchor)| match anchor {
            Some(_) => crate::guides::Leave::segment(cx, *first, false),
            None => crate::guides::Leave::contact(*first),
        });
        let guided = self.snap.hover(cx, p, &[], leave.as_ref());
        self.on_end = false;
        self.corner = None;
        let mut anchor = anchor_under(cx, p);
        if let Some(corner) = preview_corner(cx, p, &mut self.preview_boxes) {
            anchor = anchor_over_corner(cx, p, &corner, anchor);
            if anchor.is_none() {
                self.on_end = true;
                self.corner = Some(corner.holder);
                self.snap.label(corner.at, "anchor");
                return (corner.at, None);
            }
        }
        if let Some((point, reference)) = anchor {
            self.snap.label(point, "anchor");
            return (point, Some(reference));
        }
        let drawn = on_dimensions(cx, p);
        if let Some((q, true)) = drawn {
            self.on_end = true;
            self.snap.label(q, "anchor");
            return (q, None);
        }
        if guided.distance(p) > 1e-9 || !self.snap.guides().is_empty() || cx.snap_to_pixel || cx.snap_to_grid {
            return (guided, None);
        }
        // Not on an anchor or a guide: snap to the closest point of the line (#2432), of the art
        // or of a dimension already drawn.
        let art = pick(cx, p).and_then(|e| nearest_on(cx, &e, p));
        let line = drawn.map(|(q, _)| q);
        match art.into_iter().chain(line).min_by(|a, b| a.distance(p).total_cmp(&b.distance(p))) {
            Some(q) => {
                self.snap.label(q, "path");
                (q, None)
            }
            None => (p, None),
        }
    }
    fn target(&self, cx: &ToolContext, p: Point) -> Option<Target> {
        let edge = pick(cx, p)?;
        match self.kind {
            Kind::Linear => Some(Target::Segment(edge)),
            Kind::Angular => {
                let (anchor, at) = anchor_near(cx, &edge, p)?;
                let (first, second) = dimension::corner(cx.doc, edge.node, edge.subpath, anchor)?;
                Some(Target::Corner { first, second, at })
            }
            Kind::Radial => {
                if let Some((center, radius)) = dimension::circle(cx.doc, edge.node) {
                    return Some(Target::Radial { source: DimensionSource::Circle { node: edge.node }, center, radius });
                }
                let (center, radius) = dimension::arc(cx.doc, &edge)?;
                Some(Target::Radial { source: DimensionSource::Arc { edge }, center, radius })
            }
        }
    }
    fn recipe(&self, mode: DimensionMode, a: Point, b: Point, vertex: Point, source: Option<DimensionSource>) -> Dimension {
        Dimension {
            mode,
            a,
            b,
            vertex,
            offset: 0.0,
            length: a.distance(b),
            options: self.style.clone(),
            source,
            orientation: Orientation::Aligned,
            moved: None,
        }
    }
    /// The dimension a target gives when dragged from.
    fn dimension_for(&self, target: &Target, p: Point) -> Option<Dimension> {
        let mut d = match target {
            Target::Segment(edge) => self.recipe(
                DimensionMode::Linear,
                Point::ZERO,
                Point::new(1.0, 0.0),
                Point::ZERO,
                Some(DimensionSource::Segment { edge: edge.clone() }),
            ),
            Target::Corner { first, second, .. } => self.recipe(
                DimensionMode::Angular,
                Point::ZERO,
                Point::new(1.0, 0.0),
                Point::ZERO,
                Some(DimensionSource::Angle { first: first.clone(), second: second.clone() }),
            ),
            Target::Radial { source, center, radius } => {
                // Dragged outwards: the radius; inwards: the diameter.
                let mode = if p.distance(*center) >= *radius { DimensionMode::Radius } else { DimensionMode::Diameter };
                self.recipe(mode, *center, p, Point::ZERO, Some(source.clone()))
            }
        };
        d.offset = 30.0;
        Some(d)
    }
    fn params(d: &Dimension) -> Value {
        let mut p = json!({"mode":d.mode,"a":[d.a.x,d.a.y],"b":[d.b.x,d.b.y],"vertex":[d.vertex.x,d.vertex.y],"offset":d.offset,"options":d.options});
        if let Some(source) = &d.source {
            p["source"] = json!(source);
        }
        if d.orientation != Orientation::Aligned {
            p["orientation"] = json!(d.orientation);
        }
        p
    }
    fn preview(&mut self, cx: &ToolContext, p: Point) -> Vec<Action> {
        self.level_guide = None;
        let Some(d) = &mut self.pending else { return vec![] };
        if matches!(d.mode, DimensionMode::Radius | DimensionMode::Diameter)
            && let Some(Target::Radial { center, radius, .. }) = self.press.as_ref().and_then(|(_, t)| t.as_ref())
        {
            d.mode = if p.distance(*center) >= *radius { DimensionMode::Radius } else { DimensionMode::Diameter };
        }
        if d.mode == DimensionMode::Linear {
            // The points the dimension measures: a dragged segment's ends, read from the art.
            let ends = match &d.source {
                Some(DimensionSource::Segment { edge }) => edge.endpoints(cx.doc),
                _ => Some((d.a, d.b)),
            };
            let again = self.second.is_some_and(|(at, pointer)| at.distance(p).min(pointer.distance(p)) <= cx.tol(ANCHOR_REACH));
            d.orientation = match ends {
                Some((a, b)) if !again => orientation_at(a, b, p),
                _ => Orientation::Aligned,
            };
        }
        // A dimension dragged out from art starts with placeholder points. Read the art's points
        // before placing the dimension at the pointer. Clear the offset first: an out-of-range
        // offset from the last pointer position fails the read.
        if !matches!(d.mode, DimensionMode::Radius | DimensionMode::Diameter) {
            d.offset = 0.0;
        }
        if d.resolve(cx.doc).is_err() {
            return vec![];
        }
        // With Smart Guides on, a linear dimension's line lands on the level of a parallel
        // dimension line already drawn within the Smart Guides snapping tolerance. The lines are
        // read at the first preview and, with Smart Guides on, again when the document they come
        // from has changed since. They come from the document the next preview applies to: while
        // the interaction is in progress, the document as it began, which each preview starts
        // again from, so a dimension that a command moves or hides in between, and that the next
        // preview puts back, stays a level where it was, and the previews themselves do not make
        // the tool read the lines again. The preview of this dimension is not one of them.
        if d.mode == DimensionMode::Linear {
            if !self.began {
                self.preview_id = cx.doc.peek_next_id();
            }
            let (from, at) = match cx.interaction_doc {
                Some(began) => (began, (cx.revision.0, 0, std::ptr::from_ref(began).addr())),
                None => (cx.doc, (cx.revision.0, cx.revision.1, 0)),
            };
            if !self.began || (cx.smart_guides && self.levels_at != at) {
                self.levels = dimension_lines(from, (self.preview_id, [d.a, d.b]));
                self.levels_at = at;
            }
        }
        let level = if cx.smart_guides { line_level(&self.levels, d, p, cx.snap_tol()) } else { None };
        d.place(level.map_or(p, |(on_level, _)| on_level));
        if d.validate().is_err() {
            return vec![];
        }
        self.level_guide = level.map(|(_, ends)| ends);
        let mut actions = vec![];
        if !self.began {
            actions.push(Action::Begin("Create Dimension".into()));
            self.began = true;
        }
        actions.push(Action::Preview("dimension.create".into(), Self::params(d)));
        actions
    }
    /// Places the pending dimension at `p` and commits it.
    fn place(&mut self, cx: &ToolContext, p: Point) -> Vec<Action> {
        let mut out = self.preview(cx, p);
        if self.began {
            out.push(Action::Commit);
        }
        self.reset();
        out
    }
    fn reset(&mut self) {
        self.pending = None;
        self.press = None;
        self.press_on_anchor = false;
        self.on_end = false;
        self.corner = None;
        self.first_corner = None;
        self.points.clear();
        self.lines.clear();
        self.dragging = false;
        self.began = false;
        self.snap.clear();
        self.snapped = None;
        self.second = None;
        self.level_guide = None;
        self.levels.clear();
    }
    /// A plain click: picks a point or a line, or measures a circle's radius.
    fn click(&mut self, cx: &ToolContext, p: Point, target: Option<Target>, mods: Mods) -> Vec<Action> {
        match self.kind {
            Kind::Linear => {
                let (mut at, mut reference) = self.snap_linear(cx, p);
                let mut corner = self.corner;
                if mods.shift
                    && let Some((last, _)) = self.points.last()
                {
                    let snapped = at;
                    at = constrained(cx, *last, at);
                    reference = reference.filter(|r| r.position(cx.doc) == Some(at));
                    corner = corner.filter(|_| at.distance(snapped) <= 1e-9);
                }
                self.points.push((at, reference));
                if self.points.len() == 1 {
                    self.first_corner = corner;
                }
                if let [(a, ra), (b, rb)] = self.points.as_slice() {
                    let source = points_source(cx, (*a, ra, self.first_corner), (*b, rb, corner));
                    self.first_corner = None;
                    let mut d = self.recipe(DimensionMode::Linear, *a, *b, Point::ZERO, source);
                    if d.resolve(cx.doc).is_ok() {
                        self.second = Some((*b, p));
                        self.pending = Some(d);
                    }
                    self.points.clear();
                }
                vec![]
            }
            Kind::Angular => {
                let Some(edge) = pick(cx, p).filter(|e| e.is_straight(cx.doc)) else { return vec![] };
                if self.lines.first().is_some_and(|first| *first == edge) {
                    return vec![];
                }
                self.lines.push(edge);
                if let [first, second] = self.lines.as_slice() {
                    let mut d = self.recipe(
                        DimensionMode::Angular,
                        Point::ZERO,
                        Point::new(1.0, 0.0),
                        Point::ZERO,
                        Some(DimensionSource::Angle { first: first.clone(), second: second.clone() }),
                    );
                    if d.resolve(cx.doc).is_ok() {
                        d.offset = 30.0;
                        self.pending = Some(d);
                    }
                    self.lines.clear();
                }
                vec![]
            }
            Kind::Radial => {
                let Some(target @ Target::Radial { .. }) = target else { return vec![] };
                let Some(mut d) = self.dimension_for(&target, p) else { return vec![] };
                d.mode = DimensionMode::Radius;
                self.pending = Some(d);
                self.press = Some((p, Some(target)));
                self.place(cx, p)
            }
        }
    }
}

impl Tool for DimensionTool {
    fn id(&self) -> &'static str {
        "dimension"
    }
    fn busy(&self) -> bool {
        self.pending.is_some() || !self.points.is_empty() || !self.lines.is_empty()
    }
    fn cursor(&self, _: &ToolContext, _: Point, _: Mods) -> Cursor {
        Cursor::Crosshair
    }
    fn options(&self) -> Value {
        json!({"mode":self.kind.id(),"style":self.style})
    }
    fn set_option(&mut self, key: &str, value: &Value) {
        if key == "mode"
            && let Some(kind) = value.as_str().and_then(Kind::parse)
        {
            self.kind = kind;
        }
        if key == "style"
            && let Ok(o) = serde_json::from_value::<DimensionOptions>(value.clone())
            && o.validate().is_ok()
        {
            self.style = o;
        }
    }
    fn check_option(&self, key: &str, value: &Value) -> Result<(), String> {
        match key {
            "mode" => crate::option_check::one_of(key, value, &["linear", "angular", "radial", "radius", "diameter"]),
            "style" => DimensionOptions::from_params(value.clone()).map(|_| ()),
            _ => Err(crate::option_check::unknown(key)),
        }
    }
    fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec<Action> {
        self.at = ev.pos;
        self.shift = ev.mods.shift;
        match ev.kind {
            PointerKind::Move => {
                if self.pending.is_some() {
                    // Placing: the picks are done, their guides go.
                    self.snap.clear();
                    self.snapped = None;
                    return self.preview(cx, ev.pos);
                }
                self.hover = self.target(cx, ev.pos);
                self.snapped = (self.kind == Kind::Linear && self.lines.is_empty()).then(|| self.snap_linear(cx, ev.pos));
                if self.snapped.is_none() {
                    self.snap.clear();
                }
                vec![]
            }
            PointerKind::Down => {
                if self.pending.is_some() && !self.dragging {
                    self.press = Some((ev.pos, None));
                    return self.preview(cx, ev.pos);
                }
                // A Linear press on an anchor, on a corner of preview bounds or on the end of a
                // dimension's line, picks it unless it drags past the anchor's reach: moving a few
                // pixels before the release does not drag out the dimension of a segment under the
                // pointer.
                self.press_on_anchor = self.kind == Kind::Linear
                    && (anchor_under(cx, ev.pos).is_some()
                        || preview_corner(cx, ev.pos, &mut self.preview_boxes).is_some()
                        || on_dimensions(cx, ev.pos).is_some_and(|(_, end)| end));
                self.press = Some((ev.pos, self.target(cx, ev.pos)));
                vec![]
            }
            PointerKind::Drag => {
                if self.pending.is_some() && !self.dragging && self.press.is_some() {
                    return self.preview(cx, ev.pos);
                }
                if self.pending.is_none()
                    && let Some((start, Some(target))) = self.press.clone()
                    && start.distance(ev.pos) > cx.tol(if self.press_on_anchor { ANCHOR_REACH } else { 3.0 })
                    && self.points.is_empty()
                    && self.lines.is_empty()
                {
                    self.pending = self.dimension_for(&target, ev.pos);
                    self.dragging = self.pending.is_some();
                }
                if self.dragging { self.preview(cx, ev.pos) } else { vec![] }
            }
            PointerKind::Up => {
                if self.dragging {
                    return self.place(cx, ev.pos);
                }
                if self.pending.is_some() {
                    return if self.press.take().is_some() { self.place(cx, ev.pos) } else { vec![] };
                }
                match self.press.take() {
                    Some((start, target)) => self.click(cx, start, target, ev.mods),
                    _ => vec![],
                }
            }
            _ => vec![],
        }
    }
    fn key(&mut self, _: &ToolContext, key: ToolKey, _: Mods) -> Vec<Action> {
        if key == ToolKey::Escape {
            let cancel = self.began;
            self.reset();
            return if cancel { vec![Action::Cancel] } else { vec![] };
        }
        vec![]
    }
    /// A dropped drag is canceled as by Escape. A dropped click picks nothing, and the points or
    /// lines earlier clicks picked stay.
    fn drop_press(&mut self, cx: &ToolContext) -> Vec<Action> {
        if self.dragging {
            return self.key(cx, ToolKey::Escape, Mods::default());
        }
        self.press = None;
        if self.pending.is_some() && self.began {
            self.began = false;
            self.level_guide = None;
            vec![Action::Cancel]
        } else {
            vec![]
        }
    }
    fn deactivate(&mut self, cx: &ToolContext) -> Vec<Action> {
        self.key(cx, ToolKey::Escape, Mods::default())
    }
    fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
        let color = [60, 150, 255];
        let mut out = vec![];
        let segment = |edge: &SegmentRef, out: &mut Vec<Overlay>| {
            if let Some(sp) = cx.doc.node(edge.node).and_then(Node::path_data).and_then(|p| p.subpaths.get(edge.subpath))
                && edge.segment < sp.segment_count()
            {
                let c = sp.segment(edge.segment);
                let mut path = BezPath::new();
                path.move_to(c.p0);
                path.curve_to(c.p1, c.p2, c.p3);
                out.push(Overlay::Path { path, color, width: 3.0, dashed: false });
            }
        };
        if self.pending.is_none() {
            match &self.hover {
                Some(Target::Segment(edge)) => {
                    segment(edge, &mut out);
                    if let Some((a, b)) = edge.endpoints(cx.doc) {
                        for p in [a, b] {
                            out.push(Overlay::Anchor { p, color, filled: true, size: 6.0 });
                        }
                        if cx.measurement_labels
                            && let Ok(text) = self.style.label(a.distance(b), false)
                        {
                            out.push(Overlay::Measure { p: self.at + Vec2::new(12.0, 12.0), text });
                        }
                    }
                }
                Some(Target::Corner { first, second, at }) => {
                    segment(first, &mut out);
                    segment(second, &mut out);
                    out.push(Overlay::Anchor { p: *at, color, filled: true, size: 7.0 });
                }
                Some(Target::Radial { center, radius, .. }) => {
                    out.push(Overlay::Anchor { p: *center, color, filled: false, size: 6.0 });
                    let toward = self.at - *center;
                    if toward.hypot() > 1e-9 {
                        out.push(Overlay::Line { a: *center, b: *center + toward / toward.hypot() * *radius, color, dashed: true });
                    }
                }
                None => {}
            }
        }
        for (p, _) in &self.points {
            out.push(Overlay::Anchor { p: *p, color, filled: true, size: 6.0 });
        }
        for edge in &self.lines {
            segment(edge, &mut out);
        }
        // Linear: show where the next click lands (anchor ring, or a dot on a line), and draw the
        // rubber band to that point, so the user sees the snap before clicking (#2516).
        let linear_pick = self.kind == Kind::Linear && self.pending.is_none() && self.lines.is_empty();
        let snapped = self.snapped.clone().filter(|_| linear_pick);
        if let Some((q, reference)) = &snapped
            && (reference.is_some() || self.on_end || q.distance(self.at) > 1e-9)
        {
            let on_anchor = reference.is_some() || self.on_end;
            out.push(Overlay::Anchor { p: *q, color, filled: !on_anchor, size: if on_anchor { 10.0 } else { 6.0 } });
        }
        if let Some((p, _)) = self.points.last() {
            let target = snapped.map_or(self.at, |(q, _)| q);
            let b = if self.shift { constrained(cx, *p, target) } else { target };
            out.push(Overlay::Line { a: *p, b, color, dashed: true });
        }
        // The Smart Guides of the point the next click picks (after the rubber band).
        if linear_pick {
            out.extend(self.snap.guides().iter().cloned());
        }
        // A dimension line placed on the level of another: one alignment guide across both lines,
        // unless Alignment Guides are off.
        if cx.alignment_guides
            && let (Some(d), Some((c, e))) = (&self.pending, self.level_guide)
        {
            let (a, b) = d.line_ends();
            let u = d.direction();
            let along = |q: &Point| q.to_vec2().dot(u);
            let ends = [a, b, c, e];
            if let (Some(lo), Some(hi)) =
                (ends.iter().min_by(|p, q| along(p).total_cmp(&along(q))), ends.iter().max_by(|p, q| along(p).total_cmp(&along(q))))
            {
                out.push(Overlay::Line { a: *lo, b: *hi, color: cx.smart_guide_color, dashed: false });
            }
        }
        out
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::testutil::*;
    use vectorcraft_doc::Selection;

    /// A dropped click picks nothing and keeps the point an earlier click picked. A dropped drag
    /// out from a segment is canceled as by Escape.
    #[test]
    fn a_dropped_press_keeps_the_earlier_picks() {
        let (d, _) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let c = cx(&d, &s, &p);
        let ev = |kind, x: f64, y: f64| PointerEvent::new(kind, x, y);
        let mut t = DimensionTool::default();
        t.pointer(&c, &ev(PointerKind::Down, 400.0, 400.0));
        t.pointer(&c, &ev(PointerKind::Up, 400.0, 400.0));
        assert_eq!(t.points.len(), 1);
        // The engine sends the release after the drop.
        t.pointer(&c, &ev(PointerKind::Down, 450.0, 420.0));
        assert!(t.drop_press(&c).is_empty());
        assert!(t.pointer(&c, &ev(PointerKind::Up, 450.0, 420.0)).is_empty());
        assert_eq!(t.points.len(), 1, "the earlier pick stays and the dropped click picks nothing");
        assert!(t.pending.is_none() && t.busy());
        let mut t = DimensionTool::default();
        t.pointer(&c, &ev(PointerKind::Down, 150.0, 100.0));
        let acts = t.pointer(&c, &ev(PointerKind::Drag, 150.0, 60.0));
        assert!(matches!(acts.first(), Some(Action::Begin(_))), "{acts:?}");
        assert_eq!(t.drop_press(&c), vec![Action::Cancel]);
        assert!(!t.busy());
        assert!(t.pointer(&c, &ev(PointerKind::Up, 150.0, 60.0)).is_empty(), "the release places nothing");
    }

    /// Of two dimension lines on one level, a line the pointer lies across wins over a line whose
    /// end is nearer the pointer.
    #[test]
    fn a_line_the_pointer_lies_across_wins_on_one_level() {
        let pt = Point::new;
        let d = DimensionTool::default().recipe(DimensionMode::Linear, pt(200.0, 200.0), pt(300.0, 200.0), pt(250.0, 200.0), None);
        let across = ((pt(0.0, 170.0), pt(400.0, 170.0)), Vec2::new(1.0, 0.0));
        let beside = ((pt(100.0, 170.0), pt(200.0, 170.0)), Vec2::new(1.0, 0.0));
        for levels in [[beside, across], [across, beside]] {
            let (at, ends) = line_level(&levels, &d, pt(250.0, 172.0), 4.0).expect("on the level");
            assert!(at.distance(pt(250.0, 170.0)) < 1e-9, "{at:?}");
            assert_eq!(ends, across.0);
        }
    }

    /// The lines of the dimensions in the document are read only for a linear dimension. They are
    /// read with Smart Guides off too, so a line placed after Smart Guides are turned on lines up.
    #[test]
    fn dimension_lines_are_read_only_for_a_linear_dimension() {
        use vectorcraft_doc::{Node, NodeKind};
        let (mut d, _) = doc_with_rect();
        let id = d.alloc_id();
        let mut drawn = Node::new(id, NodeKind::Group { children: vec![], clip: false });
        let pt = Point::new;
        drawn.extras_mut().dimension =
            Some(Box::new(DimensionTool::default().recipe(DimensionMode::Linear, pt(300.0, 300.0), pt(400.0, 300.0), pt(350.0, 300.0), None)));
        let l = d.layers[0].id;
        d.insert(Some(l), usize::MAX, drawn).unwrap();
        let (s, p) = (Selection::default(), paint());
        let ev = |kind, x: f64, y: f64| PointerEvent::new(kind, x, y);
        let c = cx(&d, &s, &p);
        let off = ToolContext { smart_guides: false, ..cx(&d, &s, &p) };
        let mut t = DimensionTool::default();
        for (x, y) in [(400.0, 400.0), (450.0, 400.0)] {
            t.pointer(&off, &ev(PointerKind::Down, x, y));
            t.pointer(&off, &ev(PointerKind::Up, x, y));
        }
        assert!(matches!(t.pointer(&off, &ev(PointerKind::Move, 420.0, 450.0)).first(), Some(Action::Begin(_))));
        assert_eq!(t.levels.len(), 1);
        let acts = t.pointer(&c, &ev(PointerKind::Move, 420.0, 302.0));
        let Some(Action::Preview(_, params)) = acts.last() else { panic!("{acts:?}") };
        assert_eq!(params["offset"], json!(-100.0), "on the level of the line drawn at y = 300");
        let mut t = DimensionTool::default();
        t.set_option("mode", &json!("angular"));
        t.pointer(&c, &ev(PointerKind::Down, 100.0, 100.0));
        assert!(matches!(t.pointer(&c, &ev(PointerKind::Drag, 130.0, 140.0)).first(), Some(Action::Begin(_))));
        assert!(t.levels.is_empty(), "an angular dimension reads no lines");
        // A radius (dragged outwards from a circle) and a diameter (inwards) read none either.
        let circle = d.alloc_id();
        let round = vectorcraft_geom::shapes::ellipse(Rect::new(400.0, 150.0, 500.0, 250.0));
        d.insert(Some(l), usize::MAX, Node::path(circle, round, vectorcraft_doc::Appearance::default_art())).unwrap();
        let c = cx(&d, &s, &p);
        for (to, mode) in [(530.0, "radius"), (470.0, "diameter")] {
            let mut t = DimensionTool::default();
            t.set_option("mode", &json!("radial"));
            t.pointer(&c, &ev(PointerKind::Down, 500.0, 200.0));
            let acts = t.pointer(&c, &ev(PointerKind::Drag, to, 200.0));
            assert!(matches!(acts.first(), Some(Action::Begin(_))), "{mode}: {acts:?}");
            let Some(Action::Preview(_, params)) = acts.last() else { panic!("{mode}: {acts:?}") };
            assert_eq!(params["mode"], json!(mode));
            assert!(t.levels.is_empty(), "a {mode} dimension reads no lines");
        }
    }

    /// A dimension hidden, locked or deleted while another is placed is no longer a level, and one
    /// shown again or grouped is: the lines are read again when the document's revision moves. The
    /// preview of the dimension itself, with the id the document gave next when it began, is never
    /// a level.
    #[test]
    fn dimension_lines_are_read_again_when_the_document_changes() {
        use vectorcraft_doc::{Node, NodeKind};
        let (mut d, _) = doc_with_rect();
        let pt = Point::new;
        let line = |y: f64| Some(Box::new(DimensionTool::default().recipe(DimensionMode::Linear, pt(300.0, y), pt(400.0, y), pt(350.0, y), None)));
        let id = d.alloc_id();
        let mut drawn = Node::new(id, NodeKind::Group { children: vec![], clip: false });
        drawn.extras_mut().dimension = line(300.0);
        let l = d.layers[0].id;
        d.insert(Some(l), usize::MAX, drawn).unwrap();
        let (s, p) = (Selection::default(), paint());
        let ev = |kind, x: f64, y: f64| PointerEvent::new(kind, x, y);
        let offset = |t: &mut DimensionTool, c: &ToolContext| {
            let acts = t.pointer(c, &ev(PointerKind::Move, 420.0, 302.0));
            let Some(Action::Preview(_, params)) = acts.last() else { panic!("{acts:?}") };
            params["offset"].clone()
        };
        let mut t = DimensionTool::default();
        let c = cx(&d, &s, &p);
        for (x, y) in [(400.0, 400.0), (450.0, 400.0)] {
            t.pointer(&c, &ev(PointerKind::Down, x, y));
            t.pointer(&c, &ev(PointerKind::Up, x, y));
        }
        assert!(matches!(t.pointer(&c, &ev(PointerKind::Move, 420.0, 450.0)).first(), Some(Action::Begin(_))));
        assert_eq!(offset(&mut t, &c), json!(-100.0), "on the level of the line drawn at y = 300");
        // With Smart Guides off the lines are not read; turned on, they are read as they are now.
        let mut hidden = d.clone();
        hidden.node_mut(id).unwrap().visible = false;
        let off = ToolContext { revision: (0, 1), smart_guides: false, ..cx(&hidden, &s, &p) };
        offset(&mut t, &off);
        assert_eq!(t.levels.len(), 1, "not read with Smart Guides off");
        let on = ToolContext { revision: (0, 1), ..cx(&hidden, &s, &p) };
        assert_eq!(offset(&mut t, &on), json!(-98.0), "read when Smart Guides are turned on");
        for (rev, edit) in [(1, "hidden"), (2, "locked"), (3, "deleted")] {
            let mut doc = d.clone();
            match edit {
                "hidden" => doc.node_mut(id).unwrap().visible = false,
                "locked" => doc.node_mut(id).unwrap().locked = true,
                _ => {
                    doc.remove(id).unwrap();
                }
            }
            let c = ToolContext { revision: (0, rev), ..cx(&doc, &s, &p) };
            assert_eq!(offset(&mut t, &c), json!(-98.0), "{edit}: off every level");
        }
        let c = ToolContext { revision: (0, 4), ..cx(&d, &s, &p) };
        assert_eq!(offset(&mut t, &c), json!(-100.0), "shown again: on the level");
        // Grouped while it is placed, in a group with the id the preview takes: still a level.
        let mut doc = d.clone();
        let moved = doc.remove(id).unwrap();
        let group = doc.alloc_id();
        doc.insert(Some(l), usize::MAX, Node::new(group, NodeKind::Group { children: vec![moved], clip: false })).unwrap();
        let c = ToolContext { revision: (0, 5), ..cx(&doc, &s, &p) };
        assert_eq!(offset(&mut t, &c), json!(-100.0), "grouped: on the level");
        // The dimension's own preview, which takes the next id and measures its points, is not a
        // level. Another dimension that takes that id is.
        let mut own = DimensionTool::default().recipe(DimensionMode::Linear, pt(400.0, 400.0), pt(450.0, 400.0), pt(425.0, 400.0), None);
        own.place(pt(425.0, 304.0));
        assert_eq!(own.line_ends(), (pt(400.0, 304.0), pt(450.0, 304.0)));
        for (rev, made, level) in [(6, Some(Box::new(own)), json!(-98.0)), (7, line(304.0), json!(-96.0))] {
            let mut doc = d.clone();
            let mut preview = Node::new(doc.alloc_id(), NodeKind::Group { children: vec![], clip: false });
            preview.extras_mut().dimension = made;
            doc.node_mut(id).unwrap().visible = false;
            doc.insert(Some(l), usize::MAX, preview).unwrap();
            let c = ToolContext { revision: (0, rev), ..cx(&doc, &s, &p) };
            assert_eq!(offset(&mut t, &c), level, "revision {rev}");
        }
    }

    /// While the interaction is in progress, the lines are read from the document it began with,
    /// which the next preview starts from, not from the document a command changed in between: a
    /// dimension moved or hidden there stays a level where it was.
    #[test]
    fn dimension_lines_are_read_from_the_document_the_preview_applies_to() {
        use vectorcraft_doc::{Node, NodeKind};
        let (mut d, _) = doc_with_rect();
        let pt = Point::new;
        let line = |y: f64| Some(Box::new(DimensionTool::default().recipe(DimensionMode::Linear, pt(300.0, y), pt(400.0, y), pt(350.0, y), None)));
        let id = d.alloc_id();
        let mut drawn = Node::new(id, NodeKind::Group { children: vec![], clip: false });
        drawn.extras_mut().dimension = line(300.0);
        let l = d.layers[0].id;
        d.insert(Some(l), usize::MAX, drawn).unwrap();
        let (s, p) = (Selection::default(), paint());
        let ev = |kind, x: f64, y: f64| PointerEvent::new(kind, x, y);
        let offset = |t: &mut DimensionTool, c: &ToolContext, y: f64| {
            let acts = t.pointer(c, &ev(PointerKind::Move, 420.0, y));
            let Some(Action::Preview(_, params)) = acts.last() else { panic!("{acts:?}") };
            params["offset"].clone()
        };
        let mut t = DimensionTool::default();
        let c = cx(&d, &s, &p);
        for (x, y) in [(400.0, 400.0), (450.0, 400.0)] {
            t.pointer(&c, &ev(PointerKind::Down, x, y));
            t.pointer(&c, &ev(PointerKind::Up, x, y));
        }
        assert!(matches!(t.pointer(&c, &ev(PointerKind::Move, 420.0, 450.0)).first(), Some(Action::Begin(_))));
        for (rev, edit) in [(1, "moved"), (2, "hidden")] {
            let mut doc = d.clone();
            match edit {
                "moved" => doc.node_mut(id).unwrap().extras_mut().dimension = line(320.0),
                _ => doc.node_mut(id).unwrap().visible = false,
            }
            let c = ToolContext { revision: (0, rev), interaction_doc: Some(&d), ..cx(&doc, &s, &p) };
            assert_eq!(offset(&mut t, &c, 318.0), json!(-82.0), "{edit}: not on the level at y = 320");
            assert_eq!(offset(&mut t, &c, 302.0), json!(-100.0), "{edit}: on the level at y = 300");
        }
        // A revision that moves with the same document the interaction began with does not read
        // the lines again; another document it began with does.
        t.levels.clear();
        let c = ToolContext { revision: (0, 3), interaction_doc: Some(&d), ..cx(&d, &s, &p) };
        assert_eq!(offset(&mut t, &c, 302.0), json!(-98.0), "not read again");
        let again = d.clone();
        let c = ToolContext { revision: (0, 4), interaction_doc: Some(&again), ..cx(&d, &s, &p) };
        assert_eq!(offset(&mut t, &c, 302.0), json!(-100.0), "read again");
    }

    /// The preview of the dimension itself does not count toward the 20,000 objects read: a
    /// dimension that was the last one read stays a level once the preview is in front of it.
    #[test]
    fn the_preview_does_not_push_the_last_dimension_read_out_of_reach() {
        use std::sync::Arc;
        use vectorcraft_doc::{Node, NodeKind};
        let (mut d, _) = doc_with_rect();
        let pt = Point::new;
        let line = |y: f64| Some(Box::new(DimensionTool::default().recipe(DimensionMode::Linear, pt(300.0, y), pt(400.0, y), pt(350.0, y), None)));
        let mut drawn = Node::new(d.alloc_id(), NodeKind::Group { children: vec![], clip: false });
        drawn.extras_mut().dimension = line(300.0);
        // The layer, the group and 19,997 empty groups before the dimension: it is the 20,000th.
        let mut children = vec![Arc::new(drawn)];
        children.extend((0..19_997).map(|_| Arc::new(Node::new(d.alloc_id(), NodeKind::Group { children: vec![], clip: false }))));
        let l = d.layers[0].id;
        let group = Node::new(d.alloc_id(), NodeKind::Group { children, clip: false });
        d.insert(Some(l), usize::MAX, group).unwrap();
        let (s, p) = (Selection::default(), paint());
        let ev = |kind, x: f64, y: f64| PointerEvent::new(kind, x, y);
        let offset = |t: &mut DimensionTool, c: &ToolContext| {
            let acts = t.pointer(c, &ev(PointerKind::Move, 420.0, 302.0));
            let Some(Action::Preview(_, params)) = acts.last() else { panic!("{acts:?}") };
            params["offset"].clone()
        };
        let mut t = DimensionTool::default();
        let c = cx(&d, &s, &p);
        for (x, y) in [(400.0, 400.0), (450.0, 400.0)] {
            t.pointer(&c, &ev(PointerKind::Down, x, y));
            t.pointer(&c, &ev(PointerKind::Up, x, y));
        }
        assert!(matches!(t.pointer(&c, &ev(PointerKind::Move, 420.0, 450.0)).first(), Some(Action::Begin(_))));
        assert_eq!(offset(&mut t, &c), json!(-100.0), "the 20,000th object is read");
        let mut previewed = d.clone();
        let mut preview = Node::new(previewed.alloc_id(), NodeKind::Group { children: vec![], clip: false });
        preview.extras_mut().dimension =
            Some(Box::new(DimensionTool::default().recipe(DimensionMode::Linear, pt(400.0, 400.0), pt(450.0, 400.0), pt(425.0, 304.0), None)));
        previewed.insert(Some(l), usize::MAX, preview).unwrap();
        let c = ToolContext { revision: (0, 1), ..cx(&previewed, &s, &p) };
        assert_eq!(offset(&mut t, &c), json!(-100.0), "still read with the preview in front");
    }

    #[test]
    fn a_dropped_placement_press_does_not_commit_the_dimension() {
        let (d, _) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let c = cx(&d, &s, &p);
        let ev = |kind, x: f64, y: f64| PointerEvent::new(kind, x, y);
        let mut t = DimensionTool::default();
        for (x, y) in [(400.0, 400.0), (450.0, 420.0)] {
            assert!(t.pointer(&c, &ev(PointerKind::Down, x, y)).is_empty());
            assert!(t.pointer(&c, &ev(PointerKind::Up, x, y)).is_empty());
        }
        assert!(t.pending.is_some());
        assert!(matches!(t.pointer(&c, &ev(PointerKind::Move, 470.0, 450.0)).first(), Some(Action::Begin(_))));
        assert!(matches!(t.pointer(&c, &ev(PointerKind::Down, 470.0, 450.0)).last(), Some(Action::Preview(_, _))));
        assert_eq!(t.drop_press(&c), vec![Action::Cancel]);
        assert!(t.pointer(&c, &ev(PointerKind::Up, 470.0, 450.0)).is_empty());
        assert!(t.pending.is_some(), "the dimension can still be placed");
        assert!(matches!(t.pointer(&c, &ev(PointerKind::Down, 480.0, 460.0)).last(), Some(Action::Preview(_, _))));
        let dragged = t.pointer(&c, &ev(PointerKind::Drag, 490.0, 470.0));
        assert!(matches!(dragged.last(), Some(Action::Preview(_, _))), "{dragged:?}");
        let placed = t.pointer(&c, &ev(PointerKind::Up, 490.0, 470.0));
        assert!(matches!(placed.last(), Some(Action::Commit)), "{placed:?}");
    }

    /// A pointer position too far away to place the dimension shows no preview, and the preview
    /// comes back where the pointer returns.
    #[test]
    fn placement_recovers_after_a_position_out_of_range() {
        let (d, _) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let c = cx(&d, &s, &p);
        let mut t = DimensionTool::default();
        for (x, y) in [(400.0, 400.0), (450.0, 400.0)] {
            t.pointer(&c, &PointerEvent::new(PointerKind::Down, x, y));
            t.pointer(&c, &PointerEvent::new(PointerKind::Up, x, y));
        }
        assert!(t.pointer(&c, &PointerEvent::new(PointerKind::Move, 420.0, 3.0e6)).is_empty());
        let acts = t.pointer(&c, &PointerEvent::new(PointerKind::Move, 420.0, 450.0));
        let Some(Action::Preview(_, params)) = acts.last() else { panic!("{acts:?}") };
        assert_eq!(params["offset"], json!(50.0));
    }

    /// Dragging out from a segment previews the dimension at the pointer from the first drag on.
    #[test]
    fn the_first_preview_of_a_segment_drag_is_at_the_pointer() {
        let (d, _) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let c = cx(&d, &s, &p);
        let mut t = DimensionTool::default();
        t.pointer(&c, &PointerEvent::new(PointerKind::Down, 150.0, 100.0));
        let acts = t.pointer(&c, &PointerEvent::new(PointerKind::Drag, 150.0, 60.0));
        let Some(Action::Preview(_, params)) = acts.last() else { panic!("{acts:?}") };
        assert_eq!(params["offset"], json!(-40.0), "40 pt above the top edge");
    }

    /// Dragging out from a corner previews the angle at the pointer's distance from the corner
    /// from the first drag on.
    #[test]
    fn the_first_preview_of_a_corner_drag_is_at_the_pointer() {
        let (d, _) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let c = cx(&d, &s, &p);
        let mut t = DimensionTool::default();
        t.set_option("mode", &json!("angular"));
        t.pointer(&c, &PointerEvent::new(PointerKind::Down, 100.0, 100.0));
        let acts = t.pointer(&c, &PointerEvent::new(PointerKind::Drag, 130.0, 140.0));
        let Some(Action::Preview(_, params)) = acts.last() else { panic!("{acts:?}") };
        assert_eq!(params["vertex"], json!([100.0, 100.0]));
        assert_eq!(params["offset"], json!(50.0), "50 pt from the corner");
    }

    /// A Linear press on an anchor picks that anchor even when the pointer moves a few pixels
    /// before the release: it does not drag out the dimension of a segment that ends there. Both
    /// picks keep their links to the path, so the dimension measures between the two anchors.
    #[test]
    fn a_press_on_an_anchor_picks_it_when_the_pointer_moves() {
        let (d, id) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let c = cx(&d, &s, &p);
        let ev = |kind, x: f64, y: f64| PointerEvent::new(kind, x, y);
        let mut t = DimensionTool::default();
        for ((x, y), (dx, dy)) in [((100.0, 100.0), (3.5, 1.0)), ((200.0, 200.0), (-4.0, -2.0))] {
            assert!(t.pointer(&c, &ev(PointerKind::Down, x, y)).is_empty());
            assert!(t.pointer(&c, &ev(PointerKind::Drag, x + dx, y + dy)).is_empty(), "no segment dimension is dragged out");
            assert!(t.pointer(&c, &ev(PointerKind::Up, x + dx, y + dy)).is_empty(), "nothing is committed");
        }
        let d = t.pending.as_ref().expect("both anchors were picked");
        assert_eq!((d.a, d.b), (Point::new(100.0, 100.0), Point::new(200.0, 200.0)));
        let anchor = |anchor| Some(PointRef { node: id, subpath: 0, anchor });
        assert_eq!(d.source, Some(DimensionSource::Points { a: anchor(0), b: anchor(2), vertex: None, free_a: None, free_b: None }));
        // Dragged past the anchor's reach, the press drags out the dimension of a segment there.
        let mut t = DimensionTool::default();
        t.pointer(&c, &ev(PointerKind::Down, 100.0, 100.0));
        assert!(t.pointer(&c, &ev(PointerKind::Drag, 103.0, 106.0)).is_empty());
        let acts = t.pointer(&c, &ev(PointerKind::Drag, 100.0, 60.0));
        assert!(matches!(acts.first(), Some(Action::Begin(_))), "{acts:?}");
        assert!(matches!(t.pointer(&c, &ev(PointerKind::Up, 100.0, 60.0)).last(), Some(Action::Commit)));
    }

    /// A point picked on a segment, not on an anchor, keeps its place along the segment. A point
    /// off the art is held against the anchors of the other point's path. Both then follow the
    /// path, as the anchor at the other end does.
    #[test]
    fn points_off_anchors_are_held_against_the_path() {
        use vectorcraft_doc::dimension::FreePoint;
        let (d, id) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let c = cx(&d, &s, &p);
        let click = |t: &mut DimensionTool, x: f64, y: f64| {
            t.pointer(&c, &PointerEvent::new(PointerKind::Down, x, y));
            t.pointer(&c, &PointerEvent::new(PointerKind::Up, x, y));
        };
        let mut t = DimensionTool::default();
        click(&mut t, 100.0, 100.0);
        click(&mut t, 200.0, 150.0);
        let pending = t.pending.as_ref().expect("both points were picked");
        let anchor = Some(PointRef { node: id, subpath: 0, anchor: 0 });
        let Some(DimensionSource::Points { a, b: None, vertex: None, free_a: None, free_b: Some(FreePoint::OnSegment { edge, t }) }) =
            &pending.source
        else {
            panic!("{:?}", pending.source)
        };
        assert_eq!((a, edge), (&anchor, &SegmentRef { node: id, subpath: 0, segment: 1 }));
        assert!((t - 0.5).abs() < 1e-9, "{t}");
        let mut t = DimensionTool::default();
        click(&mut t, 400.0, 400.0);
        click(&mut t, 200.0, 200.0);
        let pending = t.pending.as_ref().expect("both points were picked");
        let Some(DimensionSource::Points { free_a: Some(free), b: Some(b), .. }) = &pending.source else { panic!("{:?}", pending.source) };
        let FreePoint::Anchors { node, anchors, across } = free else { panic!("{free:?}") };
        assert_eq!((*node, anchors.len(), *across, b.node, b.anchor), (id, 3, 0.0, id, 2));
        let at = free.position(&d).expect("the anchors that hold it exist");
        assert!(at.distance(pending.a) < 1e-9, "{at:?} {:?}", pending.a);
    }

    /// A point that Smart Guides put in line with the path's center is held, where the guide put
    /// it, against the anchors of the path at the other end.
    #[test]
    fn a_point_smart_guides_place_is_held_against_the_path() {
        use vectorcraft_doc::dimension::FreePoint;
        let (d, id) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let c = cx(&d, &s, &p);
        assert!(c.smart_guides);
        let mut t = DimensionTool::default();
        for (x, y) in [(200.0, 200.0), (151.5, 330.0)] {
            t.pointer(&c, &PointerEvent::new(PointerKind::Move, x, y));
            t.pointer(&c, &PointerEvent::new(PointerKind::Down, x, y));
            t.pointer(&c, &PointerEvent::new(PointerKind::Up, x, y));
        }
        let pending = t.pending.as_ref().expect("both points were picked");
        assert!((pending.b.x - 150.0).abs() < 1e-9, "in line with the center: {:?}", pending.b);
        let Some(DimensionSource::Points { a: Some(a), free_b: Some(free), .. }) = &pending.source else { panic!("{:?}", pending.source) };
        assert!(matches!(free, FreePoint::Anchors { node, .. } if *node == id), "{free:?}");
        assert_eq!(a.node, id);
        let at = free.position(&d).expect("the anchors that hold it exist");
        assert!(at.distance(pending.b) < 1e-9, "{at:?} {:?}", pending.b);
    }

    /// With Use Preview Bounds on, clicks by the corners of a stroked path land on the corners of
    /// its preview bounds, held against the path, so the dimension measures the outside of the
    /// stroke as W and H do. Without a stroke, or with the preference off, the anchors are picked.
    #[test]
    fn with_preview_bounds_points_land_on_the_corners_of_the_stroke() {
        use vectorcraft_doc::dimension::FreePoint;
        let (d, id) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let pick = |c: &ToolContext| {
            let mut t = DimensionTool::default();
            for (x, y) in [(101.0, 101.0), (199.0, 199.0)] {
                t.pointer(c, &PointerEvent::new(PointerKind::Move, x, y));
                t.pointer(c, &PointerEvent::new(PointerKind::Down, x, y));
                t.pointer(c, &PointerEvent::new(PointerKind::Up, x, y));
            }
            t.pending.expect("both points were picked")
        };
        let c = ToolContext { preview_bounds: true, ..cx(&d, &s, &p) };
        let pending = pick(&c);
        let near = |a: Point, b: Point| a.distance(b) < 1e-9;
        assert!(near(pending.a, Point::new(99.5, 99.5)) && near(pending.b, Point::new(200.5, 200.5)), "{:?} {:?}", pending.a, pending.b);
        let Some(DimensionSource::Points { a: None, b: None, free_a: Some(free_a), free_b: Some(free_b), .. }) = &pending.source else {
            panic!("{:?}", pending.source)
        };
        for (free, at) in [(free_a, pending.a), (free_b, pending.b)] {
            assert!(matches!(free, FreePoint::Anchors { node, .. } if *node == id), "{free:?}");
            assert!(free.position(&d).expect("the anchors that hold it exist").distance(at) < 1e-9);
        }
        // A line of another path through the corner leaves the point held against the rectangle.
        let mut crossed = d.clone();
        let (l, line) = (crossed.layers[0].id, crossed.alloc_id());
        let path = vectorcraft_geom::PathData::single(vectorcraft_geom::SubPath::polyline(&[Point::new(0.0, 99.5), Point::new(300.0, 99.5)], false));
        crossed.insert(Some(l), 1, Node::path(line, path, vectorcraft_doc::Appearance::default_art())).expect("the line");
        let pending = pick(&ToolContext { preview_bounds: true, ..cx(&crossed, &s, &p) });
        assert!(near(pending.a, Point::new(99.5, 99.5)), "{:?}", pending.a);
        let Some(DimensionSource::Points { free_a: Some(free_a), .. }) = &pending.source else { panic!("{:?}", pending.source) };
        assert!(matches!(free_a, FreePoint::Anchors { node, .. } if *node == id), "{free_a:?}");
        let anchors = |pending: &Dimension| (pending.a, pending.b, pending.source.clone());
        let anchor = |anchor| Some(PointRef { node: id, subpath: 0, anchor });
        let linked = DimensionSource::Points { a: anchor(0), b: anchor(2), vertex: None, free_a: None, free_b: None };
        let off = pick(&cx(&d, &s, &p));
        assert_eq!(anchors(&off), (Point::new(100.0, 100.0), Point::new(200.0, 200.0), Some(linked.clone())), "preference off");
        let mut bare = d.clone();
        bare.node_mut(id).expect("the rectangle").appearance = vectorcraft_doc::Appearance::default().into();
        let c = ToolContext { preview_bounds: true, ..cx(&bare, &s, &p) };
        assert_eq!(anchors(&pick(&c)), (Point::new(100.0, 100.0), Point::new(200.0, 200.0), Some(linked)), "no stroke");
        // A compound path's stroke: the points are held against the member that reaches the
        // corner, not the small hole drawn first.
        let mut compound = vectorcraft_doc::Document::new(500.0, 500.0);
        let (l, hole, part, whole) = (compound.layers[0].id, compound.alloc_id(), compound.alloc_id(), compound.alloc_id());
        let square = |id, a: f64, b: f64| {
            std::sync::Arc::new(Node::path(id, vectorcraft_geom::shapes::rectangle(vectorcraft_geom::Rect::new(a, a, b, b)), Default::default()))
        };
        let children = vec![square(hole, 140.0, 160.0), square(part, 100.0, 200.0)];
        let mut n = Node::new(whole, NodeKind::Compound { children, rule: Default::default() });
        n.appearance = vectorcraft_doc::Appearance::default_art().into();
        compound.insert(Some(l), 0, n).expect("the compound path");
        let pending = pick(&ToolContext { preview_bounds: true, ..cx(&compound, &s, &p) });
        assert!(near(pending.a, Point::new(99.5, 99.5)) && near(pending.b, Point::new(200.5, 200.5)), "{:?} {:?}", pending.a, pending.b);
        let Some(DimensionSource::Points { free_a: Some(free_a), free_b: Some(free_b), .. }) = &pending.source else {
            panic!("{:?}", pending.source)
        };
        for free in [free_a, free_b] {
            assert!(matches!(free, FreePoint::Anchors { node, .. } if *node == part), "{free:?}");
        }
        // A 40 point stroke, and an Offset Path effect on the fill, put the corners further from
        // the path than a click on the path reaches: the points still land there and stay linked.
        let mut wide = vectorcraft_doc::Appearance::default_art();
        wide.stroke_mut().expect("a stroke").width = 40.0;
        let mut offset = vectorcraft_doc::Appearance::default_art();
        let effect =
            vectorcraft_doc::Effect { id: "path.offsetPath".into(), params: serde_json::json!({"offset": 30, "joins": "miter"}), visible: true };
        offset.effects_mut(Some(0)).expect("the fill").push(effect);
        for (appearance, out) in [(wide, 20.0), (offset, 30.0)] {
            let mut d = d.clone();
            d.node_mut(id).expect("the rectangle").appearance = appearance.into();
            let c = ToolContext { preview_bounds: true, ..cx(&d, &s, &p) };
            let mut t = DimensionTool::default();
            for (x, y) in [(101.0 - out, 101.0 - out), (199.0 + out, 199.0 + out)] {
                t.pointer(&c, &PointerEvent::new(PointerKind::Move, x, y));
                t.pointer(&c, &PointerEvent::new(PointerKind::Down, x, y));
                t.pointer(&c, &PointerEvent::new(PointerKind::Up, x, y));
            }
            let pending = t.pending.expect("both points were picked");
            let (a, b) = (Point::new(100.0 - out, 100.0 - out), Point::new(200.0 + out, 200.0 + out));
            assert!(near(pending.a, a) && near(pending.b, b), "{out}: {:?} {:?}", pending.a, pending.b);
            let Some(DimensionSource::Points { free_a: Some(free_a), free_b: Some(free_b), .. }) = &pending.source else {
                panic!("{out}: {:?}", pending.source)
            };
            for free in [free_a, free_b] {
                assert!(matches!(free, FreePoint::Anchors { node, .. } if *node == id), "{out}: {free:?}");
            }
        }
        // A press on a corner over another path's segment picks the corner when the pointer moves
        // a few pixels before the release, as on an anchor.
        let mut d = d.clone();
        let mut wide = vectorcraft_doc::Appearance::default_art();
        wide.stroke_mut().expect("a stroke").width = 40.0;
        d.node_mut(id).expect("the rectangle").appearance = wide.into();
        let (l, line) = (d.layers[0].id, d.alloc_id());
        let path = vectorcraft_geom::PathData::single(vectorcraft_geom::SubPath::polyline(&[Point::new(0.0, 82.0), Point::new(95.0, 82.0)], false));
        d.insert(Some(l), 1, Node::path(line, path, Default::default())).expect("the line");
        let c = ToolContext { preview_bounds: true, ..cx(&d, &s, &p) };
        let mut t = DimensionTool::default();
        assert!(t.pointer(&c, &PointerEvent::new(PointerKind::Down, 81.0, 81.0)).is_empty());
        assert!(t.pointer(&c, &PointerEvent::new(PointerKind::Drag, 85.0, 81.0)).is_empty(), "no segment dimension is dragged out");
        assert!(t.pointer(&c, &PointerEvent::new(PointerKind::Up, 85.0, 81.0)).is_empty());
        assert!(t.points.first().is_some_and(|(q, _)| near(*q, Point::new(80.0, 80.0))), "{:?}", t.points);
    }

    /// With Use Preview Bounds on, hovering by a corner of a stroked path's preview bounds, or
    /// right on it, shows the anchor ring there.
    #[test]
    fn hovering_a_corner_of_the_preview_bounds_shows_the_anchor_ring() {
        let (d, _) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let c = ToolContext { preview_bounds: true, ..cx(&d, &s, &p) };
        for (x, y) in [(101.0, 101.0), (99.5, 99.5)] {
            let mut t = DimensionTool::default();
            t.pointer(&c, &PointerEvent::new(PointerKind::Move, x, y));
            let ring = t
                .overlays(&c)
                .into_iter()
                .any(|o| matches!(o, Overlay::Anchor { p, filled: false, size, .. } if p.distance(Point::new(99.5, 99.5)) < 1e-9 && size == 10.0));
            assert!(ring, "({x}, {y})");
            let label = t
                .snap
                .guides()
                .iter()
                .any(|o| matches!(o, Overlay::Label { p, text, .. } if text == "anchor" && p.distance(Point::new(99.5, 99.5)) < 1e-9));
            assert!(label, "({x}, {y}): {:?}", t.snap.guides());
        }
    }

    /// With Use Preview Bounds on, a corner of the preview bounds takes a pick with Smart Guides and
    /// Snap to Point off, as an anchor does, and an anchor of other art nearer the pointer than the
    /// corner takes it from the corner. The point moves with the path, and a later change to the
    /// stroke weight leaves it where it was.
    #[test]
    fn preview_bounds_corners_take_picks_as_anchors_do() {
        let (d, id) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let near = |a: Point, b: Point| a.distance(b) < 1e-9;
        let pick = |c: &ToolContext, at: [(f64, f64); 2]| {
            let mut t = DimensionTool::default();
            for (x, y) in at {
                t.pointer(c, &PointerEvent::new(PointerKind::Move, x, y));
                t.pointer(c, &PointerEvent::new(PointerKind::Down, x, y));
                t.pointer(c, &PointerEvent::new(PointerKind::Up, x, y));
            }
            t.pending.expect("both points were picked")
        };
        let unsnapped = ToolContext { preview_bounds: true, smart_guides: false, snap_to_point: false, ..cx(&d, &s, &p) };
        let pending = pick(&unsnapped, [(101.0, 101.0), (199.0, 199.0)]);
        assert!(near(pending.a, Point::new(99.5, 99.5)) && near(pending.b, Point::new(200.5, 200.5)), "{:?} {:?}", pending.a, pending.b);
        // An unstroked line whose end lies 2.5 points outside the corner.
        let mut other = d.clone();
        let (l, line) = (other.layers[0].id, other.alloc_id());
        let path = vectorcraft_geom::PathData::single(vectorcraft_geom::SubPath::polyline(&[Point::new(97.0, 97.0), Point::new(50.0, 50.0)], false));
        other.insert(Some(l), 1, Node::path(line, path, Default::default())).expect("the line");
        let c = ToolContext { preview_bounds: true, ..cx(&other, &s, &p) };
        let pending = pick(&c, [(97.5, 97.5), (199.0, 199.0)]);
        assert!(near(pending.a, Point::new(97.0, 97.0)), "the line's end is nearer: {:?}", pending.a);
        let Some(DimensionSource::Points { a: Some(a), .. }) = &pending.source else { panic!("{:?}", pending.source) };
        assert_eq!(a.node, line);
        let pending = pick(&c, [(99.0, 99.0), (199.0, 199.0)]);
        assert!(near(pending.a, Point::new(99.5, 99.5)), "the corner is nearer: {:?}", pending.a);
        // Right on the rectangle's anchor, with another path's anchor nearer than the corner: that
        // anchor takes the point, not the rectangle's own anchor on the stroke's centerline.
        let mut beside = d.clone();
        let (l, line) = (beside.layers[0].id, beside.alloc_id());
        let path =
            vectorcraft_geom::PathData::single(vectorcraft_geom::SubPath::polyline(&[Point::new(100.5, 100.0), Point::new(150.0, 50.0)], false));
        beside.insert(Some(l), 1, Node::path(line, path, Default::default())).expect("the line");
        let pending = pick(&ToolContext { preview_bounds: true, ..cx(&beside, &s, &p) }, [(100.0, 100.0), (199.0, 199.0)]);
        let Some(DimensionSource::Points { a: Some(a), .. }) = &pending.source else { panic!("{:?}", pending.source) };
        assert!(near(pending.a, Point::new(100.5, 100.0)) && a.node == line, "{:?} {a:?}", pending.a);
        // The point held against the rectangle moves with it and stays put when the stroke changes.
        let pending = pick(&ToolContext { preview_bounds: true, ..cx(&d, &s, &p) }, [(101.0, 101.0), (199.0, 199.0)]);
        let Some(DimensionSource::Points { free_a: Some(free), .. }) = &pending.source else { panic!("{:?}", pending.source) };
        let mut moved = d.clone();
        moved.node_mut(id).expect("the rectangle").transform(vectorcraft_geom::Affine::translate((10.0, 0.0)), false);
        assert!(free.position(&moved).is_some_and(|q| near(q, Point::new(109.5, 99.5))), "{:?}", free.position(&moved));
        let mut wider = d.clone();
        let mut wide = vectorcraft_doc::Appearance::default_art();
        wide.stroke_mut().expect("a stroke").width = 40.0;
        wider.node_mut(id).expect("the rectangle").appearance = wide.into();
        assert!(free.position(&wider).is_some_and(|q| near(q, Point::new(99.5, 99.5))), "{:?}", free.position(&wider));
        // Scaled 200% with Scale Strokes off, the point moves with the anchors and no longer sits
        // on the corner of the preview bounds, which the 1 point stroke puts at (199.5, 199.5).
        let mut scaled = d.clone();
        scaled.node_mut(id).expect("the rectangle").transform(vectorcraft_geom::Affine::scale(2.0), false);
        assert!(free.position(&scaled).is_some_and(|q| near(q, Point::new(199.0, 199.0))), "{:?}", free.position(&scaled));
    }

    /// With Use Preview Bounds on, a corner takes the pick only from the anchors at the same corner
    /// of its object's geometric bounds. The other anchors of a small stroked circle stay
    /// pickable, so does the end of another line lying on the anchor the corner stands in for, and
    /// of two stroked rectangles sharing an edge, each corner of the shared anchors is held against
    /// its own rectangle.
    #[test]
    fn a_corner_takes_only_the_anchor_it_stands_for() {
        let (s, p) = (Selection::default(), paint());
        let near = |a: Point, b: Point| a.distance(b) < 1e-9;
        let mut d = vectorcraft_doc::Document::new(500.0, 500.0);
        let (l, circle) = (d.layers[0].id, d.alloc_id());
        let path = vectorcraft_geom::shapes::ellipse(Rect::new(296.0, 296.0, 304.0, 304.0));
        d.insert(Some(l), 0, Node::path(circle, path, vectorcraft_doc::Appearance::default_art())).expect("the circle");
        let c = ToolContext { preview_bounds: true, ..cx(&d, &s, &p) };
        let mut t = DimensionTool::default();
        let (q, reference) = t.snap_linear(&c, Point::new(300.0, 296.0));
        assert!(near(q, Point::new(300.0, 296.0)) && reference.is_some_and(|r| r.node == circle), "{q:?}");
        let (q, reference) = t.snap_linear(&c, Point::new(296.5, 296.5));
        assert!(near(q, Point::new(295.5, 295.5)) && reference.is_none() && t.corner == Some(circle), "{q:?}");
        // An unstroked line ending right on the rectangle's anchor: a click there picks the line's
        // end, and a click nearer the corner picks the corner.
        let (mut d, id) = doc_with_rect();
        let (l, line) = (d.layers[0].id, d.alloc_id());
        let path =
            vectorcraft_geom::PathData::single(vectorcraft_geom::SubPath::polyline(&[Point::new(100.0, 100.0), Point::new(50.0, 20.0)], false));
        d.insert(Some(l), 1, Node::path(line, path, Default::default())).expect("the line");
        let c = ToolContext { preview_bounds: true, ..cx(&d, &s, &p) };
        let mut t = DimensionTool::default();
        let (q, reference) = t.snap_linear(&c, Point::new(100.0, 100.0));
        assert!(near(q, Point::new(100.0, 100.0)) && reference.is_some_and(|r| r.node == line), "{q:?}");
        let (q, reference) = t.snap_linear(&c, Point::new(99.6, 99.6));
        assert!(near(q, Point::new(99.5, 99.5)) && reference.is_none() && t.corner == Some(id), "{q:?}");
        // Another path's end right on the corner: a click on the rectangle's anchor picks that end.
        let (mut d, _) = doc_with_rect();
        let (l, line) = (d.layers[0].id, d.alloc_id());
        let path = vectorcraft_geom::PathData::single(vectorcraft_geom::SubPath::polyline(&[Point::new(99.5, 99.5), Point::new(50.0, 20.0)], false));
        d.insert(Some(l), 0, Node::path(line, path, Default::default())).expect("the line");
        let c = ToolContext { preview_bounds: true, ..cx(&d, &s, &p) };
        let mut t = DimensionTool::default();
        let (q, reference) = t.snap_linear(&c, Point::new(100.0, 100.0));
        assert!(near(q, Point::new(99.5, 99.5)) && reference.as_ref().is_some_and(|r| r.node == line), "{q:?} {reference:?}");
        // A stroked dot, a path whose two anchors coincide, cannot hold a point at a corner: a
        // click by it picks its anchor.
        let mut d = vectorcraft_doc::Document::new(500.0, 500.0);
        let (l, dot) = (d.layers[0].id, d.alloc_id());
        let path =
            vectorcraft_geom::PathData::single(vectorcraft_geom::SubPath::polyline(&[Point::new(300.0, 300.0), Point::new(300.0, 300.0)], false));
        let mut round = vectorcraft_doc::Appearance::default_art();
        let stroke = round.stroke_mut().expect("a stroke");
        (stroke.width, stroke.cap) = (10.0, vectorcraft_doc::LineCap::Round);
        d.insert(Some(l), 0, Node::path(dot, path, round)).expect("the dot");
        let c = ToolContext { preview_bounds: true, ..cx(&d, &s, &p) };
        let mut t = DimensionTool::default();
        let (q, reference) = t.snap_linear(&c, Point::new(296.0, 296.0));
        assert!(near(q, Point::new(300.0, 300.0)) && reference.is_some_and(|r| r.node == dot) && t.corner.is_none(), "{q:?}");
        // A stroked rectangle made into a guide, and a stroked member of a compound path without
        // a stroke of its own, give no corners.
        for kind in ["guide", "member"] {
            let (mut d, id) = doc_with_rect();
            let mut wide = vectorcraft_doc::Appearance::default_art();
            wide.stroke_mut().expect("a stroke").width = 40.0;
            if kind == "guide" {
                let n = d.node_mut(id).expect("the rectangle");
                n.appearance = wide.into();
                if let NodeKind::Path { guide, .. } = &mut n.kind {
                    *guide = true;
                }
            } else {
                let mut fresh = vectorcraft_doc::Document::new(500.0, 500.0);
                let (l, part, whole) = (fresh.layers[0].id, fresh.alloc_id(), fresh.alloc_id());
                let mut member = Node::path(part, vectorcraft_geom::shapes::rectangle(Rect::new(100.0, 100.0, 200.0, 200.0)), Default::default());
                member.appearance = wide.into();
                let n = Node::new(whole, NodeKind::Compound { children: vec![std::sync::Arc::new(member)], rule: Default::default() });
                fresh.insert(Some(l), 0, n).expect("the compound path");
                d = fresh;
            }
            let c = ToolContext { preview_bounds: true, ..cx(&d, &s, &p) };
            let mut t = DimensionTool::default();
            let (q, _) = t.snap_linear(&c, Point::new(81.0, 81.0));
            assert!(!near(q, Point::new(80.0, 80.0)) && t.corner.is_none(), "{kind}: {q:?}");
        }
        // Two stroked rectangles sharing the edge x = 200; the right one is on top.
        let (mut d, left) = doc_with_rect();
        let (l, right) = (d.layers[0].id, d.alloc_id());
        let path = vectorcraft_geom::shapes::rectangle(Rect::new(200.0, 100.0, 300.0, 200.0));
        d.insert(Some(l), 1, Node::path(right, path, vectorcraft_doc::Appearance::default_art())).expect("the right rectangle");
        let c = ToolContext { preview_bounds: true, ..cx(&d, &s, &p) };
        for (pointer, corner, holder) in [((200.4, 99.6), (200.5, 99.5), left), ((199.6, 99.6), (199.5, 99.5), right)] {
            let mut t = DimensionTool::default();
            for kind in [PointerKind::Move, PointerKind::Down, PointerKind::Up] {
                t.pointer(&c, &PointerEvent::new(kind, pointer.0, pointer.1));
            }
            for kind in [PointerKind::Move, PointerKind::Down, PointerKind::Up] {
                t.pointer(&c, &PointerEvent::new(kind, 250.0, 300.0));
            }
            let pending = t.pending.expect("both points were picked");
            assert!(near(pending.a, Point::new(corner.0, corner.1)), "{pointer:?}: {:?}", pending.a);
            let Some(DimensionSource::Points { a: None, free_a: Some(free), .. }) = &pending.source else { panic!("{:?}", pending.source) };
            assert!(matches!(free, FreePoint::Anchors { node, .. } if *node == holder), "{pointer:?}: {free:?}");
        }
    }

    /// A point is held against a path for a corner of its preview bounds only when it was picked
    /// there: the same position picked another way links to the segment under it.
    #[test]
    fn a_point_is_held_for_a_corner_only_when_picked_on_it() {
        let (mut d, id) = doc_with_rect();
        let (l, line) = (d.layers[0].id, d.alloc_id());
        let path = vectorcraft_geom::PathData::single(vectorcraft_geom::SubPath::polyline(&[Point::new(0.0, 99.5), Point::new(300.0, 99.5)], false));
        d.insert(Some(l), 1, Node::path(line, path, Default::default())).expect("the line");
        let (s, p) = (Selection::default(), paint());
        let c = ToolContext { preview_bounds: true, ..cx(&d, &s, &p) };
        let (corner, b) = (Point::new(99.5, 99.5), Point::new(250.0, 99.5));
        for (held, node) in [(Some(id), id), (None, line)] {
            let source = points_source(&c, (corner, &None, held), (b, &None, None));
            let Some(DimensionSource::Points { free_a: Some(free), .. }) = &source else { panic!("{source:?}") };
            let linked = match free {
                FreePoint::Anchors { node, .. } => *node,
                FreePoint::OnSegment { edge, .. } => edge.node,
            };
            assert_eq!(linked, node, "{held:?}: {free:?}");
        }
    }

    /// Hovering right on the end of a dimension's line shows the anchor ring there.
    #[test]
    fn hovering_right_on_a_dimension_lines_end_shows_the_anchor_ring() {
        let mut d = vectorcraft_doc::Document::new(500.0, 500.0);
        let (l, id) = (d.layers[0].id, d.alloc_id());
        let path =
            vectorcraft_geom::PathData::single(vectorcraft_geom::SubPath::polyline(&[Point::new(300.0, 300.0), Point::new(400.0, 300.0)], false));
        let mut n = Node::path(id, path, Default::default());
        let recipe = DimensionTool::default().recipe(DimensionMode::Linear, Point::new(0.0, 0.0), Point::new(50.0, 0.0), Point::ZERO, None);
        n.extras_mut().dimension = Some(Box::new(recipe));
        d.insert(Some(l), 0, n).expect("the dimension's line");
        let (s, p) = (Selection::default(), paint());
        let c = ToolContext { smart_guides: true, snap_to_point: true, ..cx(&d, &s, &p) };
        let mut t = DimensionTool::default();
        t.pointer(&c, &PointerEvent::new(PointerKind::Move, 300.0, 300.0));
        let ring = t
            .overlays(&c)
            .into_iter()
            .any(|o| matches!(o, Overlay::Anchor { p, filled: false, size, .. } if p.distance(Point::new(300.0, 300.0)) < 1e-9 && size == 10.0));
        assert!(ring, "{:?}", t.overlays(&c));
    }

    /// The anchors of a live rectangle are picked the same way.
    #[test]
    fn a_press_on_a_live_shapes_anchor_picks_it() {
        let (d, id) = doc_with_live_rect();
        let (s, p) = (Selection::default(), paint());
        let c = cx(&d, &s, &p);
        let mut t = DimensionTool::default();
        t.pointer(&c, &PointerEvent::new(PointerKind::Down, 200.0, 100.0));
        t.pointer(&c, &PointerEvent::new(PointerKind::Drag, 197.0, 102.0));
        t.pointer(&c, &PointerEvent::new(PointerKind::Up, 197.0, 102.0));
        let [(at, Some(r))] = t.points.as_slice() else { panic!("{:?}", t.points) };
        assert_eq!((*at, r.node), (Point::new(200.0, 100.0), id));
    }

    /// An anchor of a compound path inside nested groups, lying just inside another object's
    /// edge, is picked and linked, though that edge is nearer the pointer than any of the
    /// compound path's own segments. A press there that moves a few pixels picks it too.
    #[test]
    fn an_anchor_under_another_objects_edge_is_picked() {
        use std::sync::Arc;
        use vectorcraft_doc::{Appearance, NodeKind};
        use vectorcraft_geom::Rect;
        let (mut d, _) = doc_with_rect();
        let l = d.layers[0].id;
        let (outer, inner, compound) = (d.alloc_id(), d.alloc_id(), d.alloc_id());
        let mut path = vectorcraft_geom::shapes::rectangle(Rect::new(20.0, 20.0, 40.0, 40.0));
        path.subpaths.extend(vectorcraft_geom::shapes::rectangle(Rect::new(150.0, 103.0, 180.0, 130.0)).subpaths);
        let art = Node::path(compound, path, Appearance::default_art());
        let inner_group = Node::new(inner, NodeKind::Group { children: vec![Arc::new(art)], clip: false });
        let group = Node::new(outer, NodeKind::Group { children: vec![Arc::new(inner_group)], clip: false });
        d.insert(Some(l), 0, group).unwrap();
        let (s, p) = (Selection::default(), paint());
        let c = cx(&d, &s, &p);
        let corner = (Point::new(150.0, 103.0), Some(PointRef { node: compound, subpath: 1, anchor: 0 }));
        let mut t = DimensionTool::default();
        assert_eq!(t.snap_linear(&c, Point::new(151.0, 101.0)), corner);
        t.pointer(&c, &PointerEvent::new(PointerKind::Down, 151.0, 101.0));
        assert!(t.pointer(&c, &PointerEvent::new(PointerKind::Drag, 155.0, 100.0)).is_empty(), "no segment dimension is dragged out");
        t.pointer(&c, &PointerEvent::new(PointerKind::Up, 155.0, 100.0));
        assert_eq!(t.points, vec![corner]);
    }

    /// Beside the two points the dimension is aligned; past either point it is horizontal when
    /// the pointer's quarter holds the straight up or down direction and vertical when it holds
    /// the straight left or right direction. Points on one horizontal or vertical line, a pointer
    /// on the line through the points, and two equal points give aligned.
    #[test]
    fn the_pointer_chooses_aligned_horizontal_or_vertical() {
        use Orientation::{Aligned, Horizontal, Vertical};
        let at = |a: (f64, f64), b: (f64, f64), p: (f64, f64)| orientation_at(Point::new(a.0, a.1), Point::new(b.0, b.1), Point::new(p.0, p.1));
        // A line rising to the right (y grows downwards), and the same points in the other order.
        for (a, b) in [((100.0, 300.0), (200.0, 200.0)), ((200.0, 200.0), (100.0, 300.0))] {
            for (p, want) in [
                ((120.0, 160.0), Aligned),
                ((200.0, 300.0), Aligned),
                ((150.0, 250.0), Aligned),
                ((200.0, 200.0), Aligned),
                ((100.0, 300.0), Aligned),
                ((210.0, 120.0), Horizontal),
                ((240.0, 150.0), Horizontal),
                ((280.0, 220.0), Vertical),
                ((240.0, 170.0), Vertical),
                ((40.0, 310.0), Vertical),
                ((90.0, 380.0), Horizontal),
                ((250.0, 150.0), Aligned),
            ] {
                assert_eq!(at(a, b, p), want, "{a:?} to {b:?}, pointer at {p:?}");
            }
        }
        // A line falling to the right.
        let (a, b) = ((100.0, 100.0), (300.0, 200.0));
        for (p, want) in
            [((200.0, 50.0), Aligned), ((320.0, 300.0), Horizontal), ((400.0, 210.0), Vertical), ((60.0, 20.0), Horizontal), ((20.0, 90.0), Vertical)]
        {
            assert_eq!(at(a, b, p), want, "pointer at {p:?}");
        }
        for (a, b) in [((100.0, 100.0), (300.0, 100.0)), ((100.0, 100.0), (100.0, 300.0)), ((100.0, 100.0), (100.0, 100.0))] {
            for p in [(50.0, 50.0), (350.0, 50.0), (350.0, 350.0), (50.0, 350.0), (200.0, 60.0), (60.0, 200.0), (400.0, 100.0), (100.0, 400.0)] {
                assert_eq!(at(a, b, p), Aligned, "{a:?} to {b:?}, pointer at {p:?}");
            }
        }
    }

    /// A point that Smart Guides leave where the pointer already is (the pointer right in line
    /// with a target) stays on the guide the overlays show. It does not move to the nearest point
    /// of a segment within the pick's reach. Off the guides, a point near a segment still lands
    /// on it, also straight below the first point: the second point has no construction guide
    /// through a first point that is not on an anchor.
    #[test]
    fn a_point_on_a_guide_stays_on_the_guide() {
        let (d, _) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let c = cx(&d, &s, &p);
        let click = |t: &mut DimensionTool, x: f64, y: f64| {
            t.pointer(&c, &PointerEvent::new(PointerKind::Move, x, y));
            t.pointer(&c, &PointerEvent::new(PointerKind::Down, x, y));
            t.pointer(&c, &PointerEvent::new(PointerKind::Up, x, y));
        };
        let mut t = DimensionTool::default();
        // In line with the rectangle's center, 6 units right of its right edge.
        assert_eq!(t.snap_linear(&c, Point::new(206.0, 150.0)), (Point::new(206.0, 150.0), None));
        assert!(!t.snap.guides().is_empty());
        // Off the guides, beside the edge: the closest point of the edge.
        let (on_edge, reference) = t.snap_linear(&c, Point::new(206.0, 170.5));
        assert!(on_edge.distance(Point::new(200.0, 170.5)) < 1e-4 && reference.is_none(), "{on_edge:?}");
        // The first point, above the rectangle, then straight down past the right edge: no
        // vertical guide through the first point holds the second, so beside the edge it lands
        // on the edge, and in line with the center it stays in line.
        click(&mut t, 206.0, 50.0);
        assert_eq!(t.points, vec![(Point::new(206.0, 50.0), None)]);
        for y in [170.5, 190.0] {
            let (q, reference) = t.snap_linear(&c, Point::new(206.0, y));
            assert!(q.distance(Point::new(200.0, y)) < 1e-4 && reference.is_none(), "beside the edge at y = {y}: {q:?}");
        }
        assert_eq!(t.snap_linear(&c, Point::new(207.0, 300.0)), (Point::new(207.0, 300.0), None), "away from the art");
        assert!(t.snap.guides().is_empty());
        assert_eq!(t.snap_linear(&c, Point::new(206.0, 150.0)), (Point::new(206.0, 150.0), None));
        assert!(!t.snap.guides().is_empty());
        click(&mut t, 206.0, 150.0);
        let dim = t.pending.as_ref().expect("both points were picked");
        assert_eq!((dim.a, dim.b), (Point::new(206.0, 50.0), Point::new(206.0, 150.0)));
        // The second point, off the edge, is held against the rectangle's anchors.
        let Some(DimensionSource::Points { free_b: Some(free), .. }) = &dim.source else { panic!("{:?}", dim.source) };
        assert!(matches!(free, FreePoint::Anchors { .. }), "{free:?}");
        // A pointer already on a gridline crossing or on a whole pixel stays there too, and one
        // off the grid lands on the grid, not on the edge.
        let grid = ToolContext { snap_to_grid: true, ..cx(&d, &s, &p) };
        let step = grid.grid_step();
        let on_grid = Point::new((200.0 / step).ceil() * step, (170.0 / step).round() * step);
        assert!(on_grid.x > 200.0 + 1e-6 && on_grid.x - 200.0 < 8.0, "{on_grid:?} is off the edge, within the pick's reach");
        assert_eq!(DimensionTool::default().snap_linear(&grid, on_grid), (on_grid, None));
        let off_grid = on_grid + Vec2::new(-step * 0.3, 0.2);
        assert_eq!(DimensionTool::default().snap_linear(&grid, off_grid), (on_grid, None));
        let pixel = ToolContext { snap_to_pixel: true, ..cx(&d, &s, &p) };
        assert_eq!(DimensionTool::default().snap_linear(&pixel, Point::new(206.0, 170.0)), (Point::new(206.0, 170.0), None));
    }

    /// After a first point that is not on an anchor, the second point still lands where the line
    /// from the first point meets a slanted segment square or grazes a curve, with the
    /// "perpendicular" or "tangent" label, at places no construction guide through the first
    /// point reaches. With Snap to Perpendicular and Snap to Tangent off it stays at the pointer.
    #[test]
    fn the_second_point_lands_square_to_a_segment_or_grazing_a_curve() {
        use vectorcraft_doc::Appearance;
        use vectorcraft_geom::{Rect, shapes};
        let (mut d, _) = doc_with_rect();
        let l = d.layers[0].id;
        let (line, circle) = (d.alloc_id(), d.alloc_id());
        let slanted = shapes::line(Point::new(300.0, 100.0), Point::new(400.0, 150.0));
        d.insert(Some(l), 0, Node::path(line, slanted, Appearance::default_art())).unwrap();
        let round = shapes::ellipse(Rect::new(420.0, 370.0, 480.0, 430.0));
        d.insert(Some(l), 0, Node::path(circle, round, Appearance::default_art())).unwrap();
        let (s, p) = (Selection::default(), paint());
        let c = cx(&d, &s, &p);
        let first = Point::new(300.0, 250.0);
        let picked = |c: &ToolContext| {
            let mut t = DimensionTool::default();
            for kind in [PointerKind::Move, PointerKind::Down, PointerKind::Up] {
                t.pointer(c, &PointerEvent::new(kind, first.x, first.y));
            }
            assert_eq!(t.points, vec![(first, None)]);
            t
        };
        let labeled = |t: &DimensionTool, label: &str| t.snap.guides().iter().any(|o| matches!(o, Overlay::Label { text, .. } if text == label));
        // The foot of the perpendicular from (300, 250) to the line is (360, 130), along no
        // construction guide angle from the first point.
        let mut t = picked(&c);
        let (q, reference) = t.snap_linear(&c, Point::new(361.0, 132.0));
        assert!(q.distance(Point::new(360.0, 130.0)) < 1e-4 && reference.is_none(), "{q:?}");
        assert!(labeled(&t, "perpendicular"), "{:?}", t.snap.guides());
        // Where a line from the first point grazes the circle about (450, 400), radius 30.
        let (center, radius) = (Point::new(450.0, 400.0), 30.0);
        let away = first - center;
        let angle = away.y.atan2(away.x) + (radius / away.hypot()).acos();
        let touch = center + Vec2::new(angle.cos(), angle.sin()) * radius;
        let (q, _) = t.snap_linear(&c, touch + Vec2::new(0.5, 0.5));
        assert!((q.distance(center) - radius).abs() < 0.05, "{q:?} is on the circle");
        assert!(((q - first).normalize().dot((q - center).normalize())).abs() < 0.01, "{q:?} grazes the circle");
        assert!(labeled(&t, "tangent"), "{:?}", t.snap.guides());
        // With both options off, the pointer near the foot lands on the closest point of the line
        // instead.
        let off = ToolContext { snap_perpendicular: false, snap_tangent: false, ..cx(&d, &s, &p) };
        let mut t = picked(&off);
        let (q, _) = t.snap_linear(&off, Point::new(361.0, 132.0));
        assert!(q.distance(Point::new(360.0, 130.0)) > 0.5 && !labeled(&t, "perpendicular"), "{q:?}");
    }

    /// After a first point picked on an anchor, the second point still lands on the construction
    /// guides through it.
    #[test]
    fn the_second_point_after_an_anchor_lands_on_construction_guides() {
        let (d, id) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let c = cx(&d, &s, &p);
        let mut t = DimensionTool::default();
        for kind in [PointerKind::Move, PointerKind::Down, PointerKind::Up] {
            t.pointer(&c, &PointerEvent::new(kind, 200.0, 200.0));
        }
        assert_eq!(t.points, vec![(Point::new(200.0, 200.0), Some(PointRef { node: id, subpath: 0, anchor: 2 }))]);
        // 1.5 units right and below the 45° guide up and to the right of the anchor.
        let (q, reference) = t.snap_linear(&c, Point::new(331.0, 72.0));
        assert!(q.distance(Point::new(329.5, 70.5)) < 1e-4 && reference.is_none(), "{q:?}");
        assert!(!t.snap.guides().is_empty());
        // The same offset from a first point off the anchors stays at the pointer.
        let mut t = DimensionTool::default();
        for kind in [PointerKind::Move, PointerKind::Down, PointerKind::Up] {
            t.pointer(&c, &PointerEvent::new(kind, 240.0, 240.0));
        }
        assert_eq!(t.points, vec![(Point::new(240.0, 240.0), None)]);
        assert_eq!(t.snap_linear(&c, Point::new(371.0, 112.0)), (Point::new(371.0, 112.0), None));
        assert!(t.snap.guides().is_empty());
    }

    #[test]
    fn placement_press_previews_without_a_prior_move() {
        let (d, _) = doc_with_rect();
        let (s, p) = (Selection::default(), paint());
        let c = cx(&d, &s, &p);
        let mut t = DimensionTool::default();
        for (x, y) in [(400.0, 400.0), (450.0, 420.0)] {
            assert!(t.pointer(&c, &PointerEvent::new(PointerKind::Down, x, y)).is_empty());
            assert!(t.pointer(&c, &PointerEvent::new(PointerKind::Up, x, y)).is_empty());
        }
        assert!(t.pending.is_some());
        let acts = t.pointer(&c, &PointerEvent::new(PointerKind::Down, 470.0, 450.0));
        assert!(matches!(acts.first(), Some(Action::Begin(_))), "{acts:?}");
        assert!(matches!(acts.last(), Some(Action::Preview(_, _))), "{acts:?}");
    }
}