Files
vectorcraft/crates/tools/src/addons/extend_path.rs
T
dotCooCoo a5493a1cd0 Paths: editing one anchor of a long path keeps one chunk of anchors for undo
A subpath's anchors are now an `Anchors` list held in chunks of up to
256 anchors behind `Arc`s. Copying a path copies the chunk table and
shares the chunks, and editing one anchor copies only the chunk that
holds it, so the undo step of a one-anchor edit no longer keeps a copy
of every anchor of the path. Inserting or removing an anchor copies the
chunk it is in and rebuilds the table. Reads and edits follow the Vec
and slice methods the code used; files write and read each subpath's
anchors as one list, as before, within the same anchor read budget.

The undo memory estimate counts only the chunks the other version of
the path does not hold, and the renderer's kept paths compare only the
chunks an edit copied when they look for moved anchors.

Moving one anchor of an open path of 10,000 or 200,000 anchors
(path.moveAnchor, path.setHandle, path.moveAnchors, a nudge) keeps at
most 48 KiB in its undo and redo steps, where it kept 56 bytes per
anchor.
2026-11-14 21:25:15 -08:00

283 lines
12 KiB
Rust

//! Extend Path tool (Path Precision Tools): drag an end of an open path (selected or not) to carry
//! the path on the way it runs there, or back along itself to shorten it
//! (`addon.pathtools.extend`, previewed while dragging, one undo step). Over an end, a dashed line
//! shows how it would go on. E cycles the mode (straight, the last curve stretched, an arc of the
//! circle the end curves along); Shift steps the length by the keyboard increment; back over the
//! end, the length snaps to none.
use serde_json::{Value, json};
use vectorcraft_doc::{NodeId, NodeKind};
use vectorcraft_geom::{Point, SubPath};
use vectorcraft_pathops::addons::pathtools::{ExtendMode, extend_length_to, extend_open};
use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey};
/// The tool's id.
pub const ID: &str = "extendPath";
/// The undo step's name.
const LABEL: &str = "Extend Path";
/// How far ahead (px) the hover preview shows an end going on.
const PREVIEW_PX: f64 = 60.0;
const GREY: [u8; 3] = [0x80, 0x80, 0x80];
const BLUE: [u8; 3] = [0x4f, 0x9d, 0xff];
/// An end of an open subpath.
#[derive(Clone, Debug, PartialEq)]
struct End {
id: NodeId,
subpath: usize,
start: bool,
p: Point,
/// The subpath as it was.
sp: SubPath,
}
#[derive(Default)]
pub struct ExtendPathTool {
mode: Mode,
hover: Option<End>,
/// The end being dragged and the length the drag asks for.
drag: Option<(End, f64)>,
}
/// [`ExtendMode`], with the default the tool starts with.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
struct Mode(ExtendMode);
impl Default for Mode {
fn default() -> Self {
Mode(ExtendMode::Straight)
}
}
/// The end of an editable open path nearest `p` within the point tolerance.
fn end_at(cx: &ToolContext, p: Point) -> Option<End> {
let tol = cx.point_tol();
let mut best: Option<(f64, NodeId, usize, bool, Point)> = None;
cx.doc.walk(|n| {
let NodeKind::Path { path, guide: false, .. } = &n.kind else { return };
for (si, sp) in path.subpaths.iter().enumerate().filter(|(_, sp)| !sp.closed && sp.anchors.len() >= 2) {
for (start, a) in [(true, sp.anchors.first()), (false, sp.anchors.last())] {
let Some(a) = a else { continue };
let d = a.p.distance(p);
if d <= tol && best.is_none_or(|b| d < b.0) {
best = Some((d, n.id, si, start, a.p));
}
}
}
});
let (_, id, subpath, start, at) = best.filter(|b| cx.doc.is_editable(b.1))?;
let sp = cx.doc.node(id)?.path_data()?.subpaths.get(subpath)?.clone();
Some(End { id, subpath, start, p: at, sp })
}
impl ExtendPathTool {
/// The length a drag to `p` asks for: back over the end none, with Shift in steps of the
/// keyboard increment.
fn length_at(&self, cx: &ToolContext, end: &End, p: Point, mods: Mods) -> f64 {
if p.distance(end.p) <= cx.point_tol() {
return 0.0;
}
let len = extend_length_to(&end.sp, end.start, p, self.mode.0).unwrap_or(0.0);
let step = cx.keyboard_increment;
if mods.shift && step > 0.0 && step.is_finite() { (len / step).round() * step } else { len }
}
fn params(&self, end: &End, length: f64) -> Value {
json!({
"id": end.id.0,
"subpath": end.subpath,
"end": if end.start { "start" } else { "end" },
"length": length,
"mode": self.mode.0.id(),
})
}
}
/// The length of `sp` (pt).
fn length_of(sp: &SubPath) -> f64 {
(0..sp.segment_count()).map(|i| kurbo::ParamCurveArclen::arclen(&sp.segment(i), 1e-6)).sum()
}
impl Tool for ExtendPathTool {
fn id(&self) -> &'static str {
ID
}
fn busy(&self) -> bool {
self.drag.is_some()
}
fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec<Action> {
match ev.kind {
PointerKind::Move => {
self.hover = end_at(cx, ev.pos);
vec![]
}
PointerKind::Down => {
let Some(end) = end_at(cx, ev.pos) else { return vec![] };
self.hover = None;
self.drag = Some((end, 0.0));
vec![Action::Begin(LABEL.into())]
}
PointerKind::Drag | PointerKind::Up => {
let Some((end, _)) = self.drag.take() else { return vec![] };
let length = self.length_at(cx, &end, ev.pos, ev.mods);
let preview = Action::Preview("addon.pathtools.extend".into(), self.params(&end, length));
if ev.kind == PointerKind::Drag {
self.drag = Some((end, length));
return vec![preview];
}
// Back where it started: nothing to keep.
if length == 0.0 { vec![Action::Cancel] } else { vec![preview, Action::Commit] }
}
PointerKind::DoubleClick | PointerKind::TripleClick => vec![],
}
}
fn key(&mut self, _cx: &ToolContext, key: ToolKey, _mods: Mods) -> Vec<Action> {
match key {
ToolKey::Escape if self.drag.is_some() => {
self.drag = None;
vec![Action::Cancel]
}
ToolKey::Letter('e') => {
let all = ExtendMode::ALL;
let i = all.iter().position(|m| *m == self.mode.0).unwrap_or(0);
self.mode = Mode(all.get((i + 1) % all.len()).copied().unwrap_or(ExtendMode::Straight));
vec![]
}
_ => vec![],
}
}
fn claims_key(&self, _cx: &ToolContext, key: ToolKey) -> bool {
key == ToolKey::Letter('e') || (self.drag.is_some() && key == ToolKey::Escape)
}
fn hover_ended(&mut self, _cx: &ToolContext) {
self.hover = None;
}
fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
let size = 7.0;
if let Some((end, length)) = &self.drag {
let total = length_of(&end.sp) + length;
return vec![
Overlay::Anchor { p: end.p, color: BLUE, filled: false, size },
Overlay::Measure {
p: end.p + kurbo::Vec2::new(cx.tol(12.0), cx.tol(12.0)),
text: format!("Length: {}\nΔ: {}", cx.len(total), cx.len(*length)),
},
];
}
let Some(end) = &self.hover else { return vec![] };
let mut out = vec![Overlay::Anchor { p: end.p, color: BLUE, filled: true, size }];
// How the end would go on.
if let Some(ext) = extend_open(&end.sp, end.start, cx.tol(PREVIEW_PX), self.mode.0) {
let (k, n) = (end.sp.anchors.len(), ext.anchors.len());
// From the old end on; a stretched last curve (no anchor added) shows whole.
let from = if n > k { k - 1 } else { n.saturating_sub(2) };
let tail = if end.start { ext.anchors.get_range(..n - from) } else { ext.anchors.get_range(from..) };
if let Some(tail) = tail {
let mut bp = vectorcraft_geom::BezPath::new();
SubPath::new(tail, false).to_bezpath_into(&mut bp);
out.push(Overlay::Path { path: bp, color: GREY, width: 1.0, dashed: true });
}
}
out
}
fn cursor(&self, _cx: &ToolContext, _p: Point, _mods: Mods) -> Cursor {
Cursor::ExtendPath
}
fn options(&self) -> Value {
json!({ "mode": self.mode.0.id() })
}
fn set_option(&mut self, key: &str, v: &Value) {
if key == "mode"
&& let Some(m) = v.as_str().and_then(ExtendMode::parse)
{
self.mode = Mode(m);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::testutil::*;
use vectorcraft_doc::{Appearance, Document, Node, Selection};
use vectorcraft_geom::PathData;
/// A document with an open line from (100, 100) to (200, 100).
fn doc_with_line() -> (Document, NodeId) {
let mut d = Document::new(500.0, 500.0);
let l = d.layers[0].id;
let id = d.alloc_id();
let sp = SubPath::polyline(&[Point::new(100.0, 100.0), Point::new(200.0, 100.0)], false);
d.insert(Some(l), 0, Node::path(id, PathData::single(sp), Appearance::default_art())).unwrap();
(d, id)
}
fn ev(kind: PointerKind, x: f64, y: f64) -> PointerEvent {
PointerEvent::new(kind, x, y)
}
#[test]
fn dragging_an_end_previews_the_extension_and_commits() {
let (d, id) = doc_with_line();
let (sel, p) = (Selection::default(), paint());
let cx = cx(&d, &sel, &p);
let mut t = ExtendPathTool::default();
// Hovering the end shows it and how it would go on.
assert!(t.pointer(&cx, &ev(PointerKind::Move, 201.0, 101.0)).is_empty());
let ov = t.overlays(&cx);
assert!(matches!(ov.as_slice(), [Overlay::Anchor { filled: true, .. }, Overlay::Path { dashed: true, .. }]), "{ov:?}");
assert_eq!(t.pointer(&cx, &ev(PointerKind::Down, 201.0, 101.0)), vec![Action::Begin(LABEL.into())]);
let drag = t.pointer(&cx, &ev(PointerKind::Drag, 240.0, 105.0));
let Some(Action::Preview(cmd, params)) = drag.first() else { panic!("{drag:?}") };
assert_eq!(cmd, "addon.pathtools.extend");
assert_eq!((params["id"].clone(), params["end"].clone(), params["mode"].clone()), (json!(id.0), json!("end"), json!("straight")));
assert!((params["length"].as_f64().unwrap() - 40.0).abs() < 1e-6);
assert!(t.overlays(&cx).iter().any(|o| matches!(o, Overlay::Measure { text, .. } if text.contains("Length: 140"))));
let up = t.pointer(&cx, &ev(PointerKind::Up, 160.0, 100.0));
assert!(matches!(up.as_slice(), [Action::Preview(_, p), Action::Commit] if (p["length"].as_f64().unwrap() + 40.0).abs() < 1e-6), "{up:?}");
// The start end too, and Shift steps the length.
t.pointer(&cx, &ev(PointerKind::Down, 100.0, 100.0));
let mut shifted = ev(PointerKind::Drag, 87.4, 100.0);
shifted.mods.shift = true;
let drag = t.pointer(&cx, &shifted);
let Some(Action::Preview(_, params)) = drag.first() else { panic!("{drag:?}") };
assert_eq!((params["end"].clone(), params["length"].clone()), (json!("start"), json!(13.0)));
// Back on the end: nothing to keep.
assert_eq!(t.pointer(&cx, &ev(PointerKind::Up, 100.0, 100.0)), vec![Action::Cancel]);
}
#[test]
fn away_from_ends_nothing_happens_and_e_cycles_the_mode() {
let (d, _) = doc_with_line();
let (sel, p) = (Selection::default(), paint());
let cx = cx(&d, &sel, &p);
let mut t = ExtendPathTool::default();
assert!(t.pointer(&cx, &ev(PointerKind::Down, 150.0, 100.0)).is_empty(), "the middle of the path");
assert!(t.pointer(&cx, &ev(PointerKind::Up, 150.0, 100.0)).is_empty());
assert!(t.overlays(&cx).is_empty());
assert!(t.claims_key(&cx, ToolKey::Letter('e')));
for want in ["bezier", "arc", "straight"] {
t.key(&cx, ToolKey::Letter('e'), Mods::default());
assert_eq!(t.options()["mode"], json!(want));
}
t.set_option("mode", &json!("arc"));
t.set_option("mode", &json!("spiral"));
assert_eq!(t.options()["mode"], json!("arc"));
assert_eq!(t.cursor(&cx, Point::ZERO, Mods::default()), Cursor::ExtendPath);
// A closed path has no ends.
let (d, _) = doc_with_rect();
let cx = crate::testutil::cx(&d, &sel, &p);
assert!(t.pointer(&cx, &ev(PointerKind::Down, 100.0, 100.0)).is_empty());
}
}