Skip to content

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

Use Preview Bounds: a handle drag keeps the opposite visible edge in place

dotCooCooa5ea3a800276
diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rs
index 681c2bcc5..87ec6c8a5 100644
--- a/crates/engine/src/cmd/mod.rs
+++ b/crates/engine/src/cmd/mod.rs
@@ -486,6 +486,7 @@ pub(crate) fn unique_name(base: &str, taken: impl Fn(&str) -> bool) -> String {
}
pub(crate) use edit::{settle_interaction, typing_in_progress};
+pub(crate) use object::bounds_rewrite;
pub(crate) use vectorcraft_doc::range::parse_range;
/// A date param in Unix seconds that defaults to the clock: `None` when absent (now, see
diff --git a/crates/engine/src/cmd/object.rs b/crates/engine/src/cmd/object.rs
index d814c4f01..3fab5fe93 100644
--- a/crates/engine/src/cmd/object.rs
+++ b/crates/engine/src/cmd/object.rs
@@ -1724,14 +1724,51 @@ fn distribute_spacing(s: &mut Session, p: &Value) -> Result<Value> {
}
fn set_bounds(s: &mut Session, p: &Value) -> Result<Value> {
+ match bounds_transform(s, p, selected_roots(s)?, 0.0)? {
+ Bounds::Anchors(ids, b) => set_anchor_bounds(s, p, ids, b),
+ Bounds::Objects(ids, xf) => apply_transform(s, "Transform", ids, xf, p, false),
+ }
+}
+
+/// What `object.setBounds` does with its values ([`bounds_transform`]).
+enum Bounds {
+ /// With anchors selected with Direct Selection: the objects and the box of the anchors that
+ /// [`set_anchor_bounds`] moves or scales.
+ Anchors(Vec<NodeId>, Rect),
+ /// The objects and the transform that gives them the values.
+ Objects(Vec<NodeId>, Affine),
+}
+
+/// A previewed `object.setBounds` that transforms objects runs as `object.transform` with the
+/// transform [`bounds_transform`] finds for it, so the interaction commits that transform (Transform
+/// Again repeats it, and the journal holds it). A bounding-box handle drag with Use Preview Bounds
+/// previews `object.setBounds`. The objects are those `object.transform` transforms (a path of a
+/// compound path selected on its own is one), and the art keeps at least 1e-4 of its width and
+/// height, as with [`vectorcraft_tools::bbox::scale_for_drag`]. `None` with anchors selected with
+/// Direct Selection and when the values are not valid.
+pub(crate) fn bounds_rewrite(s: &Session, cmd: &str, params: &Value) -> Option<(String, Value)> {
+ if cmd != "object.setBounds" {
+ return None;
+ }
+ let Ok(Bounds::Objects(_, xf)) = bounds_transform(s, params, selected_roots_to_transform(s).ok()?, 1e-4) else { return None };
+ let mut p = params.as_object().cloned().unwrap_or_default();
+ for k in ["x", "y", "width", "height", "reference", "proportional"] {
+ p.remove(k);
+ }
+ p.insert("matrix".into(), json!(xf.as_coeffs()));
+ Some(("object.transform".to_string(), Value::Object(p)))
+}
+
+/// How `object.setBounds` with params `p` changes the objects `ids`. A scale that would leave the
+/// art with a width or height below `least` of the one it has keeps `least` of it.
+fn bounds_transform(s: &Session, p: &Value, ids: Vec<NodeId>, least: f64) -> Result<Bounds> {
check_numbers(p, &["x", "y", "width", "height"], "object.setBounds")?;
- let ids = selected_roots(s)?;
let st = s.doc()?;
if transforms_objects(p)
&& !bool_or(p, "copy", false)
&& let Some(b) = effects::preview::anchor_bounds(&st.selection, &st.doc, s.prefs.use_preview_bounds)
{
- return set_anchor_bounds(s, p, ids, b);
+ return Ok(Bounds::Anchors(ids, b));
}
let d = &s.doc()?.doc;
// Sizes are measured square to the bounding box, which a rotation turns with the objects:
@@ -1786,7 +1823,7 @@ fn set_bounds(s: &mut Session, p: &Value) -> Result<Value> {
// leave a rounding error in it on a rotated object or with Use Preview Bounds.
let current = |k: &str, now: f64| p.get(k).and_then(Value::as_f64).is_none_or(|x| x == now);
if current("x", page.x) && current("y", page.y) && current("width", v.width()) && current("height", v.height()) {
- return apply_transform(s, "Transform", ids, Affine::IDENTITY, p, false);
+ return Ok(Bounds::Objects(ids, Affine::IDENTITY));
}
let to = frame.to_local(Point::new(f64_or(p, "x", page.x), f64_or(p, "y", page.y)));
// The scales and the point above can miss the size or the reference point when the margins of
@@ -1818,8 +1855,15 @@ fn set_bounds(s: &mut Session, p: &Value) -> Result<Value> {
} else {
Spans::measure(d, &ids, &frame, strokes).refit(rp, refi, [w, h], (sx, sy, new_rp))
};
- let (scale, new_rp) = solved.map_or((scale, new_rp), |(sx, sy, at)| (about(rp, Affine::scale_non_uniform(sx, sy)), at));
- apply_transform(s, "Transform", ids, frame.conjugate(Affine::translate(to - new_rp) * scale), p, false)
+ let (sx, sy, new_rp) = solved.unwrap_or((sx, sy, new_rp));
+ // A scale below `least` of art with a width (height) keeps `least`, and the reference point
+ // moves with the scales as above.
+ let keep = |s: f64, geo: f64| if geo > 1e-9 && (0.0..least).contains(&s) { least } else { s };
+ let (kx, ky) = (keep(sx, g.width()), keep(sy, g.height()));
+ let scale = about(rp, Affine::scale_non_uniform(kx, ky));
+ let new_rp = if (kx, ky) == (sx, sy) { new_rp } else { scale * gp + (sp - gp) * f(kx, ky) + (rp - sp) };
+ let xf = frame.conjugate(Affine::translate(to - new_rp) * scale);
+ Ok(Bounds::Objects(ids, xf))
}
/// The scales along x and y that give the box `measure` returns for them the size `size`, and point
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index b08053415..4d078301a 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -1902,7 +1902,7 @@ impl Session {
}
// The previous preview's paint is undone with it.
self.pending_paint = None;
- let rw = cmd::distortcmds::perspective_rewrite(self, cmd, params);
+ let rw = cmd::distortcmds::perspective_rewrite(self, cmd, params).or_else(|| cmd::bounds_rewrite(self, cmd, params));
let (cmd, params) = rw.as_ref().map_or((cmd, params), |(c, p)| (c.as_str(), p));
let outer = std::mem::replace(&mut self.previewing, true);
let r = self.execute(cmd, params);
diff --git a/crates/engine/src/tests_previewbounds.rs b/crates/engine/src/tests_previewbounds.rs
index a8ffe4ee0..88b87394d 100644
--- a/crates/engine/src/tests_previewbounds.rs
+++ b/crates/engine/src/tests_previewbounds.rs
@@ -748,6 +748,136 @@ fn the_bounding_box_handles_sit_on_the_offset_shape() {
assert_eq!(drag(false).width(), 100.0, "off, the point is no handle");
}
+/// The box `id` is drawn in (strokes and geometry effects included) and its geometric box after a
+/// Selection tool drag from `from` to `to` with `mods`, with Smart Guides off.
+fn drag_box(s: &mut Session, id: NodeId, from: (f64, f64), to: (f64, f64), mods: Mods) -> (Rect, Rect) {
+ let v = ViewInfo { smart_guides: false, ..ViewInfo::default() };
+ s.select_tool("selection", v).unwrap();
+ for (k, (x, y)) in [(PointerKind::Down, from), (PointerKind::Drag, to), (PointerKind::Up, to)] {
+ s.pointer(&PointerEvent { mods, ..PointerEvent::new(k, x, y) }, v).unwrap();
+ }
+ let drawn = vectorcraft_render::effects::preview::bounds_of(&s.doc().unwrap().doc, &[id], true).unwrap();
+ (drawn, geometric(s, id))
+}
+
+/// Drags of `make`'s object with Use Preview Bounds on, and Scale Strokes & Effects off and on: from
+/// the handle at the first point to the second point, with the modifiers, giving the visual box.
+type HandleDrags = [((f64, f64), (f64, f64), Mods, Rect); 4];
+
+fn assert_handle_drags(make: fn(&mut Session) -> NodeId, drags: HandleDrags) {
+ for strokes in [false, true] {
+ for (from, to, mods, want) in drags {
+ let mut s = session();
+ let id = make(&mut s);
+ preview(&mut s, true);
+ s.prefs.scale_strokes = strokes;
+ let (v, _) = drag_box(&mut s, id, from, to, mods);
+ assert!(near(v, want, 1e-6), "strokes {strokes}, {from:?} to {to:?}, {mods:?}: {v:?}");
+ }
+ }
+}
+
+const SHIFT: Mods = Mods { shift: true, alt: false, cmd: false, ctrl: false, space: false };
+const ALT: Mods = Mods { shift: false, alt: true, cmd: false, ctrl: false, space: false };
+
+#[test]
+fn a_handle_drag_keeps_the_opposite_visual_edge_of_a_stroked_path() {
+ // A 100 x 50 rectangle at (100, 100) with a 20 pt stroke, drawn from (90, 90) to (210, 160): the
+ // opposite edge of the visual box stays and the dragged edge goes to the pointer, with Shift in
+ // proportion, with Alt about the center.
+ let make = |s: &mut Session| rect(s, 100.0, 100.0, 20.0);
+ assert_handle_drags(
+ make,
+ [
+ ((210.0, 125.0), (310.0, 125.0), Mods::default(), Rect::new(90.0, 90.0, 310.0, 160.0)),
+ ((210.0, 160.0), (260.0, 200.0), Mods::default(), Rect::new(90.0, 90.0, 260.0, 200.0)),
+ ((210.0, 160.0), (330.0, 170.0), SHIFT, Rect::new(90.0, 90.0, 330.0, 230.0)),
+ ((210.0, 125.0), (260.0, 125.0), ALT, Rect::new(40.0, 90.0, 260.0, 160.0)),
+ ],
+ );
+ // Off, the handles sit on the path, and the path scales from its own opposite edge.
+ for strokes in [false, true] {
+ let mut s = session();
+ let id = make(&mut s);
+ s.prefs.scale_strokes = strokes;
+ let (_, g) = drag_box(&mut s, id, (200.0, 125.0), (300.0, 125.0), Mods::default());
+ assert_eq!(g, Rect::new(100.0, 100.0, 300.0, 150.0), "strokes {strokes}");
+ let (_, g) = drag_box(&mut s, id, (300.0, 150.0), (350.0, 200.0), Mods::default());
+ assert_eq!(g, Rect::new(100.0, 100.0, 350.0, 200.0), "strokes {strokes}");
+ }
+}
+
+#[test]
+fn transform_again_repeats_the_transform_of_a_handle_drag_with_preview_bounds() {
+ // The drag takes the visual right edge of the stroked rectangle from 210 to 310, so the path,
+ // with its stroke kept, goes from 100..200 to 100..300: x becomes 2x - 100.
+ let mut s = session();
+ let id = rect(&mut s, 100.0, 100.0, 20.0);
+ preview(&mut s, true);
+ s.prefs.scale_strokes = false;
+ let (_, g) = drag_box(&mut s, id, (210.0, 125.0), (310.0, 125.0), Mods::default());
+ assert!(near(g, Rect::new(100.0, 100.0, 300.0, 150.0), 1e-6), "{g:?}");
+ run(&mut s, "object.transformAgain", json!({}));
+ assert!(near(geometric(&s, id), Rect::new(100.0, 100.0, 500.0, 150.0), 1e-6), "{:?}", geometric(&s, id));
+}
+
+#[test]
+fn a_handle_drag_with_preview_bounds_scales_a_compound_paths_member_alone() {
+ // A ring: a 100 pt square at (100, 100) with a 20 pt square hole at (140, 140), the hole selected
+ // alone in the isolated compound path.
+ let mut s = session();
+ let square = |s: &mut Session, at: f64, size: f64| {
+ NodeId(run(s, "shape.rectangle", json!({"x": at, "y": at, "width": size, "height": size}))["id"].as_u64().unwrap())
+ };
+ let (outer, hole) = (square(&mut s, 100.0, 100.0), square(&mut s, 140.0, 20.0));
+ run(&mut s, "select.set", json!({"ids": [outer.0, hole.0]}));
+ let c = run(&mut s, "object.compoundPath.make", json!({}))["id"].as_u64().unwrap();
+ run(&mut s, "object.isolate", json!({"id": c}));
+ run(&mut s, "select.set", json!({"ids": [hole.0]}));
+ preview(&mut s, true);
+ let (b, around) = (s.transform_bounds(&[hole]).unwrap(), s.transform_bounds(&[outer]));
+ let (v, _) = drag_box(&mut s, hole, (b.x1, b.center().y), (b.x1 + 10.0, b.center().y), Mods::default());
+ assert_eq!(s.transform_bounds(&[outer]), around, "the square around the hole stays");
+ assert!(near(v, Rect::new(b.x0, b.y0, b.x1 + 10.0, b.y1), 1e-6), "the hole: {v:?} from {b:?}");
+}
+
+#[test]
+fn a_handle_drag_with_preview_bounds_leaves_the_art_some_width() {
+ // Dragging the visual right edge of the rectangle with a kept 20 pt stroke (drawn from 90 to 210)
+ // to 95 asks for less width than the stroke adds: the path keeps 1e-4 of its width.
+ let mut s = session();
+ let id = rect(&mut s, 100.0, 100.0, 20.0);
+ preview(&mut s, true);
+ s.prefs.scale_strokes = false;
+ let (_, g) = drag_box(&mut s, id, (210.0, 125.0), (95.0, 125.0), Mods::default());
+ assert!((g.width() - 0.01).abs() < 1e-9, "{g:?}");
+}
+
+#[test]
+fn a_handle_drag_keeps_the_opposite_edge_of_the_offset_shape() {
+ // A 100 pt square at (100, 100) with Offset Path 10, drawn from (90, 90) to (210, 210).
+ let make = |s: &mut Session| offset_square(s, 100.0);
+ assert_handle_drags(
+ make,
+ [
+ ((210.0, 150.0), (310.0, 150.0), Mods::default(), Rect::new(90.0, 90.0, 310.0, 210.0)),
+ ((210.0, 210.0), (260.0, 250.0), Mods::default(), Rect::new(90.0, 90.0, 260.0, 250.0)),
+ ((210.0, 210.0), (330.0, 220.0), SHIFT, Rect::new(90.0, 90.0, 330.0, 330.0)),
+ ((210.0, 150.0), (260.0, 150.0), ALT, Rect::new(40.0, 90.0, 260.0, 210.0)),
+ ],
+ );
+ // Off, the handles sit on the square, and the square scales from its own opposite edge.
+ for strokes in [false, true] {
+ let mut s = session();
+ let id = make(&mut s);
+ s.prefs.scale_strokes = strokes;
+ let (_, g) = drag_box(&mut s, id, (200.0, 150.0), (300.0, 150.0), Mods::default());
+ assert_eq!(g, Rect::new(100.0, 100.0, 300.0, 200.0), "strokes {strokes}");
+ let (_, g) = drag_box(&mut s, id, (300.0, 200.0), (350.0, 250.0), Mods::default());
+ assert_eq!(g, Rect::new(100.0, 100.0, 350.0, 250.0), "strokes {strokes}");
+ }
+}
+
#[test]
fn hovering_over_an_unchanged_document_measures_nothing_again() {
// A selected square with Offset Path 10, drawn from 90 to 210, with Use Preview Bounds and Smart
diff --git a/crates/tools/src/bbox.rs b/crates/tools/src/bbox.rs
index 2227bef27..37d2dca53 100644
--- a/crates/tools/src/bbox.rs
+++ b/crates/tools/src/bbox.rs
@@ -46,6 +46,20 @@ impl Handle {
_ => (true, true),
}
}
+ /// The handle's point in the 9-point reference grid (row-major from the top-left, 4 the center)
+ /// that `object.setBounds` takes as `reference`.
+ pub fn reference(self) -> usize {
+ match self {
+ Handle::TopLeft => 0,
+ Handle::Top => 1,
+ Handle::TopRight => 2,
+ Handle::Left => 3,
+ Handle::Right => 5,
+ Handle::BottomLeft => 6,
+ Handle::Bottom => 7,
+ Handle::BottomRight => 8,
+ }
+ }
}
/// Handle under `p` (within `tol` document units).
@@ -122,6 +136,9 @@ mod tests {
assert_eq!(Handle::Top.opposite(), Handle::Bottom);
assert_eq!(hit_handle(R, Point::new(99.0, 24.0), 3.0), Some(Handle::Right));
assert_eq!(hit_handle(R, Point::new(50.0, 25.0), 3.0), None);
+ for h in Handle::ALL {
+ assert_eq!(vectorcraft_geom::reference_point(R, h.reference()), h.pos(R), "{h:?}");
+ }
}
#[test]
diff --git a/crates/tools/src/select.rs b/crates/tools/src/select.rs
index 6a21f9d45..225bf7b8a 100644
--- a/crates/tools/src/select.rs
+++ b/crates/tools/src/select.rs
@@ -716,11 +716,21 @@ impl Tool for SelectionTool {
}
let nr = a.transform_rect_bbox(bx.rect);
self.measure = cx.transform_tools_guides.then(|| (p, cx.size_label(nr.width(), nr.height())));
- let mut params = json!({ "matrix": matrix_json(bx.conjugate(a)), "copy": false });
+ // With Use Preview Bounds the box is the visual box, whose margins around the art
+ // (strokes, geometry effects) scale with it or stay. `object.setBounds` then gives the
+ // visual box the dragged size and keeps its opposite handle (with Alt, its center)
+ // where it is. A drag that flips the box scales by the matrix.
+ let [sx, _, _, sy, _, _] = a.as_coeffs();
+ let (cmd, mut params) = if cx.preview_bounds && cx.selection.anchors.is_empty() && sx > 0.0 && sy > 0.0 {
+ let reference = if m.alt { 4 } else { handle.opposite().reference() };
+ ("object.setBounds", json!({ "width": nr.width(), "height": nr.height(), "reference": reference, "copy": false }))
+ } else {
+ ("object.transform", json!({ "matrix": matrix_json(bx.conjugate(a)), "copy": false }))
+ };
if areas {
params["typeAreas"] = json!(true);
}
- vec![Action::Preview("object.transform".into(), params)]
+ vec![Action::Preview(cmd.into(), params)]
}
(PointerKind::Drag, State::Rotating { center, start, .. }) => {
let (a, deg) = rotate_for_drag(center, start, p, m.shift);