Skip to content

VectorCraft: An open-source, vector art tool written by scratch in pure Rust

refactor(tools): move draw2/gesture.rs tests to draw2/gesture/tests.rs

aiongg8fd986ae13d8
diff --git a/crates/tools/src/draw2/gesture.rs b/crates/tools/src/draw2/gesture.rs
index 82b512143..bdb8e4d84 100644
--- a/crates/tools/src/draw2/gesture.rs
+++ b/crates/tools/src/draw2/gesture.rs
@@ -692,1041 +692,4 @@ impl Tool for GestureTool {
}
#[cfg(test)]
-mod tests {
- use super::*;
- use crate::testutil::*;
- use vectorcraft_doc::Selection;
-
- fn drag(t: &mut GestureTool, cx: &ToolContext, pts: &[(f64, f64)], m: Mods) -> Vec<Vec<Action>> {
- let mut v = vec![t.pointer(cx, &PointerEvent::new(PointerKind::Down, pts[0].0, pts[0].1))];
- for &(x, y) in &pts[1..] {
- v.push(t.pointer(cx, &PointerEvent::new(PointerKind::Drag, x, y)));
- }
- let l = pts[pts.len() - 1];
- v.push(t.pointer(cx, &PointerEvent::new(PointerKind::Up, l.0, l.1).with_mods(m)));
- v
- }
-
- fn drag_held(t: &mut GestureTool, cx: &ToolContext, pts: &[(f64, f64)], m: Mods) -> Vec<Vec<Action>> {
- let mut v = vec![t.pointer(cx, &PointerEvent::new(PointerKind::Down, pts[0].0, pts[0].1).with_mods(m))];
- for &(x, y) in &pts[1..] {
- v.push(t.pointer(cx, &PointerEvent::new(PointerKind::Drag, x, y).with_mods(m)));
- }
- let l = pts[pts.len() - 1];
- v.push(t.pointer(cx, &PointerEvent::new(PointerKind::Up, l.0, l.1).with_mods(m)));
- v
- }
-
- /// The Pencil's new path starts and ends on Smart Guides (#506), the points between where
- /// the hand went.
- #[test]
- fn pencil_ends_snap_to_smart_guides() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let cx = cx(&d, &s, &p);
- let mut t = GestureTool::new("pencil");
- let acts = drag(&mut t, &cx, &[(102.0, 98.0), (151.0, 300.0), (250.0, 320.0), (198.0, 203.0)], Mods::default());
- let Some(Action::Preview(_, v)) = acts.last().and_then(|a| a.first()) else { panic!("{acts:?}") };
- assert_eq!(v["points"], json!([[100.0, 100.0], [151.0, 300.0], [250.0, 320.0], [200.0, 200.0]]));
- // The Paintbrush follows the hand all the way.
- let mut t = GestureTool::new("paintbrush");
- let acts = drag(&mut t, &cx, &[(102.0, 98.0), (151.0, 300.0)], Mods::default());
- let Some(Action::Preview(_, v)) = acts.last().and_then(|a| a.first()) else { panic!("{acts:?}") };
- assert_eq!(v["points"][0], json!([102.0, 98.0]));
- }
-
- /// #852: the Paintbrush sends each point's pen pressure; a mouse (always fully pressed) and
- /// the Pencil send plain points.
- #[test]
- fn paintbrush_sends_pen_pressure() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let cx = cx(&d, &s, &p);
- let stroke = |id: &str, pressures: [f32; 3]| {
- let mut t = GestureTool::new(id);
- let kinds = [PointerKind::Down, PointerKind::Drag, PointerKind::Up];
- let mut last = vec![];
- for ((k, x), f) in kinds.into_iter().zip([0.0, 40.0, 80.0]).zip(pressures) {
- last = t.pointer(&cx, &PointerEvent { pressure: f, ..PointerEvent::new(k, x, 0.0) });
- }
- let Some(Action::Preview(_, v)) = last.first() else { panic!("{last:?}") };
- v["points"].clone()
- };
- assert_eq!(stroke("paintbrush", [0.25, 0.5, 1.0]), json!([[0.0, 0.0, 0.25], [40.0, 0.0, 0.5], [80.0, 0.0, 1.0]]));
- assert_eq!(stroke("paintbrush", [1.0; 3]), json!([[0.0, 0.0], [40.0, 0.0], [80.0, 0.0]]));
- assert_eq!(stroke("pencil", [0.25, 0.5, 1.0]), json!([[0.0, 0.0], [40.0, 0.0], [80.0, 0.0]]));
- }
-
- #[test]
- fn pencil_previews_and_commits() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let cx = cx(&d, &s, &p);
- let mut t = GestureTool::new("pencil");
- let acts = drag(&mut t, &cx, &[(0.0, 0.0), (10.0, 5.0), (20.0, 0.0)], Mods::default());
- assert!(acts[0].is_empty());
- assert_eq!(acts[1][0], Action::Begin("Pencil".into()));
- assert!(matches!(&acts[1][1], Action::Preview(c, v) if c == "path.freehand" && v["points"].as_array().unwrap().len() == 2));
- let last = acts.last().unwrap();
- assert!(matches!(&last[0], Action::Preview(_, v) if v["closed"] == false && v["style"] == "pencil"));
- assert_eq!(last[1], Action::Commit);
- assert!(!t.busy());
- }
-
- /// Live curve fitting is the Pencil's, on by default. Off, the previews while a stroke is drawn
- /// ask for the points unfitted (`fit: false`), and the release's preview is fitted as before.
- #[test]
- fn pencil_with_live_curve_fitting_off_previews_the_stroke_unfitted() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let cx = cx(&d, &s, &p);
- let stroke = [(0.0, 0.0), (10.0, 5.0), (20.0, 0.0), (30.0, 6.0), (40.0, 0.0)];
- // The `fit` each preview sends: those while drawn, then the release's.
- let fits = |t: &mut GestureTool| {
- let acts = drag(t, &cx, &stroke, Mods::default());
- let fit = |a: &Action| if let Action::Preview(_, v) = a { Some(v.get("fit").cloned()) } else { None };
- let (drawn, release) = acts.split_at(acts.len() - 1);
- (drawn.iter().flatten().filter_map(fit).collect::<Vec<_>>(), release[0].iter().filter_map(fit).collect::<Vec<_>>())
- };
- let mut t = GestureTool::new("pencil");
- assert_eq!(t.options()["liveFit"], json!(true));
- let (drawn, release) = fits(&mut t);
- assert!(!drawn.is_empty() && drawn.iter().all(Option::is_none), "{drawn:?}");
- assert_eq!(release, [None]);
- t.set_option("liveFit", &json!(false));
- assert_eq!(t.options()["liveFit"], json!(false));
- let (drawn, release) = fits(&mut t);
- assert!(!drawn.is_empty() && drawn.iter().all(|f| *f == Some(json!(false))), "{drawn:?}");
- assert_eq!(release, [None], "the release fits the stroke");
- // Choosing another tool while the stroke is drawn keeps it fitted, too.
- t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
- for &(x, y) in &stroke[1..] {
- t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, x, y));
- }
- let acts = t.deactivate(&cx);
- assert!(matches!(acts.as_slice(), [Action::Preview(_, v), Action::Commit] if v.get("fit").is_none()), "{acts:?}");
- // The Paintbrush has no such option, and its previews are fitted.
- let mut t = GestureTool::new("paintbrush");
- t.set_option("liveFit", &json!(false));
- assert!(t.options().get("liveFit").is_none());
- let (drawn, _) = fits(&mut t);
- assert!(!drawn.is_empty() && drawn.iter().all(Option::is_none), "{drawn:?}");
- }
-
- /// Keep selected is on by default, and every Pencil and Paintbrush preview sends it.
- #[test]
- fn pencil_and_paintbrush_send_keep_selected() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let cx = cx(&d, &s, &p);
- for id in ["pencil", "paintbrush"] {
- let mut t = GestureTool::new(id);
- assert_eq!(t.options()["keepSelected"], json!(true), "{id}");
- for keep in [true, false] {
- t.set_option("keepSelected", &json!(keep));
- assert_eq!(t.options()["keepSelected"], json!(keep), "{id}");
- let acts = drag(&mut t, &cx, &[(0.0, 0.0), (10.0, 5.0), (20.0, 0.0)], Mods::default());
- assert!(acts[1..].iter().all(|a| a.iter().all(|a| !matches!(a, Action::Preview(_, v) if v["keepSelected"] != keep))), "{id}");
- assert!(matches!(&acts.last().unwrap()[0], Action::Preview(_, v) if v["keepSelected"] == keep), "{id}");
- }
- }
- }
-
- /// With the Pencil's Live preview off, a stroke previews nothing while it is drawn: a thin line
- /// follows the pen (an overlay), and the release draws the path with its fill and stroke. On (the
- /// default), every step previews the path and no line is shown. The Paintbrush has no such option.
- #[test]
- fn pencil_with_live_preview_off_shows_a_thin_line_until_the_release() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let cx = cx(&d, &s, &p);
- let previews = |acts: &[Action]| acts.iter().filter(|a| matches!(a, Action::Preview(..))).count();
- let line = |t: &GestureTool| t.overlays(&cx).iter().any(|o| matches!(o, Overlay::Path { width, .. } if *width == 1.0));
- let pts = [(0.0, 0.0), (10.0, 5.0), (20.0, 0.0), (30.0, 5.0)];
- for live in [true, false] {
- let mut t = GestureTool::new("pencil");
- assert_eq!(t.options()["livePreview"], json!(true), "on by default");
- t.set_option("livePreview", &json!(live));
- assert_eq!(t.options()["livePreview"], json!(live));
- t.pointer(&cx, &PointerEvent::new(PointerKind::Down, pts[0].0, pts[0].1));
- let mut during = vec![];
- for &(x, y) in &pts[1..] {
- during.extend(t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, x, y)));
- }
- assert!(matches!(during.first(), Some(Action::Begin(_))), "live {live}: {during:?}");
- assert_eq!(previews(&during), if live { 3 } else { 0 }, "live {live}: {during:?}");
- assert_eq!(line(&t), !live, "live {live}: the thin line shows only with Live preview off");
- let up = t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 30.0, 5.0));
- assert!(matches!(up.as_slice(), [Action::Preview(c, _), Action::Commit] if c == "path.freehand"), "live {live}: {up:?}");
- assert!(!line(&t), "live {live}: no line after the release");
- }
- // Escape mid-stroke with Live preview off cancels the stroke it began.
- let mut t = GestureTool::new("pencil");
- t.set_option("livePreview", &json!(false));
- t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
- t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 10.0, 5.0));
- assert_eq!(t.key(&cx, ToolKey::Escape, Mods::default()), vec![Action::Cancel]);
- // The Paintbrush keeps previewing: Live preview isn't one of its options.
- let mut b = GestureTool::new("paintbrush");
- assert!(b.options().get("livePreview").is_none());
- b.set_option("livePreview", &json!(false));
- b.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
- let acts = b.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 10.0, 5.0));
- assert_eq!(previews(&acts), 1, "{acts:?}");
- }
-
- /// Holding Alt shows the Paintbrush's closing cursor before the press, and the Pencil's and the
- /// Paintbrush's while drawing (before a press, Alt gives the Pencil its straight-line cursor); a release
- /// with Alt still held closes the path, and Alt let go before the release leaves it open.
- /// The freehand tools take every position the pointer passed (`wants_samples`); the Join tool
- /// doesn't need them.
- #[test]
- fn the_freehand_tools_want_every_sample() {
- for id in ["pencil", "paintbrush", "blobBrush", "eraser", "knife", "smooth", "pathEraser"] {
- assert!(GestureTool::new(id).wants_samples(), "{id}");
- }
- assert!(!GestureTool::new("join").wants_samples());
- }
-
- #[test]
- fn alt_shows_the_closing_cursor_and_a_release_with_alt_closes() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let cx = cx(&d, &s, &p);
- let alt = Mods { alt: true, ..Default::default() };
- let at = Point::new(10.0, 5.0);
- for (id, own, closing, style) in
- [("pencil", Cursor::Pencil, Cursor::PencilClose, "pencil"), ("paintbrush", Cursor::Paintbrush, Cursor::PaintbrushClose, "brush")]
- {
- let mut t = GestureTool::new(id);
- assert_eq!(t.cursor(&cx, at, Mods::default()), if id == "pencil" { Cursor::PencilNew } else { own }, "{id}");
- assert_eq!(t.cursor(&cx, at, alt), if id == "pencil" { Cursor::PencilStraight } else { closing }, "{id}");
- for alt_at_release in [true, false] {
- t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
- t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 10.0, 5.0).with_mods(alt));
- assert_eq!(t.cursor(&cx, at, alt), closing, "{id} while drawing");
- assert_eq!(t.cursor(&cx, at, Mods::default()), own, "{id} while drawing");
- let up = Mods { alt: alt_at_release, ..Default::default() };
- let acts = t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 20.0, 0.0).with_mods(up));
- assert!(
- matches!(&acts[0], Action::Preview(_, v) if v["closed"] == alt_at_release && v["style"] == style),
- "{id}, Alt at the release {alt_at_release}: {acts:?}"
- );
- }
- }
- // With Alt key toggles to Smooth Tool on, Alt lends the Pencil the Smooth tool instead, until
- // a stroke has begun to draw: Alt then neither smooths nor closes, and the cursor stays the Pencil's.
- let mut t = GestureTool::new("pencil");
- t.set_option("altSmooth", &json!(true));
- assert_eq!(t.cursor(&cx, at, alt), Cursor::Smooth);
- t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
- t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 10.0, 5.0));
- assert_eq!(t.cursor(&cx, at, alt), Cursor::Pencil, "a stroke that has begun");
- let acts = t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 20.0, 0.0).with_mods(alt));
- assert!(matches!(&acts[0], Action::Preview(_, v) if v["closed"] == false), "{acts:?}");
- // A smoothing drag keeps the Smooth cursor when Alt is let go.
- t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0).with_mods(alt));
- t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 10.0, 5.0).with_mods(alt));
- assert_eq!(t.cursor(&cx, at, Mods::default()), Cursor::Smooth, "a smoothing drag");
- }
-
- #[test]
- fn blob_brush_drag_shows_scrub_length_measurement_labels() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let on = ToolContext { measurement_labels: true, ..cx(&d, &s, &p) };
- let off = ToolContext { measurement_labels: false, ..cx(&d, &s, &p) };
- let mut t = GestureTool::new("blobBrush");
- t.pointer(&on, &PointerEvent::new(PointerKind::Down, 50.0, 150.0));
- t.pointer(&on, &PointerEvent::new(PointerKind::Drag, 150.0, 150.0));
- let want = format!("L: {}", on.len(100.0));
- assert!(t.overlays(&on).iter().any(|o| matches!(o, Overlay::Measure { text, .. } if text == &want)));
- let mut quiet = GestureTool::new("blobBrush");
- quiet.pointer(&off, &PointerEvent::new(PointerKind::Down, 50.0, 150.0));
- quiet.pointer(&off, &PointerEvent::new(PointerKind::Drag, 150.0, 150.0));
- assert!(!quiet.overlays(&off).iter().any(|o| matches!(o, Overlay::Measure { .. })));
- }
-
- /// The Blob Brush has Keep selected and Merge only with selection, both off by default, and its
- /// stroke sends both.
- #[test]
- fn blob_brush_sends_keep_selected_and_merge_only_with_selection() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let cx = cx(&d, &s, &p);
- let mut t = GestureTool::new("blobBrush");
- assert_eq!((t.options()["keepSelected"].clone(), t.options()["mergeOnlySelection"].clone()), (json!(false), json!(false)));
- for (keep, only) in [(false, false), (true, false), (false, true)] {
- t.set_option("keepSelected", &json!(keep));
- t.set_option("mergeOnlySelection", &json!(only));
- let acts = drag(&mut t, &cx, &[(50.0, 150.0), (250.0, 150.0)], Mods::default());
- assert!(
- matches!(&acts[2][0], Action::Exec(c, v) if c == "path.blob" && v["keepSelected"] == keep && v["mergeOnlySelection"] == only),
- "{acts:?}"
- );
- }
- // The Eraser keeps Size, Angle and Roundness: a round tip by default.
- assert_eq!(GestureTool::new("eraser").options(), json!({"size": 10.0, "angle": 0.0, "roundness": 100.0}));
- }
-
- /// Shift keeps a Blob Brush stroke on the horizontal or vertical line through the press point,
- /// whichever is nearer to the pointer, at 90° steps from the Constrain Angle; the points
- /// dragged with Shift held move to the other line together, and each point follows the Shift
- /// state of its own event.
- #[test]
- fn blob_brush_shift_keeps_the_stroke_horizontal_or_vertical() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let mut cx = cx(&d, &s, &p);
- let shift = Mods { shift: true, ..Default::default() };
- let blob = |acts: &[Vec<Action>]| -> Vec<(f64, f64)> {
- let Some(Action::Exec(c, v)) = acts.last().and_then(|a| a.first()) else { panic!("{acts:?}") };
- assert_eq!(c, "path.blob");
- v["points"].as_array().unwrap().iter().map(|q| (q[0].as_f64().unwrap(), q[1].as_f64().unwrap())).collect()
- };
- let mut t = GestureTool::new("blobBrush");
- let pts = blob(&drag_held(&mut t, &cx, &[(0.0, 0.0), (30.0, 5.0), (50.0, 8.0)], shift));
- assert_eq!(pts.len(), 3);
- assert!(pts.iter().all(|q| q.1 == 0.0 && q.0 >= 0.0), "{pts:?}");
- let pts = blob(&drag_held(&mut t, &cx, &[(0.0, 0.0), (5.0, 30.0), (8.0, 50.0)], shift));
- assert!(pts.iter().all(|q| q.0.abs() < 1e-9 && q.1 >= 0.0), "{pts:?}");
- // A pointer that crosses to the vertical line takes the points before it along, each on
- // its own side of the press point and at its own distance.
- let pts = blob(&drag_held(&mut t, &cx, &[(0.0, 0.0), (-40.0, -2.0), (100.0, 99.0), (90.0, 120.0)], shift));
- assert_eq!(pts.len(), 4, "{pts:?}");
- assert!(pts.iter().all(|q| q.0.abs() < 1e-9), "{pts:?}");
- assert!((pts[1].1 + 1604f64.sqrt()).abs() < 1e-9 && (pts[2].1 - 19801f64.sqrt()).abs() < 1e-9 && (pts[3].1 - 150.0).abs() < 1e-9, "{pts:?}");
- // Without Shift the stroke follows the pointer.
- let pts = blob(&drag_held(&mut t, &cx, &[(0.0, 0.0), (30.0, 5.0), (50.0, 8.0)], Mods::default()));
- assert_eq!(pts, vec![(0.0, 0.0), (30.0, 5.0), (50.0, 8.0)]);
- // Shift pressed and let go mid-stroke constrains only the points dragged while it is down,
- // and a later press of Shift leaves the points of the earlier one where they are.
- let ev = |k, x, y, m| PointerEvent::new(k, x, y).with_mods(m);
- t.pointer(&cx, &ev(PointerKind::Down, 0.0, 0.0, Mods::default()));
- t.pointer(&cx, &ev(PointerKind::Drag, 20.0, 10.0, Mods::default()));
- t.pointer(&cx, &ev(PointerKind::Drag, 40.0, 10.0, shift));
- t.pointer(&cx, &ev(PointerKind::Drag, 60.0, 10.0, Mods::default()));
- let pts = blob(&[t.pointer(&cx, &ev(PointerKind::Up, 10.0, 80.0, shift))]);
- assert_eq!((pts.len(), pts[1], pts[3]), (5, (20.0, 10.0), (60.0, 10.0)), "{pts:?}");
- assert!(pts[2].1 == 0.0 && (pts[2].0 - 1700f64.sqrt()).abs() < 1e-9, "{pts:?}");
- assert!(pts[4].0.abs() < 1e-9 && (pts[4].1 - 6500f64.sqrt()).abs() < 1e-9, "{pts:?}");
- // The axes turn with the Constrain Angle.
- cx.constrain_angle = 30.0;
- let pts = blob(&drag_held(&mut t, &cx, &[(0.0, 0.0), (40.0, -20.0)], shift));
- let a = (-pts[1].1).atan2(pts[1].0).to_degrees();
- assert!((a - 30.0).abs() < 1e-9, "{pts:?}");
- // A pointer back at the press point leaves the stroke on its line.
- let pts = blob(&drag_held(&mut t, &cx, &[(0.0, 0.0), (40.0, -20.0), (0.0, 0.0)], shift));
- let a = (-pts[1].1).atan2(pts[1].0).to_degrees();
- assert!(pts.len() == 3 && pts[2] == (0.0, 0.0) && (a - 30.0).abs() < 1e-9, "{pts:?}");
- }
-
- /// #3799: Shift held at the press draws a straight Pencil line from the press point, at 45°
- /// steps from the Constrain Angle, previewed as it is dragged; the Paintbrush keeps following
- /// the hand.
- #[test]
- fn pencil_shift_draws_a_straight_line_at_45_degree_steps() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let mut cx = cx(&d, &s, &p);
- cx.smart_guides = false;
- let shift = Mods { shift: true, ..Default::default() };
- let pts = |acts: &[Vec<Action>]| -> Vec<Vec<(f64, f64)>> {
- acts.iter()
- .filter_map(|a| a.iter().find_map(|a| if let Action::Preview(_, v) = a { Some(v["points"].clone()) } else { None }))
- .map(|v| v.as_array().unwrap().iter().map(|q| (q[0].as_f64().unwrap(), q[1].as_f64().unwrap())).collect())
- .collect()
- };
- let angle = |q: (f64, f64), from: (f64, f64)| (-(q.1 - from.1)).atan2(q.0 - from.0).to_degrees();
- let mut t = GestureTool::new("pencil");
- // A wavy drag heading up and right at about 40°: a line at 45°, as long as the drag.
- let acts = drag_held(&mut t, &cx, &[(0.0, 0.0), (30.0, -10.0), (50.0, -60.0), (100.0, -84.0)], shift);
- let all = pts(&acts);
- assert!(all.iter().all(|v| v.len() == 2 && v[0] == (0.0, 0.0)), "{all:?}");
- let end = *all.last().unwrap().last().unwrap();
- assert!((angle(end, (0.0, 0.0)) - 45.0).abs() < 1e-9, "{end:?}");
- assert!((end.0.hypot(end.1) - 100f64.hypot(84.0)).abs() < 1e-9, "{end:?}");
- let last = acts.last().unwrap();
- assert!(matches!(&last[0], Action::Preview(_, v) if v["closed"] == false) && last[1] == Action::Commit, "{last:?}");
- // The steps turn with the Constrain Angle: at 30°, a drag at 40° gives 30°, one at 60° gives 75°.
- cx.constrain_angle = 30.0;
- for (to, want) in [((100.0, -84.0), 30.0), ((50.0, -86.6), 75.0)] {
- let all = pts(&drag_held(&mut t, &cx, &[(10.0, 10.0), (to.0 + 10.0, to.1 + 10.0)], shift));
- let end = *all.last().unwrap().last().unwrap();
- assert!((angle(end, (10.0, 10.0)) - want).abs() < 1e-9, "{to:?}: {all:?}");
- }
- // Without Shift, and with the Paintbrush, the stroke follows the hand.
- for (id, m) in [("pencil", Mods::default()), ("paintbrush", shift)] {
- let mut t = GestureTool::new(id);
- let all = pts(&drag_held(&mut t, &cx, &[(0.0, 0.0), (30.0, -10.0), (50.0, -60.0)], m));
- assert_eq!(all.last().unwrap().len(), 3, "{id}: {all:?}");
- }
- }
-
- /// #3799: a Shift line leaves no Smart Guides of its press on screen while it is dragged
- /// (its end doesn't snap), and Alt at its release leaves it open.
- #[test]
- fn pencil_shift_line_drops_the_press_guides_and_stays_open_with_alt() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let cx = cx(&d, &s, &p);
- let shift = Mods { shift: true, ..Default::default() };
- let mut t = GestureTool::new("pencil");
- t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 102.0, 98.0).with_mods(shift));
- assert!(!t.overlays(&cx).is_empty(), "the press snaps to the corner and shows it");
- t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 300.0, 140.0).with_mods(shift));
- assert!(t.overlays(&cx).is_empty(), "{:?}", t.overlays(&cx));
- let shift_alt = Mods { shift: true, alt: true, ..Default::default() };
- let acts = t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 300.0, 140.0).with_mods(shift_alt));
- assert!(matches!(&acts[0], Action::Preview(_, v) if v["closed"] == false && v["points"].as_array().unwrap().len() == 2), "{acts:?}");
- }
-
- /// Before a press, the Pencil shows its straight-line cursor exactly when the press would draw a
- /// straight line; once the press is down, and with the Paintbrush, Shift leaves the tool's own
- /// cursor.
- #[test]
- fn pencil_shows_the_straight_line_cursor_when_a_press_draws_a_line() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let mut cx = cx(&d, &s, &p);
- cx.smart_guides = false;
- let at = Point::new(0.0, 0.0);
- let shift = Mods { shift: true, ..Default::default() };
- let alt = Mods { alt: true, ..Default::default() };
- let shift_alt = Mods { shift: true, alt: true, ..Default::default() };
- // The last drag's preview: two points for a line, all three for a freehand stroke, none
- // for a smoothing drag.
- let straight = |acts: &[Vec<Action>]| {
- acts[acts.len() - 2].iter().any(|a| matches!(a, Action::Preview(_, v) if v["points"].as_array().is_some_and(|q| q.len() == 2)))
- };
- for alt_smooth in [false, true] {
- for m in [Mods::default(), shift, alt, shift_alt] {
- let mut t = GestureTool::new("pencil");
- t.set_option("altSmooth", &json!(alt_smooth));
- let shown = t.cursor(&cx, at, m) == Cursor::PencilStraight;
- let drawn = straight(&drag_held(&mut t, &cx, &[(0.0, 0.0), (30.0, -10.0), (50.0, -60.0)], m));
- assert_eq!(shown, drawn, "altSmooth {alt_smooth}, {m:?}");
- }
- }
- let mut t = GestureTool::new("pencil");
- assert_eq!(t.cursor(&cx, at, Mods::default()), Cursor::PencilNew);
- assert_eq!(t.cursor(&cx, at, shift), Cursor::PencilStraight);
- assert_eq!(t.cursor(&cx, at, alt), Cursor::PencilStraight, "Alt alone draws a line at any angle");
- assert_eq!(t.cursor(&cx, at, shift_alt), Cursor::PencilStraight, "Alt at the release leaves a straight line open");
- // While the line is drawn, the Pencil's own cursor; after the release, Shift shows it again.
- t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0).with_mods(shift));
- t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 40.0, -10.0).with_mods(shift));
- assert_eq!(t.cursor(&cx, at, shift), Cursor::Pencil, "while the line is drawn");
- t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 40.0, -10.0).with_mods(shift));
- assert_eq!(t.cursor(&cx, at, shift), Cursor::PencilStraight, "after the release");
- // Shift pressed during a freehand stroke doesn't make it a line.
- t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
- t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 40.0, -10.0).with_mods(shift));
- assert_eq!(t.cursor(&cx, at, shift), Cursor::Pencil, "a freehand stroke");
- assert_eq!(GestureTool::new("paintbrush").cursor(&cx, at, shift), Cursor::Paintbrush);
- assert_eq!(Cursor::PencilStraight.precise(), Cursor::Crosshair, "Use Precise Cursors");
- }
-
- /// Before a press, the Pencil shows its new-path cursor (the star) exactly when the press draws
- /// a new path: over an end of a selected open path, which the stroke continues, and over a
- /// selected path, which it redraws, it does not. With nothing selected, with Edit Selected Paths
- /// off and away from the paths, it does; while a stroke is drawn, it does not.
- #[test]
- fn pencil_shows_the_star_before_a_press_that_draws_a_new_path() {
- let (mut d, _) = doc_with_rect();
- let l = d.layers[0].id;
- let id = d.alloc_id();
- let line = vectorcraft_geom::PathData::from_bezpath(&vectorcraft_geom::BezPath::from_vec(vec![
- vectorcraft_geom::PathEl::MoveTo(Point::new(300.0, 300.0)),
- vectorcraft_geom::PathEl::LineTo(Point::new(400.0, 300.0)),
- ]));
- d.insert(Some(l), 1, vectorcraft_doc::Node::path(id, line, vectorcraft_doc::Appearance::default_art())).unwrap();
- let mut s = Selection::default();
- s.set([id]);
- let p = paint();
- let mut cx = cx(&d, &s, &p);
- cx.smart_guides = false;
- // The stroke edits the selected path when its previews continue or redraw it.
- let edits = |acts: &[Vec<Action>]| {
- acts.iter().flatten().any(|a| matches!(a, Action::Preview(_, v) if v.get("extend").is_some() || v.get("redraw").is_some()))
- };
- let (end, middle, away) = (Point::new(405.0, 303.0), Point::new(350.0, 304.0), Point::new(350.0, 360.0));
- for edit_within in [12.0, 0.0] {
- for at in [end, Point::new(296.0, 302.0), middle, away, Point::new(200.0, 200.0)] {
- let mut t = GestureTool::new("pencil");
- t.set_option("editWithin", &json!(edit_within));
- let shown = t.cursor(&cx, at, Mods::default()) == Cursor::PencilNew;
- let acts = drag(&mut t, &cx, &[(at.x, at.y), (360.0, 330.0), (420.0, 350.0)], Mods::default());
- assert_eq!(shown, !edits(&acts), "editWithin {edit_within} at {at:?}");
- }
- }
- let mut t = GestureTool::new("pencil");
- assert_eq!(t.cursor(&cx, end, Mods::default()), Cursor::Pencil, "over an end the stroke continues");
- assert_eq!(t.cursor(&cx, middle, Mods::default()), Cursor::Pencil, "over the path the stroke redraws");
- assert_eq!(t.cursor(&cx, away, Mods::default()), Cursor::PencilNew, "away from the path");
- // While a stroke is drawn, the Pencil's own cursor.
- t.pointer(&cx, &PointerEvent::new(PointerKind::Down, away.x, away.y));
- t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 380.0, 380.0));
- assert_eq!(t.cursor(&cx, Point::new(380.0, 380.0), Mods::default()), Cursor::Pencil, "while a stroke is drawn");
- t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 380.0, 380.0));
- assert_eq!(t.cursor(&cx, away, Mods::default()), Cursor::PencilNew, "after the release");
- // With nothing selected, every press draws a new path.
- let none = Selection::default();
- let cx_none = crate::testutil::cx(&d, &none, &p);
- assert_eq!(GestureTool::new("pencil").cursor(&cx_none, middle, Mods::default()), Cursor::PencilNew, "nothing selected");
- // Shift held: a straight line, with its own cursor; the Paintbrush keeps its cursor.
- let shift = Mods { shift: true, ..Default::default() };
- assert_eq!(GestureTool::new("pencil").cursor(&cx, away, shift), Cursor::PencilStraight);
- assert_eq!(GestureTool::new("paintbrush").cursor(&cx, away, Mods::default()), Cursor::Paintbrush);
- }
-
- /// #3799: a Shift line started on an end of a selected open path continues the path from that
- /// end, constrained from the end itself.
- #[test]
- fn pencil_shift_line_continues_a_selected_path_from_its_end() {
- let (mut d, _) = doc_with_rect();
- let l = d.layers[0].id;
- let id = d.alloc_id();
- let line = vectorcraft_geom::PathData::from_bezpath(&vectorcraft_geom::BezPath::from_vec(vec![
- vectorcraft_geom::PathEl::MoveTo(Point::new(300.0, 300.0)),
- vectorcraft_geom::PathEl::LineTo(Point::new(400.0, 300.0)),
- ]));
- d.insert(Some(l), 1, vectorcraft_doc::Node::path(id, line, vectorcraft_doc::Appearance::default_art())).unwrap();
- let mut s = Selection::default();
- s.set([id]);
- let p = paint();
- let mut cx = cx(&d, &s, &p);
- cx.smart_guides = false;
- let mut t = GestureTool::new("pencil");
- // Pressed 5 pt off the end, released 100 pt right and 4 pt above it.
- let acts = drag_held(&mut t, &cx, &[(405.0, 303.0), (450.0, 290.0), (500.0, 296.0)], Mods { shift: true, ..Default::default() });
- let Some(Action::Preview(_, v)) = acts.last().and_then(|a| a.first()) else { panic!("{acts:?}") };
- assert_eq!(v["extend"], json!({"id": id.0, "end": "end"}));
- assert_eq!(v["points"], json!([[400.0, 300.0], [400.0 + 100f64.hypot(4.0), 300.0]]));
- }
-
- /// Before a press over an end of a selected open path, the Pencil shows its continuation cursor
- /// exactly when the press would draw a straight line that continues the path; away from the
- /// ends, with nothing selected, with Edit Selected Paths off, once the press is down and with
- /// the Paintbrush, it does not.
- #[test]
- fn pencil_shows_the_continuation_cursor_over_an_end_a_line_continues() {
- let (mut d, _) = doc_with_rect();
- let l = d.layers[0].id;
- let id = d.alloc_id();
- let line = vectorcraft_geom::PathData::from_bezpath(&vectorcraft_geom::BezPath::from_vec(vec![
- vectorcraft_geom::PathEl::MoveTo(Point::new(300.0, 300.0)),
- vectorcraft_geom::PathEl::LineTo(Point::new(400.0, 300.0)),
- ]));
- d.insert(Some(l), 1, vectorcraft_doc::Node::path(id, line, vectorcraft_doc::Appearance::default_art())).unwrap();
- let mut s = Selection::default();
- s.set([id]);
- let p = paint();
- let mut cx = cx(&d, &s, &p);
- cx.smart_guides = false;
- let shift = Mods { shift: true, ..Default::default() };
- let alt = Mods { alt: true, ..Default::default() };
- let shift_alt = Mods { shift: true, alt: true, ..Default::default() };
- // The release's stroke: a straight line that continues the path.
- let continues = |acts: &[Vec<Action>]| {
- acts.last().and_then(|a| a.first()).is_some_and(
- |a| matches!(a, Action::Preview(_, v) if v.get("extend").is_some() && v["points"].as_array().is_some_and(|q| q.len() == 2)),
- )
- };
- for alt_smooth in [false, true] {
- for m in [Mods::default(), shift, alt, shift_alt] {
- for (at, other_end) in [(Point::new(405.0, 303.0), (500.0, 296.0)), (Point::new(296.0, 302.0), (200.0, 310.0))] {
- let mut t = GestureTool::new("pencil");
- t.set_option("altSmooth", &json!(alt_smooth));
- let shown = t.cursor(&cx, at, m) == Cursor::PencilContinue;
- let acts = drag_held(&mut t, &cx, &[(at.x, at.y), (450.0, 250.0), other_end], m);
- assert_eq!(shown, continues(&acts), "altSmooth {alt_smooth}, {m:?} at {at:?}");
- }
- }
- }
- let mut t = GestureTool::new("pencil");
- let end = Point::new(405.0, 303.0);
- assert_eq!(t.cursor(&cx, end, shift), Cursor::PencilContinue);
- assert_eq!(t.cursor(&cx, end, alt), Cursor::PencilContinue, "Alt alone continues at any angle");
- assert_eq!(t.cursor(&cx, end, Mods::default()), Cursor::Pencil, "without Shift or Alt the stroke is freehand");
- assert_eq!(t.cursor(&cx, Point::new(350.0, 360.0), shift), Cursor::PencilStraight, "away from the ends");
- // While the line is drawn, the Pencil's own cursor.
- t.pointer(&cx, &PointerEvent::new(PointerKind::Down, end.x, end.y).with_mods(shift));
- t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 450.0, 303.0).with_mods(shift));
- assert_eq!(t.cursor(&cx, end, shift), Cursor::Pencil, "while the line is drawn");
- t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 450.0, 303.0).with_mods(shift));
- // Edit Selected Paths off: the press draws a new line.
- t.set_option("editWithin", &json!(0.0));
- assert_eq!(t.cursor(&cx, end, shift), Cursor::PencilStraight, "Edit Selected Paths off");
- let none = Selection::default();
- let cx_none = crate::testutil::cx(&d, &none, &p);
- assert_eq!(GestureTool::new("pencil").cursor(&cx_none, end, shift), Cursor::PencilStraight, "nothing selected");
- assert_eq!(GestureTool::new("paintbrush").cursor(&cx, end, shift), Cursor::Paintbrush);
- assert_eq!(Cursor::PencilContinue.precise(), Cursor::Crosshair, "Use Precise Cursors");
- }
-
- /// #3846: Alt during a Shift line doesn't promise a close the release can't do, and with Alt
- /// Toggles to Smooth, Alt pressed after the press doesn't turn the line into a smoothing drag.
- #[test]
- fn pencil_shift_line_ignores_alt_for_cursor_and_smoothing() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let mut cx = cx(&d, &s, &p);
- cx.smart_guides = false;
- let shift = Mods { shift: true, ..Default::default() };
- let shift_alt = Mods { shift: true, alt: true, ..Default::default() };
- let mut t = GestureTool::new("pencil");
- t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0).with_mods(shift));
- assert_eq!(t.cursor(&cx, Point::new(0.0, 0.0), shift_alt), Cursor::Pencil);
- t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 0.0, 0.0).with_mods(shift));
-
- let mut t = GestureTool::new("pencil");
- t.alt_smooth = true;
- t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0).with_mods(shift));
- let acts = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 80.0, 0.0).with_mods(shift_alt));
- assert!(matches!(acts.as_slice(), [Action::Begin(_), Action::Preview(..)]), "{acts:?}");
- let acts = t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 80.0, 0.0).with_mods(shift_alt));
- assert!(matches!(&acts[0], Action::Preview(_, v) if v["points"].as_array().unwrap().len() == 2), "{acts:?}");
- }
-
- /// #3846: a Shift line dragged back to its press point has no line: the preview is cancelled
- /// and the release commits nothing (not the previous end of the line).
- #[test]
- fn pencil_shift_line_back_at_the_press_point_draws_nothing() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let mut cx = cx(&d, &s, &p);
- cx.smart_guides = false;
- let shift = Mods { shift: true, ..Default::default() };
- // Released back at the press point, and dragged back there first.
- for back_in_drag in [false, true] {
- let mut t = GestureTool::new("pencil");
- t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0).with_mods(shift));
- t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 80.0, 0.0).with_mods(shift));
- let mut acts = vec![];
- if back_in_drag {
- // The shown line goes as soon as the pointer is back, not only at the release.
- let back = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 0.2, 0.0).with_mods(shift));
- assert_eq!(back, vec![Action::Cancel]);
- acts.extend(back);
- }
- acts.extend(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 0.2, 0.0).with_mods(shift)));
- assert!(acts.contains(&Action::Cancel), "{back_in_drag}: {acts:?}");
- assert!(!acts.contains(&Action::Commit) && !acts.iter().any(|a| matches!(a, Action::Preview(..))), "{back_in_drag}: {acts:?}");
- }
- }
-
- /// #3799: Alt held at the press draws a straight Pencil line at any angle from the press point
- /// to the pointer, previewed as it is dragged, and left open by a release with Alt still held;
- /// with Shift too it keeps Shift's 45° steps. Alt pressed after the press keeps the stroke
- /// freehand and closes it at the release, and the Paintbrush keeps following the hand.
- #[test]
- fn pencil_alt_at_the_press_draws_a_straight_line_at_any_angle() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let mut cx = cx(&d, &s, &p);
- cx.smart_guides = false;
- let alt = Mods { alt: true, ..Default::default() };
- let pts = |acts: &[Vec<Action>]| -> Vec<Vec<(f64, f64)>> {
- acts.iter()
- .filter_map(|a| a.iter().find_map(|a| if let Action::Preview(_, v) = a { Some(v["points"].clone()) } else { None }))
- .map(|v| v.as_array().unwrap().iter().map(|q| (q[0].as_f64().unwrap(), q[1].as_f64().unwrap())).collect())
- .collect()
- };
- let wavy = [(0.0, 0.0), (30.0, -10.0), (50.0, -60.0), (100.0, -84.0)];
- let mut t = GestureTool::new("pencil");
- assert_eq!(t.cursor(&cx, Point::new(0.0, 0.0), alt), Cursor::PencilStraight, "before the press");
- let acts = drag_held(&mut t, &cx, &wavy, alt);
- let all = pts(&acts);
- assert_eq!(all.len(), 4, "{all:?}");
- assert!(all.iter().all(|v| v.len() == 2 && v[0] == (0.0, 0.0)), "{all:?}");
- assert_eq!(all[1][1], (50.0, -60.0), "the preview follows the pointer at its own angle");
- assert_eq!(all[3][1], (100.0, -84.0), "{all:?}");
- let last = acts.last().unwrap();
- assert!(matches!(&last[0], Action::Preview(_, v) if v["closed"] == false) && last[1] == Action::Commit, "{last:?}");
- // While the line is drawn, Alt shows no closing ring.
- t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0).with_mods(alt));
- t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 40.0, 10.0).with_mods(alt));
- assert_eq!(t.cursor(&cx, Point::new(40.0, 10.0), alt), Cursor::Pencil);
- t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 40.0, 10.0).with_mods(alt));
- // Shift with Alt: 45° steps.
- let all = pts(&drag_held(&mut t, &cx, &wavy, Mods { shift: true, alt: true, ..Default::default() }));
- let end = *all.last().unwrap().last().unwrap();
- assert!(((-end.1).atan2(end.0).to_degrees() - 45.0).abs() < 1e-9, "{end:?}");
- // Alt pressed after the press: freehand, closed at the release.
- let acts = drag(&mut t, &cx, &wavy, alt);
- assert_eq!(pts(&acts).last().unwrap().len(), 4, "{acts:?}");
- assert!(matches!(&acts.last().unwrap()[0], Action::Preview(_, v) if v["closed"] == true), "{acts:?}");
- // The Paintbrush with Alt held follows the hand and closes.
- let mut b = GestureTool::new("paintbrush");
- let acts = drag_held(&mut b, &cx, &wavy, alt);
- assert_eq!(pts(&acts).last().unwrap().len(), 4, "{acts:?}");
- assert!(matches!(&acts.last().unwrap()[0], Action::Preview(_, v) if v["closed"] == true), "{acts:?}");
- }
-
- /// #3799: with Alt key toggles to Smooth Tool on, Alt held at the press smooths as before and
- /// draws no line.
- #[test]
- fn pencil_alt_with_alt_to_smooth_on_smooths_instead_of_drawing_a_line() {
- let (d, id) = doc_with_rect();
- let mut s = Selection::default();
- s.set([id]);
- let p = paint();
- let mut cx = cx(&d, &s, &p);
- cx.smart_guides = false;
- let alt = Mods { alt: true, ..Default::default() };
- let mut t = GestureTool::new("pencil");
- t.set_option("altSmooth", &json!(true));
- let acts = drag_held(&mut t, &cx, &[(50.0, 150.0), (150.0, 150.0), (250.0, 160.0)], alt);
- assert!(acts[..acts.len() - 1].iter().all(|a| a.is_empty()), "{acts:?}");
- assert!(matches!(&acts.last().unwrap()[0], Action::Exec(c, v) if c == "path.smoothRegion" && v["points"].as_array().unwrap().len() == 3));
- }
-
- /// #3799: Alt's line starts and ends on Smart Guides as a stroke does, and pressed on an end of
- /// a selected open path it continues the path from that end to the pointer.
- #[test]
- fn pencil_alt_line_snaps_its_ends_and_continues_a_selected_path() {
- let (mut d, _) = doc_with_rect();
- let alt = Mods { alt: true, ..Default::default() };
- let p = paint();
- {
- let s = Selection::default();
- let cx = cx(&d, &s, &p);
- let mut t = GestureTool::new("pencil");
- let acts = drag_held(&mut t, &cx, &[(102.0, 98.0), (151.0, 300.0), (198.0, 203.0)], alt);
- let Some(Action::Preview(_, v)) = acts.last().and_then(|a| a.first()) else { panic!("{acts:?}") };
- assert_eq!(v["points"], json!([[100.0, 100.0], [200.0, 200.0]]));
- }
- let l = d.layers[0].id;
- let id = d.alloc_id();
- let line = vectorcraft_geom::PathData::from_bezpath(&vectorcraft_geom::BezPath::from_vec(vec![
- vectorcraft_geom::PathEl::MoveTo(Point::new(300.0, 300.0)),
- vectorcraft_geom::PathEl::LineTo(Point::new(400.0, 300.0)),
- ]));
- d.insert(Some(l), 1, vectorcraft_doc::Node::path(id, line, vectorcraft_doc::Appearance::default_art())).unwrap();
- let mut s = Selection::default();
- s.set([id]);
- let mut cx = cx(&d, &s, &p);
- cx.smart_guides = false;
- let mut t = GestureTool::new("pencil");
- let acts = drag_held(&mut t, &cx, &[(405.0, 303.0), (450.0, 340.0), (470.0, 330.0)], alt);
- let Some(Action::Preview(_, v)) = acts.last().and_then(|a| a.first()) else { panic!("{acts:?}") };
- assert_eq!(v["extend"], json!({"id": id.0, "end": "end"}));
- assert_eq!(v["points"], json!([[400.0, 300.0], [470.0, 330.0]]));
- }
-
- #[test]
- fn pencil_alt_closes_and_continues_selected_path() {
- let (d, id) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let cx = cx(&d, &s, &p);
- let mut t = GestureTool::new("paintbrush");
- let acts = drag(&mut t, &cx, &[(0.0, 0.0), (10.0, 5.0), (20.0, 0.0)], Mods { alt: true, ..Default::default() });
- assert!(matches!(&acts.last().unwrap()[0], Action::Preview(_, v) if v["closed"] == true && v["style"] == "brush"));
- // A selected closed rect is not continued; an open path would be (see engine tests).
- let mut s2 = Selection::default();
- s2.set([id]);
- let cx2 = crate::testutil::cx(&d, &s2, &p);
- let acts = drag(&mut t, &cx2, &[(100.0, 100.0), (90.0, 90.0)], Mods::default());
- assert!(matches!(&acts[1][1], Action::Preview(_, v) if v.get("extend").is_none()));
- }
-
- /// Edit selected paths within 0 turns editing off: a stroke that starts exactly on an end of a
- /// selected open path draws a new path; at 12 px it continues the path from that end.
- #[test]
- fn edit_selected_paths_within_0_draws_a_new_path_from_an_end() {
- let (mut d, _) = doc_with_rect();
- let l = d.layers[0].id;
- let id = d.alloc_id();
- let line = vectorcraft_geom::PathData::from_bezpath(&vectorcraft_geom::BezPath::from_vec(vec![
- vectorcraft_geom::PathEl::MoveTo(Point::new(300.0, 300.0)),
- vectorcraft_geom::PathEl::LineTo(Point::new(400.0, 300.0)),
- ]));
- d.insert(Some(l), 1, vectorcraft_doc::Node::path(id, line, vectorcraft_doc::Appearance::default_art())).unwrap();
- let mut s = Selection::default();
- s.set([id]);
- let p = paint();
- let cx = cx(&d, &s, &p);
- for tool in ["pencil", "paintbrush"] {
- let mut t = GestureTool::new(tool);
- for (within, extends) in [(12.0, true), (0.0, false)] {
- t.set_option("editWithin", &json!(within));
- for (x, end) in [(400.0, "end"), (300.0, "start")] {
- let acts = drag(&mut t, &cx, &[(x, 300.0), (x + 20.0, 350.0), (x, 380.0)], Mods::default());
- let Some(Action::Preview(_, v)) = acts.last().and_then(|a| a.first()) else { panic!("{tool}: {acts:?}") };
- if extends {
- assert_eq!(v["extend"], json!({"id": id.0, "end": end}), "{tool} from the {end}");
- } else {
- assert!(v.get("extend").is_none() && v.get("redraw").is_none(), "{tool} from the {end}: {v}");
- }
- }
- }
- }
- }
-
- /// A Pencil stroke from an end of a selected open path to an end of another selected open path
- /// connects the two; it does not when the other path is not selected, and the Paintbrush does
- /// not connect.
- #[test]
- fn pencil_connects_a_stroke_from_one_selected_path_to_an_end_of_another() {
- let (mut d, _) = doc_with_rect();
- let l = d.layers[0].id;
- let add = |d: &mut vectorcraft_doc::Document, a: (f64, f64), b: (f64, f64)| {
- let id = d.alloc_id();
- let line = vectorcraft_geom::PathData::from_bezpath(&vectorcraft_geom::BezPath::from_vec(vec![
- vectorcraft_geom::PathEl::MoveTo(Point::new(a.0, a.1)),
- vectorcraft_geom::PathEl::LineTo(Point::new(b.0, b.1)),
- ]));
- d.insert(Some(l), 1, vectorcraft_doc::Node::path(id, line, vectorcraft_doc::Appearance::default_art())).unwrap();
- id
- };
- let a = add(&mut d, (300.0, 300.0), (400.0, 300.0));
- let b = add(&mut d, (500.0, 400.0), (600.0, 400.0));
- let p = paint();
- let stroke = [(400.0, 300.0), (450.0, 350.0), (499.0, 401.0)];
- let mut both = Selection::default();
- both.set([a, b]);
- let mut one = Selection::default();
- one.set([a]);
- // The previews select the path continued: after the press only it is selected.
- let last = |tool: &str, at_press: &Selection| {
- let mut t = GestureTool::new(tool);
- t.pointer(&cx(&d, at_press, &p), &PointerEvent::new(PointerKind::Down, stroke[0].0, stroke[0].1));
- let after = cx(&d, &one, &p);
- t.pointer(&after, &PointerEvent::new(PointerKind::Drag, stroke[1].0, stroke[1].1));
- t.pointer(&after, &PointerEvent::new(PointerKind::Drag, stroke[2].0, stroke[2].1));
- let acts = t.pointer(&after, &PointerEvent::new(PointerKind::Up, stroke[2].0, stroke[2].1));
- let Some(Action::Preview(_, v)) = acts.first() else { panic!("{acts:?}") };
- v.clone()
- };
- let v = last("pencil", &both);
- assert_eq!((v["extend"].clone(), v["connect"].clone()), (json!({"id": a.0, "end": "end"}), json!({"id": b.0, "end": "start"})));
- assert!(last("paintbrush", &both).get("connect").is_none(), "the Paintbrush");
- let v = last("pencil", &one);
- assert!(v.get("extend").is_some() && v.get("connect").is_none(), "{v}");
- }
-
- /// Close paths when ends are within 0 turns closing off: a stroke that ends exactly where it
- /// started stays open; at 15 px it is closed.
- #[test]
- fn close_paths_within_0_leaves_a_stroke_that_ends_at_its_start_open() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let cx = cx(&d, &s, &p);
- for tool in ["pencil", "paintbrush"] {
- let mut t = GestureTool::new(tool);
- for (within, closes) in [(15.0, true), (0.0, false)] {
- t.set_option("closeWithin", &json!(within));
- let acts = drag(&mut t, &cx, &[(310.0, 330.0), (360.0, 350.0), (330.0, 390.0), (310.0, 330.0)], Mods::default());
- let Some(Action::Preview(_, v)) = acts.last().and_then(|a| a.first()) else { panic!("{tool}: {acts:?}") };
- assert_eq!(v["points"][0], v["points"][3], "{tool}");
- assert_eq!(v["closed"], json!(closes), "{tool} at {within} px");
- }
- }
- }
-
- /// While a stroke is drawn back near its start, the cursor shows the closing ring when a
- /// release there closes the path (Close Paths When Ends Are Within), and the tool's own cursor
- /// away from the start, at 0 pixels and after the release.
- #[test]
- fn a_stroke_near_its_start_shows_the_closing_cursor() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let cx = cx(&d, &s, &p);
- let none = Mods::default();
- let tools = [("pencil", Cursor::Pencil, Cursor::PencilClose), ("paintbrush", Cursor::Paintbrush, Cursor::PaintbrushClose)];
- for (tool, own, closing) in tools {
- for within in [15.0, 0.0] {
- let near = if within > 0.0 { closing } else { own };
- let mut t = GestureTool::new(tool);
- t.set_option("closeWithin", &json!(within));
- let mut at = |k, x, y| {
- let acts = t.pointer(&cx, &PointerEvent::new(k, x, y));
- (acts, t.cursor(&cx, Point::new(x, y), none))
- };
- assert_eq!(at(PointerKind::Down, 310.0, 330.0).1, own, "{tool} at the press");
- assert_eq!(at(PointerKind::Drag, 360.0, 350.0).1, own, "{tool} away from the start");
- assert_eq!(at(PointerKind::Drag, 330.0, 390.0).1, own, "{tool} away from the start");
- assert_eq!(at(PointerKind::Drag, 318.0, 335.0).1, near, "{tool} near the start at {within} px");
- assert_eq!(at(PointerKind::Drag, 345.0, 340.0).1, own, "{tool} away from the start again");
- assert_eq!(at(PointerKind::Drag, 318.0, 335.0).1, near, "{tool} back near the start at {within} px");
- let (acts, after) = at(PointerKind::Up, 318.0, 335.0);
- let Some(Action::Preview(_, v)) = acts.first() else { panic!("{tool}: {acts:?}") };
- assert_eq!(v["closed"], json!(within > 0.0), "{tool}: the release does what the cursor showed");
- assert_eq!(after, if tool == "pencil" { Cursor::PencilNew } else { own }, "{tool} after the release");
- }
- }
- // A straight Pencil line (Shift or Alt held at the press) stays open, so it shows no ring
- // near its start.
- for held in [Mods { shift: true, ..Mods::default() }, Mods { alt: true, ..Mods::default() }] {
- let mut t = GestureTool::new("pencil");
- t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 310.0, 330.0).with_mods(held));
- for (x, y) in [(360.0, 330.0), (330.0, 390.0), (318.0, 335.0)] {
- t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, x, y).with_mods(held));
- }
- for m in [held, none] {
- assert_eq!(t.cursor(&cx, Point::new(318.0, 335.0), m), Cursor::Pencil, "a straight line, {held:?}, {m:?}");
- }
- }
- }
-
- /// A Paintbrush sample under a pixel from the last point is dropped, and a release there keeps
- /// the last point: the closing cursor follows that point, not the pointer.
- #[test]
- fn the_paintbrush_closing_cursor_follows_the_point_a_release_keeps() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let cx = cx(&d, &s, &p);
- let none = Mods::default();
- let mut t = GestureTool::new("paintbrush");
- t.set_option("closeWithin", &json!(15.0));
- for (k, x, y) in [(PointerKind::Down, 310.0, 330.0), (PointerKind::Drag, 360.0, 350.0), (PointerKind::Drag, 330.0, 390.0)] {
- t.pointer(&cx, &PointerEvent::new(k, x, y));
- }
- // The last point kept is 15.5 from the start, outside Close Paths When Ends Are Within.
- t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 325.5, 330.0));
- assert_eq!(t.cursor(&cx, Point::new(325.5, 330.0), none), Cursor::Paintbrush, "outside the closing distance");
- // The pointer moves 0.7 to 14.8 from the start; the sample is dropped.
- t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 324.8, 330.0));
- assert_eq!(t.cursor(&cx, Point::new(324.8, 330.0), none), Cursor::Paintbrush, "the dropped sample shows no ring");
- let acts = t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 324.8, 330.0));
- let Some(Action::Preview(_, v)) = acts.first() else { panic!("{acts:?}") };
- assert_eq!(v["closed"], json!(false), "the release keeps the last point and leaves the path open");
- }
-
- #[test]
- fn eraser_and_knife_exec_on_release() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let cx = cx(&d, &s, &p);
- let mut t = GestureTool::new("eraser");
- let acts = drag(&mut t, &cx, &[(50.0, 150.0), (250.0, 150.0)], Mods::default());
- assert!(acts[1].is_empty());
- assert!(matches!(&acts[2][0], Action::Exec(c, v) if c == "path.eraseRegion" && v["size"] == 10.0));
- let mut k = GestureTool::new("knife");
- k.pointer(&cx, &PointerEvent::new(PointerKind::Down, 50.0, 150.0));
- k.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 150.0, 150.0));
- assert_eq!(k.overlays(&cx).len(), 1);
- let a = k.pointer(&cx, &PointerEvent::new(PointerKind::Up, 250.0, 150.0));
- assert!(matches!(&a[0], Action::Exec(c, v) if c == "path.knife" && v["points"].as_array().unwrap().len() == 3));
- }
-
- /// The Eraser's Angle and Roundness (Eraser Tool Options) go with its stroke, kept within
- /// −180–180° and 1–100%; while it drags, a tip that is not round shows the outline of the area
- /// it covers, and a round one the drag as wide as the tip.
- #[test]
- fn the_eraser_sends_its_tip_and_shows_the_area_it_covers() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let cx = cx(&d, &s, &p);
- let mut t = GestureTool::new("eraser");
- t.set_option("size", &json!(20));
- t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 50.0, 150.0));
- t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 150.0, 150.0));
- let round = t.overlays(&cx);
- assert!(matches!(&round[..], [Overlay::Path { width, .. }] if *width == 20.0), "{round:?}");
- t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 250.0, 150.0));
- for (angle, roundness, sent) in [(90.0, 25.0, (90.0, 25.0)), (400.0, 0.0, (180.0, 1.0)), (-400.0, 250.0, (-180.0, 100.0))] {
- t.set_option("angle", &json!(angle));
- t.set_option("roundness", &json!(roundness));
- assert_eq!((t.options()["angle"].as_f64(), t.options()["roundness"].as_f64()), (Some(sent.0), Some(sent.1)));
- let acts = drag(&mut t, &cx, &[(50.0, 150.0), (250.0, 150.0)], Mods::default());
- assert!(
- matches!(&acts[2][0], Action::Exec(c, v) if c == "path.eraseRegion" && v["size"] == 20.0 && v["angle"] == sent.0 && v["roundness"] == sent.1),
- "{acts:?}"
- );
- }
- // A tip 20 pt long and 5 pt wide, standing upright: along a horizontal drag from x 50 to
- // x 150 the outline reaches 2.5 pt either side of the drag and 10 pt above and below
- // its ends.
- t.set_option("angle", &json!(90));
- t.set_option("roundness", &json!(25));
- t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 50.0, 150.0));
- t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 150.0, 150.0));
- let o = t.overlays(&cx);
- let [Overlay::Path { path, width, .. }] = &o[..] else { panic!("{o:?}") };
- assert_eq!(*width, 1.0);
- let b = vectorcraft_geom::Shape::bounding_box(path);
- assert!((b.x0 - 47.5).abs() < 0.1 && (b.x1 - 152.5).abs() < 0.1, "{b:?}");
- assert!((b.y0 - 140.0).abs() < 0.1 && (b.y1 - 160.0).abs() < 0.1, "{b:?}");
- }
-
- #[test]
- fn smooth_needs_selection_and_brackets_resize() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let cx = cx(&d, &s, &p);
- let mut t = GestureTool::new("smooth");
- let acts = drag(&mut t, &cx, &[(50.0, 150.0), (250.0, 150.0)], Mods::default());
- assert!(acts.iter().all(|a| a.is_empty()));
- let mut b = GestureTool::new("blobBrush");
- b.key(&cx, ToolKey::BracketRight, Mods::default());
- assert_eq!(b.options()["size"], 11.0);
- }
-
- #[test]
- fn pencil_alt_toggles_to_smooth_when_enabled_and_closes_when_disabled() {
- let (d, id) = doc_with_rect();
- let mut s = Selection::default();
- s.set([id]);
- let p = paint();
- let cx = cx(&d, &s, &p);
-
- // Off by default, as Pencil Tool Options ships it; on, Alt lends the Smooth tool.
- let mut t = GestureTool::new("pencil");
- assert_eq!(t.options()["altSmooth"], json!(false));
- t.set_option("altSmooth", &json!(true));
-
- // When alt is pressed, cursor shows smooth tool.
- let alt_mod = Mods { alt: true, ..Default::default() };
- assert_eq!(t.cursor(&cx, Point::new(50.0, 50.0), alt_mod), Cursor::Smooth);
- assert_eq!(t.cursor(&cx, Point::new(50.0, 50.0), Mods::default()), Cursor::PencilNew);
-
- // Alt-drag over selected path smooths it.
- let acts = drag_held(&mut t, &cx, &[(50.0, 150.0), (150.0, 150.0), (250.0, 150.0)], alt_mod);
- assert!(acts[1].is_empty(), "drag does not preview freehand path while smoothing");
- let last = acts.last().unwrap();
- assert!(
- matches!(&last[0], Action::Exec(c, v) if c == "path.smoothRegion" && v["points"].as_array().unwrap().len() == 3),
- "expected path.smoothRegion, got: {last:?}"
- );
-
- // When altSmooth is disabled:
- t.set_option("altSmooth", &json!(false));
- assert_eq!(t.options()["altSmooth"], json!(false));
- // Before a press, Alt gives a straight line rather than a closed path.
- assert_eq!(t.cursor(&cx, Point::new(50.0, 50.0), alt_mod), Cursor::PencilStraight);
-
- // A drag released with Alt held draws a closed pencil path.
- let empty_sel = Selection::default();
- let cx_empty = crate::testutil::cx(&d, &empty_sel, &p);
- let acts = drag(&mut t, &cx_empty, &[(0.0, 0.0), (10.0, 5.0), (20.0, 0.0)], alt_mod);
- assert_eq!(acts[1][0], Action::Begin("Pencil".into()));
- let last = acts.last().unwrap();
- assert!(matches!(&last[0], Action::Preview(_, v) if v["closed"] == true && v["style"] == "pencil"));
- assert_eq!(last[1], Action::Commit);
- }
-}
+mod tests;
diff --git a/crates/tools/src/draw2/gesture/tests.rs b/crates/tools/src/draw2/gesture/tests.rs
new file mode 100644
index 000000000..5cc7684ea
--- /dev/null
+++ b/crates/tools/src/draw2/gesture/tests.rs
@@ -0,0 +1,1036 @@
+use super::*;
+use crate::testutil::*;
+use vectorcraft_doc::Selection;
+
+fn drag(t: &mut GestureTool, cx: &ToolContext, pts: &[(f64, f64)], m: Mods) -> Vec<Vec<Action>> {
+ let mut v = vec![t.pointer(cx, &PointerEvent::new(PointerKind::Down, pts[0].0, pts[0].1))];
+ for &(x, y) in &pts[1..] {
+ v.push(t.pointer(cx, &PointerEvent::new(PointerKind::Drag, x, y)));
+ }
+ let l = pts[pts.len() - 1];
+ v.push(t.pointer(cx, &PointerEvent::new(PointerKind::Up, l.0, l.1).with_mods(m)));
+ v
+}
+
+fn drag_held(t: &mut GestureTool, cx: &ToolContext, pts: &[(f64, f64)], m: Mods) -> Vec<Vec<Action>> {
+ let mut v = vec![t.pointer(cx, &PointerEvent::new(PointerKind::Down, pts[0].0, pts[0].1).with_mods(m))];
+ for &(x, y) in &pts[1..] {
+ v.push(t.pointer(cx, &PointerEvent::new(PointerKind::Drag, x, y).with_mods(m)));
+ }
+ let l = pts[pts.len() - 1];
+ v.push(t.pointer(cx, &PointerEvent::new(PointerKind::Up, l.0, l.1).with_mods(m)));
+ v
+}
+
+/// The Pencil's new path starts and ends on Smart Guides (#506), the points between where
+/// the hand went.
+#[test]
+fn pencil_ends_snap_to_smart_guides() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+ let mut t = GestureTool::new("pencil");
+ let acts = drag(&mut t, &cx, &[(102.0, 98.0), (151.0, 300.0), (250.0, 320.0), (198.0, 203.0)], Mods::default());
+ let Some(Action::Preview(_, v)) = acts.last().and_then(|a| a.first()) else { panic!("{acts:?}") };
+ assert_eq!(v["points"], json!([[100.0, 100.0], [151.0, 300.0], [250.0, 320.0], [200.0, 200.0]]));
+ // The Paintbrush follows the hand all the way.
+ let mut t = GestureTool::new("paintbrush");
+ let acts = drag(&mut t, &cx, &[(102.0, 98.0), (151.0, 300.0)], Mods::default());
+ let Some(Action::Preview(_, v)) = acts.last().and_then(|a| a.first()) else { panic!("{acts:?}") };
+ assert_eq!(v["points"][0], json!([102.0, 98.0]));
+}
+
+/// #852: the Paintbrush sends each point's pen pressure; a mouse (always fully pressed) and
+/// the Pencil send plain points.
+#[test]
+fn paintbrush_sends_pen_pressure() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+ let stroke = |id: &str, pressures: [f32; 3]| {
+ let mut t = GestureTool::new(id);
+ let kinds = [PointerKind::Down, PointerKind::Drag, PointerKind::Up];
+ let mut last = vec![];
+ for ((k, x), f) in kinds.into_iter().zip([0.0, 40.0, 80.0]).zip(pressures) {
+ last = t.pointer(&cx, &PointerEvent { pressure: f, ..PointerEvent::new(k, x, 0.0) });
+ }
+ let Some(Action::Preview(_, v)) = last.first() else { panic!("{last:?}") };
+ v["points"].clone()
+ };
+ assert_eq!(stroke("paintbrush", [0.25, 0.5, 1.0]), json!([[0.0, 0.0, 0.25], [40.0, 0.0, 0.5], [80.0, 0.0, 1.0]]));
+ assert_eq!(stroke("paintbrush", [1.0; 3]), json!([[0.0, 0.0], [40.0, 0.0], [80.0, 0.0]]));
+ assert_eq!(stroke("pencil", [0.25, 0.5, 1.0]), json!([[0.0, 0.0], [40.0, 0.0], [80.0, 0.0]]));
+}
+
+#[test]
+fn pencil_previews_and_commits() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+ let mut t = GestureTool::new("pencil");
+ let acts = drag(&mut t, &cx, &[(0.0, 0.0), (10.0, 5.0), (20.0, 0.0)], Mods::default());
+ assert!(acts[0].is_empty());
+ assert_eq!(acts[1][0], Action::Begin("Pencil".into()));
+ assert!(matches!(&acts[1][1], Action::Preview(c, v) if c == "path.freehand" && v["points"].as_array().unwrap().len() == 2));
+ let last = acts.last().unwrap();
+ assert!(matches!(&last[0], Action::Preview(_, v) if v["closed"] == false && v["style"] == "pencil"));
+ assert_eq!(last[1], Action::Commit);
+ assert!(!t.busy());
+}
+
+/// Live curve fitting is the Pencil's, on by default. Off, the previews while a stroke is drawn
+/// ask for the points unfitted (`fit: false`), and the release's preview is fitted as before.
+#[test]
+fn pencil_with_live_curve_fitting_off_previews_the_stroke_unfitted() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+ let stroke = [(0.0, 0.0), (10.0, 5.0), (20.0, 0.0), (30.0, 6.0), (40.0, 0.0)];
+ // The `fit` each preview sends: those while drawn, then the release's.
+ let fits = |t: &mut GestureTool| {
+ let acts = drag(t, &cx, &stroke, Mods::default());
+ let fit = |a: &Action| if let Action::Preview(_, v) = a { Some(v.get("fit").cloned()) } else { None };
+ let (drawn, release) = acts.split_at(acts.len() - 1);
+ (drawn.iter().flatten().filter_map(fit).collect::<Vec<_>>(), release[0].iter().filter_map(fit).collect::<Vec<_>>())
+ };
+ let mut t = GestureTool::new("pencil");
+ assert_eq!(t.options()["liveFit"], json!(true));
+ let (drawn, release) = fits(&mut t);
+ assert!(!drawn.is_empty() && drawn.iter().all(Option::is_none), "{drawn:?}");
+ assert_eq!(release, [None]);
+ t.set_option("liveFit", &json!(false));
+ assert_eq!(t.options()["liveFit"], json!(false));
+ let (drawn, release) = fits(&mut t);
+ assert!(!drawn.is_empty() && drawn.iter().all(|f| *f == Some(json!(false))), "{drawn:?}");
+ assert_eq!(release, [None], "the release fits the stroke");
+ // Choosing another tool while the stroke is drawn keeps it fitted, too.
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
+ for &(x, y) in &stroke[1..] {
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, x, y));
+ }
+ let acts = t.deactivate(&cx);
+ assert!(matches!(acts.as_slice(), [Action::Preview(_, v), Action::Commit] if v.get("fit").is_none()), "{acts:?}");
+ // The Paintbrush has no such option, and its previews are fitted.
+ let mut t = GestureTool::new("paintbrush");
+ t.set_option("liveFit", &json!(false));
+ assert!(t.options().get("liveFit").is_none());
+ let (drawn, _) = fits(&mut t);
+ assert!(!drawn.is_empty() && drawn.iter().all(Option::is_none), "{drawn:?}");
+}
+
+/// Keep selected is on by default, and every Pencil and Paintbrush preview sends it.
+#[test]
+fn pencil_and_paintbrush_send_keep_selected() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+ for id in ["pencil", "paintbrush"] {
+ let mut t = GestureTool::new(id);
+ assert_eq!(t.options()["keepSelected"], json!(true), "{id}");
+ for keep in [true, false] {
+ t.set_option("keepSelected", &json!(keep));
+ assert_eq!(t.options()["keepSelected"], json!(keep), "{id}");
+ let acts = drag(&mut t, &cx, &[(0.0, 0.0), (10.0, 5.0), (20.0, 0.0)], Mods::default());
+ assert!(acts[1..].iter().all(|a| a.iter().all(|a| !matches!(a, Action::Preview(_, v) if v["keepSelected"] != keep))), "{id}");
+ assert!(matches!(&acts.last().unwrap()[0], Action::Preview(_, v) if v["keepSelected"] == keep), "{id}");
+ }
+ }
+}
+
+/// With the Pencil's Live preview off, a stroke previews nothing while it is drawn: a thin line
+/// follows the pen (an overlay), and the release draws the path with its fill and stroke. On (the
+/// default), every step previews the path and no line is shown. The Paintbrush has no such option.
+#[test]
+fn pencil_with_live_preview_off_shows_a_thin_line_until_the_release() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+ let previews = |acts: &[Action]| acts.iter().filter(|a| matches!(a, Action::Preview(..))).count();
+ let line = |t: &GestureTool| t.overlays(&cx).iter().any(|o| matches!(o, Overlay::Path { width, .. } if *width == 1.0));
+ let pts = [(0.0, 0.0), (10.0, 5.0), (20.0, 0.0), (30.0, 5.0)];
+ for live in [true, false] {
+ let mut t = GestureTool::new("pencil");
+ assert_eq!(t.options()["livePreview"], json!(true), "on by default");
+ t.set_option("livePreview", &json!(live));
+ assert_eq!(t.options()["livePreview"], json!(live));
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, pts[0].0, pts[0].1));
+ let mut during = vec![];
+ for &(x, y) in &pts[1..] {
+ during.extend(t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, x, y)));
+ }
+ assert!(matches!(during.first(), Some(Action::Begin(_))), "live {live}: {during:?}");
+ assert_eq!(previews(&during), if live { 3 } else { 0 }, "live {live}: {during:?}");
+ assert_eq!(line(&t), !live, "live {live}: the thin line shows only with Live preview off");
+ let up = t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 30.0, 5.0));
+ assert!(matches!(up.as_slice(), [Action::Preview(c, _), Action::Commit] if c == "path.freehand"), "live {live}: {up:?}");
+ assert!(!line(&t), "live {live}: no line after the release");
+ }
+ // Escape mid-stroke with Live preview off cancels the stroke it began.
+ let mut t = GestureTool::new("pencil");
+ t.set_option("livePreview", &json!(false));
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 10.0, 5.0));
+ assert_eq!(t.key(&cx, ToolKey::Escape, Mods::default()), vec![Action::Cancel]);
+ // The Paintbrush keeps previewing: Live preview isn't one of its options.
+ let mut b = GestureTool::new("paintbrush");
+ assert!(b.options().get("livePreview").is_none());
+ b.set_option("livePreview", &json!(false));
+ b.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
+ let acts = b.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 10.0, 5.0));
+ assert_eq!(previews(&acts), 1, "{acts:?}");
+}
+
+/// Holding Alt shows the Paintbrush's closing cursor before the press, and the Pencil's and the
+/// Paintbrush's while drawing (before a press, Alt gives the Pencil its straight-line cursor); a release
+/// with Alt still held closes the path, and Alt let go before the release leaves it open.
+/// The freehand tools take every position the pointer passed (`wants_samples`); the Join tool
+/// doesn't need them.
+#[test]
+fn the_freehand_tools_want_every_sample() {
+ for id in ["pencil", "paintbrush", "blobBrush", "eraser", "knife", "smooth", "pathEraser"] {
+ assert!(GestureTool::new(id).wants_samples(), "{id}");
+ }
+ assert!(!GestureTool::new("join").wants_samples());
+}
+
+#[test]
+fn alt_shows_the_closing_cursor_and_a_release_with_alt_closes() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+ let alt = Mods { alt: true, ..Default::default() };
+ let at = Point::new(10.0, 5.0);
+ for (id, own, closing, style) in
+ [("pencil", Cursor::Pencil, Cursor::PencilClose, "pencil"), ("paintbrush", Cursor::Paintbrush, Cursor::PaintbrushClose, "brush")]
+ {
+ let mut t = GestureTool::new(id);
+ assert_eq!(t.cursor(&cx, at, Mods::default()), if id == "pencil" { Cursor::PencilNew } else { own }, "{id}");
+ assert_eq!(t.cursor(&cx, at, alt), if id == "pencil" { Cursor::PencilStraight } else { closing }, "{id}");
+ for alt_at_release in [true, false] {
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 10.0, 5.0).with_mods(alt));
+ assert_eq!(t.cursor(&cx, at, alt), closing, "{id} while drawing");
+ assert_eq!(t.cursor(&cx, at, Mods::default()), own, "{id} while drawing");
+ let up = Mods { alt: alt_at_release, ..Default::default() };
+ let acts = t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 20.0, 0.0).with_mods(up));
+ assert!(
+ matches!(&acts[0], Action::Preview(_, v) if v["closed"] == alt_at_release && v["style"] == style),
+ "{id}, Alt at the release {alt_at_release}: {acts:?}"
+ );
+ }
+ }
+ // With Alt key toggles to Smooth Tool on, Alt lends the Pencil the Smooth tool instead, until
+ // a stroke has begun to draw: Alt then neither smooths nor closes, and the cursor stays the Pencil's.
+ let mut t = GestureTool::new("pencil");
+ t.set_option("altSmooth", &json!(true));
+ assert_eq!(t.cursor(&cx, at, alt), Cursor::Smooth);
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 10.0, 5.0));
+ assert_eq!(t.cursor(&cx, at, alt), Cursor::Pencil, "a stroke that has begun");
+ let acts = t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 20.0, 0.0).with_mods(alt));
+ assert!(matches!(&acts[0], Action::Preview(_, v) if v["closed"] == false), "{acts:?}");
+ // A smoothing drag keeps the Smooth cursor when Alt is let go.
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0).with_mods(alt));
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 10.0, 5.0).with_mods(alt));
+ assert_eq!(t.cursor(&cx, at, Mods::default()), Cursor::Smooth, "a smoothing drag");
+}
+
+#[test]
+fn blob_brush_drag_shows_scrub_length_measurement_labels() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let on = ToolContext { measurement_labels: true, ..cx(&d, &s, &p) };
+ let off = ToolContext { measurement_labels: false, ..cx(&d, &s, &p) };
+ let mut t = GestureTool::new("blobBrush");
+ t.pointer(&on, &PointerEvent::new(PointerKind::Down, 50.0, 150.0));
+ t.pointer(&on, &PointerEvent::new(PointerKind::Drag, 150.0, 150.0));
+ let want = format!("L: {}", on.len(100.0));
+ assert!(t.overlays(&on).iter().any(|o| matches!(o, Overlay::Measure { text, .. } if text == &want)));
+ let mut quiet = GestureTool::new("blobBrush");
+ quiet.pointer(&off, &PointerEvent::new(PointerKind::Down, 50.0, 150.0));
+ quiet.pointer(&off, &PointerEvent::new(PointerKind::Drag, 150.0, 150.0));
+ assert!(!quiet.overlays(&off).iter().any(|o| matches!(o, Overlay::Measure { .. })));
+}
+
+/// The Blob Brush has Keep selected and Merge only with selection, both off by default, and its
+/// stroke sends both.
+#[test]
+fn blob_brush_sends_keep_selected_and_merge_only_with_selection() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+ let mut t = GestureTool::new("blobBrush");
+ assert_eq!((t.options()["keepSelected"].clone(), t.options()["mergeOnlySelection"].clone()), (json!(false), json!(false)));
+ for (keep, only) in [(false, false), (true, false), (false, true)] {
+ t.set_option("keepSelected", &json!(keep));
+ t.set_option("mergeOnlySelection", &json!(only));
+ let acts = drag(&mut t, &cx, &[(50.0, 150.0), (250.0, 150.0)], Mods::default());
+ assert!(
+ matches!(&acts[2][0], Action::Exec(c, v) if c == "path.blob" && v["keepSelected"] == keep && v["mergeOnlySelection"] == only),
+ "{acts:?}"
+ );
+ }
+ // The Eraser keeps Size, Angle and Roundness: a round tip by default.
+ assert_eq!(GestureTool::new("eraser").options(), json!({"size": 10.0, "angle": 0.0, "roundness": 100.0}));
+}
+
+/// Shift keeps a Blob Brush stroke on the horizontal or vertical line through the press point,
+/// whichever is nearer to the pointer, at 90° steps from the Constrain Angle; the points
+/// dragged with Shift held move to the other line together, and each point follows the Shift
+/// state of its own event.
+#[test]
+fn blob_brush_shift_keeps_the_stroke_horizontal_or_vertical() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let mut cx = cx(&d, &s, &p);
+ let shift = Mods { shift: true, ..Default::default() };
+ let blob = |acts: &[Vec<Action>]| -> Vec<(f64, f64)> {
+ let Some(Action::Exec(c, v)) = acts.last().and_then(|a| a.first()) else { panic!("{acts:?}") };
+ assert_eq!(c, "path.blob");
+ v["points"].as_array().unwrap().iter().map(|q| (q[0].as_f64().unwrap(), q[1].as_f64().unwrap())).collect()
+ };
+ let mut t = GestureTool::new("blobBrush");
+ let pts = blob(&drag_held(&mut t, &cx, &[(0.0, 0.0), (30.0, 5.0), (50.0, 8.0)], shift));
+ assert_eq!(pts.len(), 3);
+ assert!(pts.iter().all(|q| q.1 == 0.0 && q.0 >= 0.0), "{pts:?}");
+ let pts = blob(&drag_held(&mut t, &cx, &[(0.0, 0.0), (5.0, 30.0), (8.0, 50.0)], shift));
+ assert!(pts.iter().all(|q| q.0.abs() < 1e-9 && q.1 >= 0.0), "{pts:?}");
+ // A pointer that crosses to the vertical line takes the points before it along, each on
+ // its own side of the press point and at its own distance.
+ let pts = blob(&drag_held(&mut t, &cx, &[(0.0, 0.0), (-40.0, -2.0), (100.0, 99.0), (90.0, 120.0)], shift));
+ assert_eq!(pts.len(), 4, "{pts:?}");
+ assert!(pts.iter().all(|q| q.0.abs() < 1e-9), "{pts:?}");
+ assert!((pts[1].1 + 1604f64.sqrt()).abs() < 1e-9 && (pts[2].1 - 19801f64.sqrt()).abs() < 1e-9 && (pts[3].1 - 150.0).abs() < 1e-9, "{pts:?}");
+ // Without Shift the stroke follows the pointer.
+ let pts = blob(&drag_held(&mut t, &cx, &[(0.0, 0.0), (30.0, 5.0), (50.0, 8.0)], Mods::default()));
+ assert_eq!(pts, vec![(0.0, 0.0), (30.0, 5.0), (50.0, 8.0)]);
+ // Shift pressed and let go mid-stroke constrains only the points dragged while it is down,
+ // and a later press of Shift leaves the points of the earlier one where they are.
+ let ev = |k, x, y, m| PointerEvent::new(k, x, y).with_mods(m);
+ t.pointer(&cx, &ev(PointerKind::Down, 0.0, 0.0, Mods::default()));
+ t.pointer(&cx, &ev(PointerKind::Drag, 20.0, 10.0, Mods::default()));
+ t.pointer(&cx, &ev(PointerKind::Drag, 40.0, 10.0, shift));
+ t.pointer(&cx, &ev(PointerKind::Drag, 60.0, 10.0, Mods::default()));
+ let pts = blob(&[t.pointer(&cx, &ev(PointerKind::Up, 10.0, 80.0, shift))]);
+ assert_eq!((pts.len(), pts[1], pts[3]), (5, (20.0, 10.0), (60.0, 10.0)), "{pts:?}");
+ assert!(pts[2].1 == 0.0 && (pts[2].0 - 1700f64.sqrt()).abs() < 1e-9, "{pts:?}");
+ assert!(pts[4].0.abs() < 1e-9 && (pts[4].1 - 6500f64.sqrt()).abs() < 1e-9, "{pts:?}");
+ // The axes turn with the Constrain Angle.
+ cx.constrain_angle = 30.0;
+ let pts = blob(&drag_held(&mut t, &cx, &[(0.0, 0.0), (40.0, -20.0)], shift));
+ let a = (-pts[1].1).atan2(pts[1].0).to_degrees();
+ assert!((a - 30.0).abs() < 1e-9, "{pts:?}");
+ // A pointer back at the press point leaves the stroke on its line.
+ let pts = blob(&drag_held(&mut t, &cx, &[(0.0, 0.0), (40.0, -20.0), (0.0, 0.0)], shift));
+ let a = (-pts[1].1).atan2(pts[1].0).to_degrees();
+ assert!(pts.len() == 3 && pts[2] == (0.0, 0.0) && (a - 30.0).abs() < 1e-9, "{pts:?}");
+}
+
+/// #3799: Shift held at the press draws a straight Pencil line from the press point, at 45°
+/// steps from the Constrain Angle, previewed as it is dragged; the Paintbrush keeps following
+/// the hand.
+#[test]
+fn pencil_shift_draws_a_straight_line_at_45_degree_steps() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let mut cx = cx(&d, &s, &p);
+ cx.smart_guides = false;
+ let shift = Mods { shift: true, ..Default::default() };
+ let pts = |acts: &[Vec<Action>]| -> Vec<Vec<(f64, f64)>> {
+ acts.iter()
+ .filter_map(|a| a.iter().find_map(|a| if let Action::Preview(_, v) = a { Some(v["points"].clone()) } else { None }))
+ .map(|v| v.as_array().unwrap().iter().map(|q| (q[0].as_f64().unwrap(), q[1].as_f64().unwrap())).collect())
+ .collect()
+ };
+ let angle = |q: (f64, f64), from: (f64, f64)| (-(q.1 - from.1)).atan2(q.0 - from.0).to_degrees();
+ let mut t = GestureTool::new("pencil");
+ // A wavy drag heading up and right at about 40°: a line at 45°, as long as the drag.
+ let acts = drag_held(&mut t, &cx, &[(0.0, 0.0), (30.0, -10.0), (50.0, -60.0), (100.0, -84.0)], shift);
+ let all = pts(&acts);
+ assert!(all.iter().all(|v| v.len() == 2 && v[0] == (0.0, 0.0)), "{all:?}");
+ let end = *all.last().unwrap().last().unwrap();
+ assert!((angle(end, (0.0, 0.0)) - 45.0).abs() < 1e-9, "{end:?}");
+ assert!((end.0.hypot(end.1) - 100f64.hypot(84.0)).abs() < 1e-9, "{end:?}");
+ let last = acts.last().unwrap();
+ assert!(matches!(&last[0], Action::Preview(_, v) if v["closed"] == false) && last[1] == Action::Commit, "{last:?}");
+ // The steps turn with the Constrain Angle: at 30°, a drag at 40° gives 30°, one at 60° gives 75°.
+ cx.constrain_angle = 30.0;
+ for (to, want) in [((100.0, -84.0), 30.0), ((50.0, -86.6), 75.0)] {
+ let all = pts(&drag_held(&mut t, &cx, &[(10.0, 10.0), (to.0 + 10.0, to.1 + 10.0)], shift));
+ let end = *all.last().unwrap().last().unwrap();
+ assert!((angle(end, (10.0, 10.0)) - want).abs() < 1e-9, "{to:?}: {all:?}");
+ }
+ // Without Shift, and with the Paintbrush, the stroke follows the hand.
+ for (id, m) in [("pencil", Mods::default()), ("paintbrush", shift)] {
+ let mut t = GestureTool::new(id);
+ let all = pts(&drag_held(&mut t, &cx, &[(0.0, 0.0), (30.0, -10.0), (50.0, -60.0)], m));
+ assert_eq!(all.last().unwrap().len(), 3, "{id}: {all:?}");
+ }
+}
+
+/// #3799: a Shift line leaves no Smart Guides of its press on screen while it is dragged
+/// (its end doesn't snap), and Alt at its release leaves it open.
+#[test]
+fn pencil_shift_line_drops_the_press_guides_and_stays_open_with_alt() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+ let shift = Mods { shift: true, ..Default::default() };
+ let mut t = GestureTool::new("pencil");
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 102.0, 98.0).with_mods(shift));
+ assert!(!t.overlays(&cx).is_empty(), "the press snaps to the corner and shows it");
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 300.0, 140.0).with_mods(shift));
+ assert!(t.overlays(&cx).is_empty(), "{:?}", t.overlays(&cx));
+ let shift_alt = Mods { shift: true, alt: true, ..Default::default() };
+ let acts = t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 300.0, 140.0).with_mods(shift_alt));
+ assert!(matches!(&acts[0], Action::Preview(_, v) if v["closed"] == false && v["points"].as_array().unwrap().len() == 2), "{acts:?}");
+}
+
+/// Before a press, the Pencil shows its straight-line cursor exactly when the press would draw a
+/// straight line; once the press is down, and with the Paintbrush, Shift leaves the tool's own
+/// cursor.
+#[test]
+fn pencil_shows_the_straight_line_cursor_when_a_press_draws_a_line() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let mut cx = cx(&d, &s, &p);
+ cx.smart_guides = false;
+ let at = Point::new(0.0, 0.0);
+ let shift = Mods { shift: true, ..Default::default() };
+ let alt = Mods { alt: true, ..Default::default() };
+ let shift_alt = Mods { shift: true, alt: true, ..Default::default() };
+ // The last drag's preview: two points for a line, all three for a freehand stroke, none
+ // for a smoothing drag.
+ let straight = |acts: &[Vec<Action>]| {
+ acts[acts.len() - 2].iter().any(|a| matches!(a, Action::Preview(_, v) if v["points"].as_array().is_some_and(|q| q.len() == 2)))
+ };
+ for alt_smooth in [false, true] {
+ for m in [Mods::default(), shift, alt, shift_alt] {
+ let mut t = GestureTool::new("pencil");
+ t.set_option("altSmooth", &json!(alt_smooth));
+ let shown = t.cursor(&cx, at, m) == Cursor::PencilStraight;
+ let drawn = straight(&drag_held(&mut t, &cx, &[(0.0, 0.0), (30.0, -10.0), (50.0, -60.0)], m));
+ assert_eq!(shown, drawn, "altSmooth {alt_smooth}, {m:?}");
+ }
+ }
+ let mut t = GestureTool::new("pencil");
+ assert_eq!(t.cursor(&cx, at, Mods::default()), Cursor::PencilNew);
+ assert_eq!(t.cursor(&cx, at, shift), Cursor::PencilStraight);
+ assert_eq!(t.cursor(&cx, at, alt), Cursor::PencilStraight, "Alt alone draws a line at any angle");
+ assert_eq!(t.cursor(&cx, at, shift_alt), Cursor::PencilStraight, "Alt at the release leaves a straight line open");
+ // While the line is drawn, the Pencil's own cursor; after the release, Shift shows it again.
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0).with_mods(shift));
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 40.0, -10.0).with_mods(shift));
+ assert_eq!(t.cursor(&cx, at, shift), Cursor::Pencil, "while the line is drawn");
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 40.0, -10.0).with_mods(shift));
+ assert_eq!(t.cursor(&cx, at, shift), Cursor::PencilStraight, "after the release");
+ // Shift pressed during a freehand stroke doesn't make it a line.
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0));
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 40.0, -10.0).with_mods(shift));
+ assert_eq!(t.cursor(&cx, at, shift), Cursor::Pencil, "a freehand stroke");
+ assert_eq!(GestureTool::new("paintbrush").cursor(&cx, at, shift), Cursor::Paintbrush);
+ assert_eq!(Cursor::PencilStraight.precise(), Cursor::Crosshair, "Use Precise Cursors");
+}
+
+/// Before a press, the Pencil shows its new-path cursor (the star) exactly when the press draws
+/// a new path: over an end of a selected open path, which the stroke continues, and over a
+/// selected path, which it redraws, it does not. With nothing selected, with Edit Selected Paths
+/// off and away from the paths, it does; while a stroke is drawn, it does not.
+#[test]
+fn pencil_shows_the_star_before_a_press_that_draws_a_new_path() {
+ let (mut d, _) = doc_with_rect();
+ let l = d.layers[0].id;
+ let id = d.alloc_id();
+ let line = vectorcraft_geom::PathData::from_bezpath(&vectorcraft_geom::BezPath::from_vec(vec![
+ vectorcraft_geom::PathEl::MoveTo(Point::new(300.0, 300.0)),
+ vectorcraft_geom::PathEl::LineTo(Point::new(400.0, 300.0)),
+ ]));
+ d.insert(Some(l), 1, vectorcraft_doc::Node::path(id, line, vectorcraft_doc::Appearance::default_art())).unwrap();
+ let mut s = Selection::default();
+ s.set([id]);
+ let p = paint();
+ let mut cx = cx(&d, &s, &p);
+ cx.smart_guides = false;
+ // The stroke edits the selected path when its previews continue or redraw it.
+ let edits = |acts: &[Vec<Action>]| {
+ acts.iter().flatten().any(|a| matches!(a, Action::Preview(_, v) if v.get("extend").is_some() || v.get("redraw").is_some()))
+ };
+ let (end, middle, away) = (Point::new(405.0, 303.0), Point::new(350.0, 304.0), Point::new(350.0, 360.0));
+ for edit_within in [12.0, 0.0] {
+ for at in [end, Point::new(296.0, 302.0), middle, away, Point::new(200.0, 200.0)] {
+ let mut t = GestureTool::new("pencil");
+ t.set_option("editWithin", &json!(edit_within));
+ let shown = t.cursor(&cx, at, Mods::default()) == Cursor::PencilNew;
+ let acts = drag(&mut t, &cx, &[(at.x, at.y), (360.0, 330.0), (420.0, 350.0)], Mods::default());
+ assert_eq!(shown, !edits(&acts), "editWithin {edit_within} at {at:?}");
+ }
+ }
+ let mut t = GestureTool::new("pencil");
+ assert_eq!(t.cursor(&cx, end, Mods::default()), Cursor::Pencil, "over an end the stroke continues");
+ assert_eq!(t.cursor(&cx, middle, Mods::default()), Cursor::Pencil, "over the path the stroke redraws");
+ assert_eq!(t.cursor(&cx, away, Mods::default()), Cursor::PencilNew, "away from the path");
+ // While a stroke is drawn, the Pencil's own cursor.
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, away.x, away.y));
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 380.0, 380.0));
+ assert_eq!(t.cursor(&cx, Point::new(380.0, 380.0), Mods::default()), Cursor::Pencil, "while a stroke is drawn");
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 380.0, 380.0));
+ assert_eq!(t.cursor(&cx, away, Mods::default()), Cursor::PencilNew, "after the release");
+ // With nothing selected, every press draws a new path.
+ let none = Selection::default();
+ let cx_none = crate::testutil::cx(&d, &none, &p);
+ assert_eq!(GestureTool::new("pencil").cursor(&cx_none, middle, Mods::default()), Cursor::PencilNew, "nothing selected");
+ // Shift held: a straight line, with its own cursor; the Paintbrush keeps its cursor.
+ let shift = Mods { shift: true, ..Default::default() };
+ assert_eq!(GestureTool::new("pencil").cursor(&cx, away, shift), Cursor::PencilStraight);
+ assert_eq!(GestureTool::new("paintbrush").cursor(&cx, away, Mods::default()), Cursor::Paintbrush);
+}
+
+/// #3799: a Shift line started on an end of a selected open path continues the path from that
+/// end, constrained from the end itself.
+#[test]
+fn pencil_shift_line_continues_a_selected_path_from_its_end() {
+ let (mut d, _) = doc_with_rect();
+ let l = d.layers[0].id;
+ let id = d.alloc_id();
+ let line = vectorcraft_geom::PathData::from_bezpath(&vectorcraft_geom::BezPath::from_vec(vec![
+ vectorcraft_geom::PathEl::MoveTo(Point::new(300.0, 300.0)),
+ vectorcraft_geom::PathEl::LineTo(Point::new(400.0, 300.0)),
+ ]));
+ d.insert(Some(l), 1, vectorcraft_doc::Node::path(id, line, vectorcraft_doc::Appearance::default_art())).unwrap();
+ let mut s = Selection::default();
+ s.set([id]);
+ let p = paint();
+ let mut cx = cx(&d, &s, &p);
+ cx.smart_guides = false;
+ let mut t = GestureTool::new("pencil");
+ // Pressed 5 pt off the end, released 100 pt right and 4 pt above it.
+ let acts = drag_held(&mut t, &cx, &[(405.0, 303.0), (450.0, 290.0), (500.0, 296.0)], Mods { shift: true, ..Default::default() });
+ let Some(Action::Preview(_, v)) = acts.last().and_then(|a| a.first()) else { panic!("{acts:?}") };
+ assert_eq!(v["extend"], json!({"id": id.0, "end": "end"}));
+ assert_eq!(v["points"], json!([[400.0, 300.0], [400.0 + 100f64.hypot(4.0), 300.0]]));
+}
+
+/// Before a press over an end of a selected open path, the Pencil shows its continuation cursor
+/// exactly when the press would draw a straight line that continues the path; away from the
+/// ends, with nothing selected, with Edit Selected Paths off, once the press is down and with
+/// the Paintbrush, it does not.
+#[test]
+fn pencil_shows_the_continuation_cursor_over_an_end_a_line_continues() {
+ let (mut d, _) = doc_with_rect();
+ let l = d.layers[0].id;
+ let id = d.alloc_id();
+ let line = vectorcraft_geom::PathData::from_bezpath(&vectorcraft_geom::BezPath::from_vec(vec![
+ vectorcraft_geom::PathEl::MoveTo(Point::new(300.0, 300.0)),
+ vectorcraft_geom::PathEl::LineTo(Point::new(400.0, 300.0)),
+ ]));
+ d.insert(Some(l), 1, vectorcraft_doc::Node::path(id, line, vectorcraft_doc::Appearance::default_art())).unwrap();
+ let mut s = Selection::default();
+ s.set([id]);
+ let p = paint();
+ let mut cx = cx(&d, &s, &p);
+ cx.smart_guides = false;
+ let shift = Mods { shift: true, ..Default::default() };
+ let alt = Mods { alt: true, ..Default::default() };
+ let shift_alt = Mods { shift: true, alt: true, ..Default::default() };
+ // The release's stroke: a straight line that continues the path.
+ let continues = |acts: &[Vec<Action>]| {
+ acts.last().and_then(|a| a.first()).is_some_and(
+ |a| matches!(a, Action::Preview(_, v) if v.get("extend").is_some() && v["points"].as_array().is_some_and(|q| q.len() == 2)),
+ )
+ };
+ for alt_smooth in [false, true] {
+ for m in [Mods::default(), shift, alt, shift_alt] {
+ for (at, other_end) in [(Point::new(405.0, 303.0), (500.0, 296.0)), (Point::new(296.0, 302.0), (200.0, 310.0))] {
+ let mut t = GestureTool::new("pencil");
+ t.set_option("altSmooth", &json!(alt_smooth));
+ let shown = t.cursor(&cx, at, m) == Cursor::PencilContinue;
+ let acts = drag_held(&mut t, &cx, &[(at.x, at.y), (450.0, 250.0), other_end], m);
+ assert_eq!(shown, continues(&acts), "altSmooth {alt_smooth}, {m:?} at {at:?}");
+ }
+ }
+ }
+ let mut t = GestureTool::new("pencil");
+ let end = Point::new(405.0, 303.0);
+ assert_eq!(t.cursor(&cx, end, shift), Cursor::PencilContinue);
+ assert_eq!(t.cursor(&cx, end, alt), Cursor::PencilContinue, "Alt alone continues at any angle");
+ assert_eq!(t.cursor(&cx, end, Mods::default()), Cursor::Pencil, "without Shift or Alt the stroke is freehand");
+ assert_eq!(t.cursor(&cx, Point::new(350.0, 360.0), shift), Cursor::PencilStraight, "away from the ends");
+ // While the line is drawn, the Pencil's own cursor.
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, end.x, end.y).with_mods(shift));
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 450.0, 303.0).with_mods(shift));
+ assert_eq!(t.cursor(&cx, end, shift), Cursor::Pencil, "while the line is drawn");
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 450.0, 303.0).with_mods(shift));
+ // Edit Selected Paths off: the press draws a new line.
+ t.set_option("editWithin", &json!(0.0));
+ assert_eq!(t.cursor(&cx, end, shift), Cursor::PencilStraight, "Edit Selected Paths off");
+ let none = Selection::default();
+ let cx_none = crate::testutil::cx(&d, &none, &p);
+ assert_eq!(GestureTool::new("pencil").cursor(&cx_none, end, shift), Cursor::PencilStraight, "nothing selected");
+ assert_eq!(GestureTool::new("paintbrush").cursor(&cx, end, shift), Cursor::Paintbrush);
+ assert_eq!(Cursor::PencilContinue.precise(), Cursor::Crosshair, "Use Precise Cursors");
+}
+
+/// #3846: Alt during a Shift line doesn't promise a close the release can't do, and with Alt
+/// Toggles to Smooth, Alt pressed after the press doesn't turn the line into a smoothing drag.
+#[test]
+fn pencil_shift_line_ignores_alt_for_cursor_and_smoothing() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let mut cx = cx(&d, &s, &p);
+ cx.smart_guides = false;
+ let shift = Mods { shift: true, ..Default::default() };
+ let shift_alt = Mods { shift: true, alt: true, ..Default::default() };
+ let mut t = GestureTool::new("pencil");
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0).with_mods(shift));
+ assert_eq!(t.cursor(&cx, Point::new(0.0, 0.0), shift_alt), Cursor::Pencil);
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 0.0, 0.0).with_mods(shift));
+
+ let mut t = GestureTool::new("pencil");
+ t.alt_smooth = true;
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0).with_mods(shift));
+ let acts = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 80.0, 0.0).with_mods(shift_alt));
+ assert!(matches!(acts.as_slice(), [Action::Begin(_), Action::Preview(..)]), "{acts:?}");
+ let acts = t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 80.0, 0.0).with_mods(shift_alt));
+ assert!(matches!(&acts[0], Action::Preview(_, v) if v["points"].as_array().unwrap().len() == 2), "{acts:?}");
+}
+
+/// #3846: a Shift line dragged back to its press point has no line: the preview is cancelled
+/// and the release commits nothing (not the previous end of the line).
+#[test]
+fn pencil_shift_line_back_at_the_press_point_draws_nothing() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let mut cx = cx(&d, &s, &p);
+ cx.smart_guides = false;
+ let shift = Mods { shift: true, ..Default::default() };
+ // Released back at the press point, and dragged back there first.
+ for back_in_drag in [false, true] {
+ let mut t = GestureTool::new("pencil");
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0).with_mods(shift));
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 80.0, 0.0).with_mods(shift));
+ let mut acts = vec![];
+ if back_in_drag {
+ // The shown line goes as soon as the pointer is back, not only at the release.
+ let back = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 0.2, 0.0).with_mods(shift));
+ assert_eq!(back, vec![Action::Cancel]);
+ acts.extend(back);
+ }
+ acts.extend(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 0.2, 0.0).with_mods(shift)));
+ assert!(acts.contains(&Action::Cancel), "{back_in_drag}: {acts:?}");
+ assert!(!acts.contains(&Action::Commit) && !acts.iter().any(|a| matches!(a, Action::Preview(..))), "{back_in_drag}: {acts:?}");
+ }
+}
+
+/// #3799: Alt held at the press draws a straight Pencil line at any angle from the press point
+/// to the pointer, previewed as it is dragged, and left open by a release with Alt still held;
+/// with Shift too it keeps Shift's 45° steps. Alt pressed after the press keeps the stroke
+/// freehand and closes it at the release, and the Paintbrush keeps following the hand.
+#[test]
+fn pencil_alt_at_the_press_draws_a_straight_line_at_any_angle() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let mut cx = cx(&d, &s, &p);
+ cx.smart_guides = false;
+ let alt = Mods { alt: true, ..Default::default() };
+ let pts = |acts: &[Vec<Action>]| -> Vec<Vec<(f64, f64)>> {
+ acts.iter()
+ .filter_map(|a| a.iter().find_map(|a| if let Action::Preview(_, v) = a { Some(v["points"].clone()) } else { None }))
+ .map(|v| v.as_array().unwrap().iter().map(|q| (q[0].as_f64().unwrap(), q[1].as_f64().unwrap())).collect())
+ .collect()
+ };
+ let wavy = [(0.0, 0.0), (30.0, -10.0), (50.0, -60.0), (100.0, -84.0)];
+ let mut t = GestureTool::new("pencil");
+ assert_eq!(t.cursor(&cx, Point::new(0.0, 0.0), alt), Cursor::PencilStraight, "before the press");
+ let acts = drag_held(&mut t, &cx, &wavy, alt);
+ let all = pts(&acts);
+ assert_eq!(all.len(), 4, "{all:?}");
+ assert!(all.iter().all(|v| v.len() == 2 && v[0] == (0.0, 0.0)), "{all:?}");
+ assert_eq!(all[1][1], (50.0, -60.0), "the preview follows the pointer at its own angle");
+ assert_eq!(all[3][1], (100.0, -84.0), "{all:?}");
+ let last = acts.last().unwrap();
+ assert!(matches!(&last[0], Action::Preview(_, v) if v["closed"] == false) && last[1] == Action::Commit, "{last:?}");
+ // While the line is drawn, Alt shows no closing ring.
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 0.0, 0.0).with_mods(alt));
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 40.0, 10.0).with_mods(alt));
+ assert_eq!(t.cursor(&cx, Point::new(40.0, 10.0), alt), Cursor::Pencil);
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 40.0, 10.0).with_mods(alt));
+ // Shift with Alt: 45° steps.
+ let all = pts(&drag_held(&mut t, &cx, &wavy, Mods { shift: true, alt: true, ..Default::default() }));
+ let end = *all.last().unwrap().last().unwrap();
+ assert!(((-end.1).atan2(end.0).to_degrees() - 45.0).abs() < 1e-9, "{end:?}");
+ // Alt pressed after the press: freehand, closed at the release.
+ let acts = drag(&mut t, &cx, &wavy, alt);
+ assert_eq!(pts(&acts).last().unwrap().len(), 4, "{acts:?}");
+ assert!(matches!(&acts.last().unwrap()[0], Action::Preview(_, v) if v["closed"] == true), "{acts:?}");
+ // The Paintbrush with Alt held follows the hand and closes.
+ let mut b = GestureTool::new("paintbrush");
+ let acts = drag_held(&mut b, &cx, &wavy, alt);
+ assert_eq!(pts(&acts).last().unwrap().len(), 4, "{acts:?}");
+ assert!(matches!(&acts.last().unwrap()[0], Action::Preview(_, v) if v["closed"] == true), "{acts:?}");
+}
+
+/// #3799: with Alt key toggles to Smooth Tool on, Alt held at the press smooths as before and
+/// draws no line.
+#[test]
+fn pencil_alt_with_alt_to_smooth_on_smooths_instead_of_drawing_a_line() {
+ let (d, id) = doc_with_rect();
+ let mut s = Selection::default();
+ s.set([id]);
+ let p = paint();
+ let mut cx = cx(&d, &s, &p);
+ cx.smart_guides = false;
+ let alt = Mods { alt: true, ..Default::default() };
+ let mut t = GestureTool::new("pencil");
+ t.set_option("altSmooth", &json!(true));
+ let acts = drag_held(&mut t, &cx, &[(50.0, 150.0), (150.0, 150.0), (250.0, 160.0)], alt);
+ assert!(acts[..acts.len() - 1].iter().all(|a| a.is_empty()), "{acts:?}");
+ assert!(matches!(&acts.last().unwrap()[0], Action::Exec(c, v) if c == "path.smoothRegion" && v["points"].as_array().unwrap().len() == 3));
+}
+
+/// #3799: Alt's line starts and ends on Smart Guides as a stroke does, and pressed on an end of
+/// a selected open path it continues the path from that end to the pointer.
+#[test]
+fn pencil_alt_line_snaps_its_ends_and_continues_a_selected_path() {
+ let (mut d, _) = doc_with_rect();
+ let alt = Mods { alt: true, ..Default::default() };
+ let p = paint();
+ {
+ let s = Selection::default();
+ let cx = cx(&d, &s, &p);
+ let mut t = GestureTool::new("pencil");
+ let acts = drag_held(&mut t, &cx, &[(102.0, 98.0), (151.0, 300.0), (198.0, 203.0)], alt);
+ let Some(Action::Preview(_, v)) = acts.last().and_then(|a| a.first()) else { panic!("{acts:?}") };
+ assert_eq!(v["points"], json!([[100.0, 100.0], [200.0, 200.0]]));
+ }
+ let l = d.layers[0].id;
+ let id = d.alloc_id();
+ let line = vectorcraft_geom::PathData::from_bezpath(&vectorcraft_geom::BezPath::from_vec(vec![
+ vectorcraft_geom::PathEl::MoveTo(Point::new(300.0, 300.0)),
+ vectorcraft_geom::PathEl::LineTo(Point::new(400.0, 300.0)),
+ ]));
+ d.insert(Some(l), 1, vectorcraft_doc::Node::path(id, line, vectorcraft_doc::Appearance::default_art())).unwrap();
+ let mut s = Selection::default();
+ s.set([id]);
+ let mut cx = cx(&d, &s, &p);
+ cx.smart_guides = false;
+ let mut t = GestureTool::new("pencil");
+ let acts = drag_held(&mut t, &cx, &[(405.0, 303.0), (450.0, 340.0), (470.0, 330.0)], alt);
+ let Some(Action::Preview(_, v)) = acts.last().and_then(|a| a.first()) else { panic!("{acts:?}") };
+ assert_eq!(v["extend"], json!({"id": id.0, "end": "end"}));
+ assert_eq!(v["points"], json!([[400.0, 300.0], [470.0, 330.0]]));
+}
+
+#[test]
+fn pencil_alt_closes_and_continues_selected_path() {
+ let (d, id) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+ let mut t = GestureTool::new("paintbrush");
+ let acts = drag(&mut t, &cx, &[(0.0, 0.0), (10.0, 5.0), (20.0, 0.0)], Mods { alt: true, ..Default::default() });
+ assert!(matches!(&acts.last().unwrap()[0], Action::Preview(_, v) if v["closed"] == true && v["style"] == "brush"));
+ // A selected closed rect is not continued; an open path would be (see engine tests).
+ let mut s2 = Selection::default();
+ s2.set([id]);
+ let cx2 = crate::testutil::cx(&d, &s2, &p);
+ let acts = drag(&mut t, &cx2, &[(100.0, 100.0), (90.0, 90.0)], Mods::default());
+ assert!(matches!(&acts[1][1], Action::Preview(_, v) if v.get("extend").is_none()));
+}
+
+/// Edit selected paths within 0 turns editing off: a stroke that starts exactly on an end of a
+/// selected open path draws a new path; at 12 px it continues the path from that end.
+#[test]
+fn edit_selected_paths_within_0_draws_a_new_path_from_an_end() {
+ let (mut d, _) = doc_with_rect();
+ let l = d.layers[0].id;
+ let id = d.alloc_id();
+ let line = vectorcraft_geom::PathData::from_bezpath(&vectorcraft_geom::BezPath::from_vec(vec![
+ vectorcraft_geom::PathEl::MoveTo(Point::new(300.0, 300.0)),
+ vectorcraft_geom::PathEl::LineTo(Point::new(400.0, 300.0)),
+ ]));
+ d.insert(Some(l), 1, vectorcraft_doc::Node::path(id, line, vectorcraft_doc::Appearance::default_art())).unwrap();
+ let mut s = Selection::default();
+ s.set([id]);
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+ for tool in ["pencil", "paintbrush"] {
+ let mut t = GestureTool::new(tool);
+ for (within, extends) in [(12.0, true), (0.0, false)] {
+ t.set_option("editWithin", &json!(within));
+ for (x, end) in [(400.0, "end"), (300.0, "start")] {
+ let acts = drag(&mut t, &cx, &[(x, 300.0), (x + 20.0, 350.0), (x, 380.0)], Mods::default());
+ let Some(Action::Preview(_, v)) = acts.last().and_then(|a| a.first()) else { panic!("{tool}: {acts:?}") };
+ if extends {
+ assert_eq!(v["extend"], json!({"id": id.0, "end": end}), "{tool} from the {end}");
+ } else {
+ assert!(v.get("extend").is_none() && v.get("redraw").is_none(), "{tool} from the {end}: {v}");
+ }
+ }
+ }
+ }
+}
+
+/// A Pencil stroke from an end of a selected open path to an end of another selected open path
+/// connects the two; it does not when the other path is not selected, and the Paintbrush does
+/// not connect.
+#[test]
+fn pencil_connects_a_stroke_from_one_selected_path_to_an_end_of_another() {
+ let (mut d, _) = doc_with_rect();
+ let l = d.layers[0].id;
+ let add = |d: &mut vectorcraft_doc::Document, a: (f64, f64), b: (f64, f64)| {
+ let id = d.alloc_id();
+ let line = vectorcraft_geom::PathData::from_bezpath(&vectorcraft_geom::BezPath::from_vec(vec![
+ vectorcraft_geom::PathEl::MoveTo(Point::new(a.0, a.1)),
+ vectorcraft_geom::PathEl::LineTo(Point::new(b.0, b.1)),
+ ]));
+ d.insert(Some(l), 1, vectorcraft_doc::Node::path(id, line, vectorcraft_doc::Appearance::default_art())).unwrap();
+ id
+ };
+ let a = add(&mut d, (300.0, 300.0), (400.0, 300.0));
+ let b = add(&mut d, (500.0, 400.0), (600.0, 400.0));
+ let p = paint();
+ let stroke = [(400.0, 300.0), (450.0, 350.0), (499.0, 401.0)];
+ let mut both = Selection::default();
+ both.set([a, b]);
+ let mut one = Selection::default();
+ one.set([a]);
+ // The previews select the path continued: after the press only it is selected.
+ let last = |tool: &str, at_press: &Selection| {
+ let mut t = GestureTool::new(tool);
+ t.pointer(&cx(&d, at_press, &p), &PointerEvent::new(PointerKind::Down, stroke[0].0, stroke[0].1));
+ let after = cx(&d, &one, &p);
+ t.pointer(&after, &PointerEvent::new(PointerKind::Drag, stroke[1].0, stroke[1].1));
+ t.pointer(&after, &PointerEvent::new(PointerKind::Drag, stroke[2].0, stroke[2].1));
+ let acts = t.pointer(&after, &PointerEvent::new(PointerKind::Up, stroke[2].0, stroke[2].1));
+ let Some(Action::Preview(_, v)) = acts.first() else { panic!("{acts:?}") };
+ v.clone()
+ };
+ let v = last("pencil", &both);
+ assert_eq!((v["extend"].clone(), v["connect"].clone()), (json!({"id": a.0, "end": "end"}), json!({"id": b.0, "end": "start"})));
+ assert!(last("paintbrush", &both).get("connect").is_none(), "the Paintbrush");
+ let v = last("pencil", &one);
+ assert!(v.get("extend").is_some() && v.get("connect").is_none(), "{v}");
+}
+
+/// Close paths when ends are within 0 turns closing off: a stroke that ends exactly where it
+/// started stays open; at 15 px it is closed.
+#[test]
+fn close_paths_within_0_leaves_a_stroke_that_ends_at_its_start_open() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+ for tool in ["pencil", "paintbrush"] {
+ let mut t = GestureTool::new(tool);
+ for (within, closes) in [(15.0, true), (0.0, false)] {
+ t.set_option("closeWithin", &json!(within));
+ let acts = drag(&mut t, &cx, &[(310.0, 330.0), (360.0, 350.0), (330.0, 390.0), (310.0, 330.0)], Mods::default());
+ let Some(Action::Preview(_, v)) = acts.last().and_then(|a| a.first()) else { panic!("{tool}: {acts:?}") };
+ assert_eq!(v["points"][0], v["points"][3], "{tool}");
+ assert_eq!(v["closed"], json!(closes), "{tool} at {within} px");
+ }
+ }
+}
+
+/// While a stroke is drawn back near its start, the cursor shows the closing ring when a
+/// release there closes the path (Close Paths When Ends Are Within), and the tool's own cursor
+/// away from the start, at 0 pixels and after the release.
+#[test]
+fn a_stroke_near_its_start_shows_the_closing_cursor() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+ let none = Mods::default();
+ let tools = [("pencil", Cursor::Pencil, Cursor::PencilClose), ("paintbrush", Cursor::Paintbrush, Cursor::PaintbrushClose)];
+ for (tool, own, closing) in tools {
+ for within in [15.0, 0.0] {
+ let near = if within > 0.0 { closing } else { own };
+ let mut t = GestureTool::new(tool);
+ t.set_option("closeWithin", &json!(within));
+ let mut at = |k, x, y| {
+ let acts = t.pointer(&cx, &PointerEvent::new(k, x, y));
+ (acts, t.cursor(&cx, Point::new(x, y), none))
+ };
+ assert_eq!(at(PointerKind::Down, 310.0, 330.0).1, own, "{tool} at the press");
+ assert_eq!(at(PointerKind::Drag, 360.0, 350.0).1, own, "{tool} away from the start");
+ assert_eq!(at(PointerKind::Drag, 330.0, 390.0).1, own, "{tool} away from the start");
+ assert_eq!(at(PointerKind::Drag, 318.0, 335.0).1, near, "{tool} near the start at {within} px");
+ assert_eq!(at(PointerKind::Drag, 345.0, 340.0).1, own, "{tool} away from the start again");
+ assert_eq!(at(PointerKind::Drag, 318.0, 335.0).1, near, "{tool} back near the start at {within} px");
+ let (acts, after) = at(PointerKind::Up, 318.0, 335.0);
+ let Some(Action::Preview(_, v)) = acts.first() else { panic!("{tool}: {acts:?}") };
+ assert_eq!(v["closed"], json!(within > 0.0), "{tool}: the release does what the cursor showed");
+ assert_eq!(after, if tool == "pencil" { Cursor::PencilNew } else { own }, "{tool} after the release");
+ }
+ }
+ // A straight Pencil line (Shift or Alt held at the press) stays open, so it shows no ring
+ // near its start.
+ for held in [Mods { shift: true, ..Mods::default() }, Mods { alt: true, ..Mods::default() }] {
+ let mut t = GestureTool::new("pencil");
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 310.0, 330.0).with_mods(held));
+ for (x, y) in [(360.0, 330.0), (330.0, 390.0), (318.0, 335.0)] {
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, x, y).with_mods(held));
+ }
+ for m in [held, none] {
+ assert_eq!(t.cursor(&cx, Point::new(318.0, 335.0), m), Cursor::Pencil, "a straight line, {held:?}, {m:?}");
+ }
+ }
+}
+
+/// A Paintbrush sample under a pixel from the last point is dropped, and a release there keeps
+/// the last point: the closing cursor follows that point, not the pointer.
+#[test]
+fn the_paintbrush_closing_cursor_follows_the_point_a_release_keeps() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+ let none = Mods::default();
+ let mut t = GestureTool::new("paintbrush");
+ t.set_option("closeWithin", &json!(15.0));
+ for (k, x, y) in [(PointerKind::Down, 310.0, 330.0), (PointerKind::Drag, 360.0, 350.0), (PointerKind::Drag, 330.0, 390.0)] {
+ t.pointer(&cx, &PointerEvent::new(k, x, y));
+ }
+ // The last point kept is 15.5 from the start, outside Close Paths When Ends Are Within.
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 325.5, 330.0));
+ assert_eq!(t.cursor(&cx, Point::new(325.5, 330.0), none), Cursor::Paintbrush, "outside the closing distance");
+ // The pointer moves 0.7 to 14.8 from the start; the sample is dropped.
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 324.8, 330.0));
+ assert_eq!(t.cursor(&cx, Point::new(324.8, 330.0), none), Cursor::Paintbrush, "the dropped sample shows no ring");
+ let acts = t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 324.8, 330.0));
+ let Some(Action::Preview(_, v)) = acts.first() else { panic!("{acts:?}") };
+ assert_eq!(v["closed"], json!(false), "the release keeps the last point and leaves the path open");
+}
+
+#[test]
+fn eraser_and_knife_exec_on_release() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+ let mut t = GestureTool::new("eraser");
+ let acts = drag(&mut t, &cx, &[(50.0, 150.0), (250.0, 150.0)], Mods::default());
+ assert!(acts[1].is_empty());
+ assert!(matches!(&acts[2][0], Action::Exec(c, v) if c == "path.eraseRegion" && v["size"] == 10.0));
+ let mut k = GestureTool::new("knife");
+ k.pointer(&cx, &PointerEvent::new(PointerKind::Down, 50.0, 150.0));
+ k.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 150.0, 150.0));
+ assert_eq!(k.overlays(&cx).len(), 1);
+ let a = k.pointer(&cx, &PointerEvent::new(PointerKind::Up, 250.0, 150.0));
+ assert!(matches!(&a[0], Action::Exec(c, v) if c == "path.knife" && v["points"].as_array().unwrap().len() == 3));
+}
+
+/// The Eraser's Angle and Roundness (Eraser Tool Options) go with its stroke, kept within
+/// −180–180° and 1–100%; while it drags, a tip that is not round shows the outline of the area
+/// it covers, and a round one the drag as wide as the tip.
+#[test]
+fn the_eraser_sends_its_tip_and_shows_the_area_it_covers() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+ let mut t = GestureTool::new("eraser");
+ t.set_option("size", &json!(20));
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 50.0, 150.0));
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 150.0, 150.0));
+ let round = t.overlays(&cx);
+ assert!(matches!(&round[..], [Overlay::Path { width, .. }] if *width == 20.0), "{round:?}");
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 250.0, 150.0));
+ for (angle, roundness, sent) in [(90.0, 25.0, (90.0, 25.0)), (400.0, 0.0, (180.0, 1.0)), (-400.0, 250.0, (-180.0, 100.0))] {
+ t.set_option("angle", &json!(angle));
+ t.set_option("roundness", &json!(roundness));
+ assert_eq!((t.options()["angle"].as_f64(), t.options()["roundness"].as_f64()), (Some(sent.0), Some(sent.1)));
+ let acts = drag(&mut t, &cx, &[(50.0, 150.0), (250.0, 150.0)], Mods::default());
+ assert!(
+ matches!(&acts[2][0], Action::Exec(c, v) if c == "path.eraseRegion" && v["size"] == 20.0 && v["angle"] == sent.0 && v["roundness"] == sent.1),
+ "{acts:?}"
+ );
+ }
+ // A tip 20 pt long and 5 pt wide, standing upright: along a horizontal drag from x 50 to
+ // x 150 the outline reaches 2.5 pt either side of the drag and 10 pt above and below
+ // its ends.
+ t.set_option("angle", &json!(90));
+ t.set_option("roundness", &json!(25));
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 50.0, 150.0));
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 150.0, 150.0));
+ let o = t.overlays(&cx);
+ let [Overlay::Path { path, width, .. }] = &o[..] else { panic!("{o:?}") };
+ assert_eq!(*width, 1.0);
+ let b = vectorcraft_geom::Shape::bounding_box(path);
+ assert!((b.x0 - 47.5).abs() < 0.1 && (b.x1 - 152.5).abs() < 0.1, "{b:?}");
+ assert!((b.y0 - 140.0).abs() < 0.1 && (b.y1 - 160.0).abs() < 0.1, "{b:?}");
+}
+
+#[test]
+fn smooth_needs_selection_and_brackets_resize() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+ let mut t = GestureTool::new("smooth");
+ let acts = drag(&mut t, &cx, &[(50.0, 150.0), (250.0, 150.0)], Mods::default());
+ assert!(acts.iter().all(|a| a.is_empty()));
+ let mut b = GestureTool::new("blobBrush");
+ b.key(&cx, ToolKey::BracketRight, Mods::default());
+ assert_eq!(b.options()["size"], 11.0);
+}
+
+#[test]
+fn pencil_alt_toggles_to_smooth_when_enabled_and_closes_when_disabled() {
+ let (d, id) = doc_with_rect();
+ let mut s = Selection::default();
+ s.set([id]);
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+
+ // Off by default, as Pencil Tool Options ships it; on, Alt lends the Smooth tool.
+ let mut t = GestureTool::new("pencil");
+ assert_eq!(t.options()["altSmooth"], json!(false));
+ t.set_option("altSmooth", &json!(true));
+
+ // When alt is pressed, cursor shows smooth tool.
+ let alt_mod = Mods { alt: true, ..Default::default() };
+ assert_eq!(t.cursor(&cx, Point::new(50.0, 50.0), alt_mod), Cursor::Smooth);
+ assert_eq!(t.cursor(&cx, Point::new(50.0, 50.0), Mods::default()), Cursor::PencilNew);
+
+ // Alt-drag over selected path smooths it.
+ let acts = drag_held(&mut t, &cx, &[(50.0, 150.0), (150.0, 150.0), (250.0, 150.0)], alt_mod);
+ assert!(acts[1].is_empty(), "drag does not preview freehand path while smoothing");
+ let last = acts.last().unwrap();
+ assert!(
+ matches!(&last[0], Action::Exec(c, v) if c == "path.smoothRegion" && v["points"].as_array().unwrap().len() == 3),
+ "expected path.smoothRegion, got: {last:?}"
+ );
+
+ // When altSmooth is disabled:
+ t.set_option("altSmooth", &json!(false));
+ assert_eq!(t.options()["altSmooth"], json!(false));
+ // Before a press, Alt gives a straight line rather than a closed path.
+ assert_eq!(t.cursor(&cx, Point::new(50.0, 50.0), alt_mod), Cursor::PencilStraight);
+
+ // A drag released with Alt held draws a closed pencil path.
+ let empty_sel = Selection::default();
+ let cx_empty = crate::testutil::cx(&d, &empty_sel, &p);
+ let acts = drag(&mut t, &cx_empty, &[(0.0, 0.0), (10.0, 5.0), (20.0, 0.0)], alt_mod);
+ assert_eq!(acts[1][0], Action::Begin("Pencil".into()));
+ let last = acts.last().unwrap();
+ assert!(matches!(&last[0], Action::Preview(_, v) if v["closed"] == true && v["style"] == "pencil"));
+ assert_eq!(last[1], Action::Commit);
+}