diff --git a/crates/engine/src/cmd/path.rs b/crates/engine/src/cmd/path.rs index f2a1b1d9f7..d4d17e7343 100644 --- a/crates/engine/src/cmd/path.rs +++ b/crates/engine/src/cmd/path.rs @@ -499,7 +499,7 @@ fn link_handle(s: &mut Session, p: &Value, id: NodeId, si: usize, ai: usize, out sp.anchors.get(ai).is_some_and(|a| { let mut linked = *a; linked.link_handle(out, pos, sp.has_segment(ai, !out)); - linked == *a + linked == *a || ((if out { a.has_in() } else { a.has_out() }) && linked_already(a, out, pos)) }) }); if unchanged { @@ -515,6 +515,78 @@ fn link_handle(s: &mut Session, p: &Value, id: NodeId, si: usize, ai: usize, out ok() } +/// Whether a smooth anchor `a` already has its `out` (or incoming) handle at `pos` and its other +/// handle exactly where [`Anchor::link_handle`] puts it for that handle at some positive length. +/// Turning the other handle again from its stored end measures its length anew, which can round +/// the end differently in the last bit; a handle that passes this test only gets that rounding, +/// and any other handle is turned. `p + u * len` here is the same arithmetic as in +/// `Anchor::link_handle`, `dir / l` included. +fn linked_already(a: &Anchor, out: bool, pos: Point) -> bool { + let (moved, other) = if out { (a.h_out, a.h_in) } else { (a.h_in, a.h_out) }; + let dir = a.p - pos; + let l = dir.x.hypot(dir.y); + if a.kind != AnchorKind::Smooth || moved != pos || !(l > 0.0 && l.is_finite()) { + return false; + } + let u = dir / l; + // The lengths that give each stored coordinate exactly; the smallest length both ranges hold + // is checked against the whole end. + let (mut lo, mut hi) = (0.0_f64, f64::INFINITY); + for (p, o, u) in [(a.p.x, other.x, u.x), (a.p.y, other.y, u.y)] { + if u == 0.0 { + if o != p { + return false; + } + continue; + } + let Some((first, last)) = lengths_onto(p, u, o) else { + return false; + }; + (lo, hi) = (lo.max(first), hi.min(last)); + } + lo <= hi && lo > 0.0 && lo.is_finite() && a.p + u * lo == other +} + +/// The lengths `len` for which `p + u * len` rounds to exactly `o`, as their smallest and largest, +/// for a `u` other than 0. The rounded sum moves the same way as `len`, so a range around the +/// unrounded answer is widened until it brackets `o` and then halved down to each end. +fn lengths_onto(p: f64, u: f64, o: f64) -> Option<(f64, f64)> { + let s = u.signum(); + let below = |len: f64| s * (p + u * len) < s * o; + let above = |len: f64| s * (p + u * len) > s * o; + let c = (o - p) / u; + let mut d = (o.abs() + p.abs()).max(f64::MIN_POSITIVE) * f64::EPSILON / u.abs(); + let mut bracket = None; + for _ in 0..64 { + if below(c - d) && above(c + d) { + bracket = Some((c - d, c + d)); + break; + } + d *= 2.0; + } + let (lo, hi) = bracket?; + let first = halve(lo, hi, |len| !below(len)).1; + let last = halve(lo, hi, above).0; + (first <= last).then_some((first, last)) +} + +/// Narrows `lo..hi`, where `pred` is false at `lo` and true at `hi` and changes once between +/// them, to two neighboring values with the same property. +fn halve(mut lo: f64, mut hi: f64, pred: impl Fn(f64) -> bool) -> (f64, f64) { + for _ in 0..2200 { + let m = lo + (hi - lo) / 2.0; + if m <= lo || m >= hi { + break; + } + if pred(m) { + hi = m; + } else { + lo = m; + } + } + (lo, hi) +} + /// `path.moveAnchor`: one anchor to (x, y), its handles keeping their offsets (the Anchor Point /// tool's Shift-drag). fn move_anchor(s: &mut Session, p: &Value) -> Result { diff --git a/crates/engine/src/tests/anchor_edit_work.rs b/crates/engine/src/tests/anchor_edit_work.rs index 5130d30c26..38bb94a6f3 100644 --- a/crates/engine/src/tests/anchor_edit_work.rs +++ b/crates/engine/src/tests/anchor_edit_work.rs @@ -234,3 +234,65 @@ fn a_linked_handle_makes_the_anchor_smooth() { assert!(s.doc().unwrap().doc == before, "a refused request changed the document"); assert_eq!(undo_steps(&s), undo); } + +/// A linked `path.setHandle` request repeated as it was changes nothing and records no undo step, +/// even where turning the other handle again from its stored end rounds it differently, near the +/// origin and 3e6 pt from it. On a smooth anchor whose other handle is off line by 1e-8, linking +/// the handle where it is still turns the other one into line and records an undo step, at both +/// places. 3.9e6 pt from the origin, a 1.5e-9 pt handle at right angles and a handle 1e-9 pt off +/// line are turned too, and so is an other handle on the same side as the linked one. +#[test] +fn a_repeated_linked_handle_records_no_undo_step() { + let (mut s, id) = long_path(100); + let near = anchor(&s, id, 5).p; + for p in [near, Point::new(3e6, -2e6)] { + let corner = + Anchor { p, h_in: p + Vec2::new(117.73528366134629, 927.4795508230089), h_out: p + Vec2::new(3.0, 0.0), kind: AnchorKind::Corner }; + let path = Arc::make_mut(&mut s.doc_mut().unwrap().doc).node_mut(id).unwrap().path_data_mut().unwrap(); + path.subpaths[0].anchors[5] = corner; + for i in 0..40 { + let t = f64::from(i) * 0.37; + let to = p + Vec2::new(8.028549152229672 * t.cos() + 0.1 * f64::from(i), -9.388200339328929 * t.sin() - 0.03 * f64::from(i)); + let link = json!({"id": id.0, "anchor": 5, "which": "out", "x": to.x, "y": to.y, "link": true}); + s.execute("path.setHandle", &link).unwrap(); + let (steps, a) = (undo_steps(&s), anchor(&s, id, 5)); + s.execute("path.setHandle", &link).unwrap(); + assert_eq!(undo_steps(&s), steps, "request {i} at {p:?} repeated recorded an undo step"); + assert_eq!(anchor(&s, id, 5), a, "request {i} at {p:?} repeated changed the anchor"); + } + + let skewed = Anchor { p, h_in: p + Vec2::new(-10.0, 1e-8), h_out: p + Vec2::new(10.0, 0.0), kind: AnchorKind::Smooth }; + let path = Arc::make_mut(&mut s.doc_mut().unwrap().doc).node_mut(id).unwrap().path_data_mut().unwrap(); + path.subpaths[0].anchors[5] = skewed; + let steps = undo_steps(&s); + s.execute("path.setHandle", &json!({"id": id.0, "anchor": 5, "which": "out", "x": skewed.h_out.x, "y": skewed.h_out.y, "link": true})) + .unwrap(); + assert_eq!(undo_steps(&s), steps + 1, "the off-line handle at {p:?} was left as it was"); + let a = anchor(&s, id, 5); + assert!(a.h_out == skewed.h_out && a.h_in.y == p.y, "{a:?}"); + } + + // Far from the origin, a short handle at right angles and a handle 1e-9 pt off line are still + // turned into line. + let p = Point::new(3.9e6, 0.0); + for h_in in [Point::new(p.x, 1.5e-9), Point::new(p.x - 10.0, 1e-9)] { + let off = Anchor { p, h_in, h_out: p + Vec2::new(10.0, 0.0), kind: AnchorKind::Smooth }; + let path = Arc::make_mut(&mut s.doc_mut().unwrap().doc).node_mut(id).unwrap().path_data_mut().unwrap(); + path.subpaths[0].anchors[5] = off; + let steps = undo_steps(&s); + s.execute("path.setHandle", &json!({"id": id.0, "anchor": 5, "which": "out", "x": off.h_out.x, "y": off.h_out.y, "link": true})).unwrap(); + assert_eq!(undo_steps(&s), steps + 1, "the handle at {h_in:?} was left as it was"); + let a = anchor(&s, id, 5); + assert!(a.h_in.y == 0.0 && a.h_in.x < p.x, "{a:?}"); + } + + // An other handle on the same side as the linked one is turned to the far side. + let p = near; + let same = Anchor { p, h_in: p + Vec2::new(5.0, 0.0), h_out: p + Vec2::new(10.0, 0.0), kind: AnchorKind::Smooth }; + let path = Arc::make_mut(&mut s.doc_mut().unwrap().doc).node_mut(id).unwrap().path_data_mut().unwrap(); + path.subpaths[0].anchors[5] = same; + let steps = undo_steps(&s); + s.execute("path.setHandle", &json!({"id": id.0, "anchor": 5, "which": "out", "x": same.h_out.x, "y": same.h_out.y, "link": true})).unwrap(); + assert_eq!(undo_steps(&s), steps + 1, "the handle on the same side was left as it was"); + assert!(anchor(&s, id, 5).h_in.distance(p + Vec2::new(-5.0, 0.0)) < 1e-9, "{:?}", anchor(&s, id, 5)); +}