Keep Scissors cuts on eligible snapped paths

This commit is contained in:
yoriswind committed 2026-11-11 16:10:46 -08:00
1 parent df5b7a95b4
commit 2c8cc52d16
2 files changed
+172 -8

No files matched your search

+43 -8
View File
@@ -94,12 +94,14 @@ enum SpaceResume {
SpineHandle { id: NodeId, ai: usize, out: bool },
}
/// The cursor reuses the last hover's point, with DrawSnap checking its target inputs. Zoom is
/// separate because the cached point has already applied the screen-pixel tolerances.
/// The cursor reuses the last hover's point, with DrawSnap checking its target inputs. The
/// Scissors-only inputs also bind the resolved point to the current cut eligibility.
struct ScissorsHover {
raw: Point,
snapped: Point,
zoom: f64,
isolation: Option<NodeId>,
selection_tolerance: f64,
}
pub struct AnchorTool {
@@ -143,7 +145,41 @@ impl AnchorTool {
}
fn current_scissors_hover(&self, cx: &ToolContext) -> Option<&ScissorsHover> {
self.scissors_hover.as_ref().filter(|h| h.zoom == cx.zoom && self.scissors_snap.is_current(cx, &[]))
self.scissors_hover.as_ref().filter(|h| {
h.zoom == cx.zoom
&& h.isolation == cx.isolation
&& h.selection_tolerance == cx.selection_tolerance
&& self.scissors_snap.is_current(cx, &[])
})
}
/// Keep a shared art snap unless it prevents a cut the raw pointer could make. Outside art
/// still supplies alignment and intersection guides; pixel and grid snapping keep precedence.
fn resolve_scissors_snap(&mut self, cx: &ToolContext, raw: Point, snapped: Point) -> Point {
let eligible = |p| hit_anchor(cx, p, 0.0).is_some() || hit_segment(cx, p, cx.pick_tol()).is_some();
let fallback =
(cx.smart_guides || cx.snap_to_point) && !cx.snap_to_pixel && !cx.snap_to_grid && snapped != raw && !eligible(snapped) && eligible(raw);
let snapped = if fallback {
self.scissors_snap.clear();
raw
} else {
snapped
};
self.scissors_hover =
Some(ScissorsHover { raw, snapped, zoom: cx.zoom, isolation: cx.isolation, selection_tolerance: cx.selection_tolerance });
snapped
}
/// Prefer a path actually at the snapped point before a nearby selected path. The small
/// tolerance covers curve-meeting roundoff. Pixel, grid and alignment points can lie off all
/// paths; there the ordinary full pick radius keeps the existing selected-path priority.
fn scissors_segment(cx: &ToolContext, p: Point) -> Option<(NodeId, usize, usize, f64)> {
let tol = cx.pick_tol();
if cx.smart_guides || cx.snap_to_point || cx.snap_to_pixel || cx.snap_to_grid {
super::segment_in(cx, super::candidate_paths(cx), p, tol.min(1e-6)).or_else(|| hit_segment(cx, p, tol))
} else {
hit_segment(cx, p, tol)
}
}
fn scissors_press(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec<Action> {
@@ -152,9 +188,8 @@ impl AnchorTool {
return Self::add(cx, p);
}
let snapped = self.scissors_snap.press(cx, p, &[], None);
self.scissors_hover = Some(ScissorsHover { raw: p, snapped, zoom: cx.zoom });
let p = snapped;
let (tol, point) = (cx.pick_tol(), cx.point_tol());
let p = self.resolve_scissors_snap(cx, p, snapped);
let point = cx.point_tol();
// A path snap must not be pulled to a nearby anchor by the larger pick radius.
// Shared anchor targets and the path's anchors use the same stored coordinates.
let snapping = cx.smart_guides || cx.snap_to_point || cx.snap_to_pixel || cx.snap_to_grid;
@@ -162,7 +197,7 @@ impl AnchorTool {
if let Some((id, si, ai)) = hit_anchor(cx, p, anchor_tol) {
return vec![Action::Exec("path.split".into(), json!({"id": id.0, "subpath": si, "anchor": ai}))];
}
match hit_segment(cx, p, tol) {
match Self::scissors_segment(cx, p) {
Some((id, si, seg, t)) => vec![Action::Exec("path.split".into(), json!({"id": id.0, "subpath": si, "segment": seg, "t": t}))],
None => vec![],
}
@@ -398,7 +433,7 @@ impl Tool for AnchorTool {
("scissors", PointerKind::Move) => {
if !ev.mods.alt {
let snapped = self.scissors_snap.hover(cx, p, &[], None);
self.scissors_hover = Some(ScissorsHover { raw: p, snapped, zoom: cx.zoom });
self.resolve_scissors_snap(cx, p, snapped);
}
vec![]
}
+129
View File
@@ -365,6 +365,118 @@ fn scissors_snaps_intersections_with_the_drawing_options() {
}
}
/// Snapping chooses the path it names, rather than a selected path merely within pick tolerance.
/// With every snap off, the existing selected-path priority still applies to the raw pointer.
#[test]
fn scissors_snapped_path_beats_nearby_selected_path() {
let (mut d, rect) = doc_with_rect();
let line = d.alloc_id();
d.insert(
Some(d.layers[0].id),
1,
vectorcraft_doc::Node::path(
line,
vectorcraft_geom::shapes::line(Point::new(120.0, 102.0), Point::new(240.0, 102.0)),
vectorcraft_doc::Appearance::default_art(),
),
)
.unwrap();
let mut selected = Selection::default();
selected.set([rect]);
let paint = paint();
for (smart, point, at, owner, target) in [
(false, false, (150.0, 101.6), rect, (150.0, 100.0)),
(true, true, (150.0, 101.6), line, (150.0, 102.0)),
(false, true, (150.0, 101.6), rect, (150.0, 100.0)),
(false, true, (150.0, 102.0), line, (150.0, 102.0)),
] {
let (at, target) = (Point::from(at), Point::from(target));
let c = ToolContext { smart_guides: smart, snap_to_point: point, snap_to_pixel: false, snap_to_grid: false, ..cx(&d, &selected, &paint) };
let mut tool = AnchorTool::new("scissors");
tool.pointer(&c, &PointerEvent::new(PointerKind::Move, at.x, at.y));
let labels = scissors_labels(&tool, &c);
if smart {
assert_eq!(labels.len(), 1, "{labels:?}");
assert_eq!(labels[0].0, "path");
assert!(labels[0].1.distance(Point::new(150.0, 102.0)) < 1e-6, "{labels:?}");
} else {
assert!(labels.is_empty(), "{labels:?}");
}
assert_eq!(tool.cursor(&c, at, Mods::default()), Cursor::Scissors);
let actions = tool.pointer(&c, &PointerEvent::new(PointerKind::Down, at.x, at.y));
assert!(scissors_cut_at(&d, owner, &actions).distance(target) < 1e-6, "smart={smart}, point={point}: {actions:?}");
}
}
/// Outside art can give an isolated path useful guides, but an unusable art snap must not turn a
/// valid raw cut into a miss. Pixel/grid precedence still forbids falling back to the raw point.
#[test]
fn scissors_keeps_valid_isolated_cuts_when_outside_art_snaps() {
let (mut d, rect) = doc_with_rect();
let outside = d.alloc_id();
d.insert(
Some(d.layers[0].id),
1,
vectorcraft_doc::Node::path(
outside,
vectorcraft_geom::shapes::line(Point::new(150.0, 103.5), Point::new(350.0, 350.0)),
vectorcraft_doc::Appearance::default_art(),
),
)
.unwrap();
let mut selected = Selection::default();
selected.set([rect]);
let paint = paint();
let at = Point::new(150.0, 100.0);
for snapping in [false, true] {
let c = ToolContext {
isolation: Some(rect),
smart_guides: snapping,
snap_to_point: snapping,
snap_to_pixel: false,
snap_to_grid: false,
..cx(&d, &selected, &paint)
};
let mut tool = AnchorTool::new("scissors");
tool.pointer(&c, &PointerEvent::new(PointerKind::Move, at.x, at.y));
let labels = scissors_labels(&tool, &c);
let cursor = tool.cursor(&c, at, Mods::default());
let actions = tool.pointer(&c, &PointerEvent::new(PointerKind::Down, at.x, at.y));
assert!(scissors_cut_at(&d, rect, &actions).distance(at) < 1e-6, "snapping={snapping}: {actions:?}");
assert_eq!(cursor, Cursor::Scissors, "snapping={snapping}");
assert!(labels.is_empty(), "rejected outside snap must not guide the raw cut: {labels:?}");
assert!(scissors_labels(&tool, &c).is_empty(), "the press also discards its rejected guide");
}
// The same isolation may still use an outside path's intersection on the eligible rectangle.
let (d, rect, selected) = scissors_crossing();
let c = ToolContext { isolation: Some(rect), ..cx(&d, &selected, &paint) };
let mut tool = AnchorTool::new("scissors");
let at = Point::new(152.0, 101.5);
tool.pointer(&c, &PointerEvent::new(PointerKind::Move, at.x, at.y));
let labels = scissors_labels(&tool, &c);
assert_eq!(labels.len(), 1, "{labels:?}");
assert_eq!(labels[0].0, "intersect");
assert!(labels[0].1.distance(Point::new(150.0, 100.0)) < 1e-6, "{labels:?}");
assert_eq!(tool.cursor(&c, at, Mods::default()), Cursor::Scissors);
let actions = tool.pointer(&c, &PointerEvent::new(PointerKind::Down, at.x, at.y));
assert!(scissors_cut_at(&d, rect, &actions).distance(Point::new(150.0, 100.0)) < 1e-6, "{actions:?}");
// A grid snap away from the path remains a miss even though the raw point is cuttable.
let (mut d, rect) = doc_with_rect();
d.node_mut(rect).unwrap().transform(vectorcraft_geom::Affine::translate((0.0, 3.5)), true);
d.grid = vectorcraft_doc::GridPrefs { spacing: 20.0, subdivisions: 1 };
let mut selected = Selection::default();
selected.set([rect]);
let c = ToolContext { isolation: Some(rect), snap_to_grid: true, ..cx(&d, &selected, &paint) };
let mut tool = AnchorTool::new("scissors");
let at = Point::new(150.0, 103.5);
tool.pointer(&c, &PointerEvent::new(PointerKind::Move, at.x, at.y));
assert_eq!(tool.cursor(&c, at, Mods::default()), Cursor::ScissorsNotAllowed);
assert!(tool.pointer(&c, &PointerEvent::new(PointerKind::Down, at.x, at.y)).is_empty());
assert!(scissors_labels(&tool, &c).is_empty());
}
/// Path and alignment labels use the same targets as the Pen. A configured snap reach beyond the
/// anchor's pick radius proves that snapping chooses the anchor rather than a nearby segment.
#[test]
@@ -418,6 +530,23 @@ fn scissors_cursor_and_press_use_current_snaps() {
tool.pointer(&c, &PointerEvent::new(PointerKind::Move, at.x, at.y));
assert_eq!(tool.cursor(&c, at, Mods::default()), Cursor::Scissors);
assert_eq!(tool.cursor(&c, Point::new(204.0, 160.0), Mods::default()), Cursor::ScissorsNotAllowed);
assert!(!tool.overlays(&c).is_empty());
// These interaction inputs can change without a document revision. The old hover must not
// keep moving the cursor onto the path or showing guides until another pointer move.
c.selection_tolerance = 1.0;
assert_eq!(tool.cursor(&c, at, Mods::default()), Cursor::ScissorsNotAllowed);
assert!(tool.overlays(&c).is_empty());
c.selection_tolerance = 3.0;
tool.pointer(&c, &PointerEvent::new(PointerKind::Move, at.x, at.y));
assert_eq!(tool.cursor(&c, at, Mods::default()), Cursor::Scissors);
assert!(!tool.overlays(&c).is_empty());
c.isolation = Some(rect);
assert_eq!(tool.cursor(&c, at, Mods::default()), Cursor::ScissorsNotAllowed);
assert!(tool.overlays(&c).is_empty());
c.isolation = None;
tool.pointer(&c, &PointerEvent::new(PointerKind::Move, at.x, at.y));
assert_eq!(tool.cursor(&c, at, Mods::default()), Cursor::Scissors);
assert!(!tool.overlays(&c).is_empty());
c.smart_guides = false;
c.snap_to_point = false;
assert_eq!(tool.cursor(&c, at, Mods::default()), Cursor::ScissorsNotAllowed);