DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
Snap: visible bounds and constrained gestures
Cameron Gilroy78605f294453
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rsindex e11fb77c9..8f2f39b0f 100644--- a/crates/engine/src/tests.rs+++ b/crates/engine/src/tests.rs@@ -69,7 +69,10 @@ fn tool_gesture_creates_one_undo_step() {s.pointer(&PointerEvent::new(PointerKind::Down, 60.0, 30.0), v).unwrap();s.pointer(&PointerEvent::new(PointerKind::Drag, 48.0, 30.0), v).unwrap();s.pointer(&PointerEvent::new(PointerKind::Up, 48.0, 30.0), v).unwrap();- assert_eq!(s.doc().unwrap().doc.spreads[0].items[0].bounds().x0, 36.0);+ // The rectangle tool's 1 pt centered stroke sits half a point outside the path.+ // The visible edge lands on the 36 pt margin.+ let it = &s.doc().unwrap().doc.spreads[0].items[0];+ assert!((it.visible_bounds().x0 - 36.0).abs() < 1e-6, "visible {:?} path {:?}", it.visible_bounds(), it.bounds());}#[test]diff --git a/crates/tools/src/frame.rs b/crates/tools/src/frame.rsindex b7e94412b..87b4284cc 100644--- a/crates/tools/src/frame.rs+++ b/crates/tools/src/frame.rs@@ -1,10 +1,11 @@//! Frame and shape tools (Rectangle/Ellipse/Polygon Frame, Rectangle/Ellipse/Polygon, Line).//! Drag to draw (Shift = square/45°, Alt = from centre); click opens the size dialog.+use designcraft_doc::SpreadRef;use designcraft_geom::{Point, Rect};use serde_json::json;-use crate::{Action, Cursor, Gesture, Mods, Overlay, PointerEvent, PointerKind, SnapRequest, Tool, ToolContext, rect_json, spread_json};+use crate::{Action, Cursor, Gesture, Mods, Overlay, PointerEvent, PointerKind, Snap, SnapRequest, Tool, ToolContext, rect_json, spread_json};pub struct FrameTool {id: &'static str,@@ -109,6 +110,209 @@ fn length_on(edges: [bool; 3], size: f64) -> Option<f64> {len.is_finite().then_some(len)}+fn line_hit(cx: &ToolContext, spread: SpreadRef, point: Point, len: Option<f64>) -> Snap {+ crate::snap::snap(+ cx,+ SnapRequest {+ spread,+ gesture: Gesture::Create,+ rect: Rect::from_points(point, point),+ x_edges: [true, true, true],+ y_edges: [true, true, true],+ exclude: &[],+ copying: false,+ lengths: [len, None],+ angle: None,+ radius: 0.0,+ pointer: point,+ },+ )+}++/// Position corrections only. A length win is not an x shove.+fn apply_position(mut end: Point, hit: &Snap) -> (Point, bool, bool) {+ let x_len = finite_length(hit.length_delta[0]);+ let y_len = finite_length(hit.length_delta[1]);+ if x_len.is_none() && hit.delta.x.is_finite() {+ end.x += hit.delta.x;+ }+ if y_len.is_none() && hit.delta.y.is_finite() {+ end.y += hit.delta.y;+ }+ let x_locked = x_len.is_none() && hit.delta.x.is_finite() && hit.delta.x.abs() > 1e-9;+ let y_locked = y_len.is_none() && hit.delta.y.is_finite() && hit.delta.y.abs() > 1e-9;+ (end, x_locked, y_locked)+}++fn finite_length(v: Option<f64>) -> Option<f64> {+ v.filter(|d| d.is_finite())+}++/// Slide along the segment so its length equals `current + diff`.+fn length_slide(anchor: Point, end: Point, diff: f64) -> Point {+ let dir = end - anchor;+ let len = dir.hypot();+ if !len.is_finite() || len <= 1e-9 || !diff.is_finite() {+ return end;+ }+ let target = len + diff;+ if !target.is_finite() || target < 0.0 {+ return end;+ }+ let scale = target / len;+ if !scale.is_finite() {+ return end;+ }+ Point::new(anchor.x + dir.x * scale, anchor.y + dir.y * scale)+}++/// A length match moves the free endpoint along the segment.+///+/// An axis a position pass already won stays put. The segment is not rescaled about the+/// anchor after that position delta, because the won axis would leave its guide.+fn commit_line_end(anchor: Point, proposed: Point, hit: &Snap) -> Point {+ let len = (proposed - anchor).hypot();+ let (mut end, x_locked, y_locked) = apply_position(proposed, hit);+ let Some(diff) = finite_length(hit.length_delta[0]).or(finite_length(hit.length_delta[1])) else {+ return end;+ };+ if !x_locked && !y_locked {+ return length_slide(anchor, proposed, diff);+ }+ let target = len + diff;+ if !target.is_finite() || target < 0.0 {+ return end;+ }+ if y_locked && !x_locked {+ let dy = end.y - anchor.y;+ let remain = target * target - dy * dy;+ if remain >= 0.0 && remain.is_finite() {+ let vx = proposed.x - anchor.x;+ let sign = if vx.abs() > 1e-9 { vx.signum() } else { 1.0 };+ end.x = anchor.x + sign * remain.sqrt();+ }+ return end;+ }+ if x_locked && !y_locked {+ let dx = end.x - anchor.x;+ let remain = target * target - dx * dx;+ if remain >= 0.0 && remain.is_finite() {+ let vy = proposed.y - anchor.y;+ let sign = if vy.abs() > 1e-9 { vy.signum() } else { 1.0 };+ end.y = anchor.y + sign * remain.sqrt();+ }+ }+ end+}++/// Shift line: slide along the ray. A position hit wins. Otherwise the length does.+fn snap_shift_line(cx: &ToolContext, spread: SpreadRef, anchor: Point, proposed: Point, guides: &mut Vec<Overlay>) -> Point {+ let pos = line_hit(cx, spread, proposed, None);+ if let Some(end) = ray_position(anchor, proposed, &pos) {+ *guides = pos.guides;+ return end;+ }+ let len = (proposed - anchor).hypot();+ let hit = line_hit(cx, spread, proposed, len.is_finite().then_some(len));+ let diff = finite_length(hit.length_delta[0]);+ let end = match diff {+ Some(diff) => length_slide(anchor, proposed, diff),+ None => proposed,+ };+ *guides = hit.guides;+ if let Some(diff) = diff {+ crate::snap::lay_line_dimension(guides, cx.layout.xf(spread), anchor, proposed, end, diff);+ }+ end+}++fn snap_free_line(cx: &ToolContext, spread: SpreadRef, anchor: Point, proposed: Point, guides: &mut Vec<Overlay>) -> Point {+ let len = (proposed - anchor).hypot();+ let hit = line_hit(cx, spread, proposed, len.is_finite().then_some(len));+ let end = commit_line_end(anchor, proposed, &hit);+ let diff = finite_length(hit.length_delta[0]);+ *guides = hit.guides;+ if let Some(diff) = diff {+ crate::snap::lay_line_dimension(guides, cx.layout.xf(spread), anchor, proposed, end, diff);+ }+ end+}++/// Closest position correction, applied along the ray. None when neither axis has one.+fn ray_position(anchor: Point, end: Point, hit: &Snap) -> Option<Point> {+ let dir = end - anchor;+ let len = dir.hypot();+ if !len.is_finite() || len <= 1e-9 {+ return None;+ }+ let ux = dir.x / len;+ let uy = dir.y / len;+ let slide = closer_slide(ux, uy, nonzero_delta(hit.delta.x), nonzero_delta(hit.delta.y))?;+ let t = len + slide;+ t.is_finite().then_some(Point::new(anchor.x + ux * t, anchor.y + uy * t))+}++fn nonzero_delta(delta: f64) -> Option<f64> {+ (delta.is_finite() && delta.abs() > 1e-9).then_some(delta)+}++fn closer_slide(ux: f64, uy: f64, x_pos: Option<f64>, y_pos: Option<f64>) -> Option<f64> {+ let mut best: Option<(f64, f64)> = None;+ if let Some(dx) = x_pos+ && ux.abs() > 1e-9+ {+ let slide = dx / ux;+ if slide.is_finite() {+ best = Some((dx.abs(), slide));+ }+ }+ if let Some(dy) = y_pos+ && uy.abs() > 1e-9+ {+ let slide = dy / uy;+ if slide.is_finite() && best.is_none_or(|(dist, _)| dy.abs() < dist) {+ best = Some((dy.abs(), slide));+ }+ }+ best.map(|(_, slide)| slide)+}++/// Shift already constrained the shape. Snap only the driving edge, then rebuild the other.+fn restore_shift_frame(anchor: Point, end: Point, rect: Rect, driver_x: bool, from_center: bool) -> Rect {+ if from_center {+ let half = if driver_x {+ let edge = if end.x >= anchor.x { rect.x1 } else { rect.x0 };+ (edge - anchor.x).abs()+ } else {+ let edge = if end.y >= anchor.y { rect.y1 } else { rect.y0 };+ (edge - anchor.y).abs()+ };+ if !half.is_finite() {+ return rect;+ }+ return Rect::new(anchor.x - half, anchor.y - half, anchor.x + half, anchor.y + half);+ }+ let span = if driver_x { rect.x1 - rect.x0 } else { rect.y1 - rect.y0 };+ if !span.is_finite() {+ return rect;+ }+ let size = span.abs();+ let sx = (end.x - anchor.x).signum();+ let sy = (end.y - anchor.y).signum();+ if sx == 0.0 || sy == 0.0 || !size.is_finite() {+ return rect;+ }+ if driver_x {+ let y_far = anchor.y + sy * size;+ let (y0, y1) = if sy > 0.0 { (anchor.y, y_far) } else { (y_far, anchor.y) };+ Rect::new(rect.x0, y0, rect.x1, y1)+ } else {+ let x_far = anchor.x + sx * size;+ let (x0, x1) = if sx > 0.0 { (anchor.x, x_far) } else { (x_far, anchor.x) };+ Rect::new(x0, rect.y0, x1, rect.y1)+ }+}+impl Tool for FrameTool {fn id(&self) -> &'static str {self.id@@ -146,46 +350,34 @@ impl Tool for FrameTool {)));}if shape == "line" {- // Shift constrains the angle first. The free endpoint still snaps.+ // Shift constrains the angle first. The endpoint then snaps along that ray.let mut b = cx.layout.to_spread(sr, ev.pos);if ev.mods.shift {let v = b - sa;b = sa + designcraft_geom::constrain_angle(v, 45.0);}if cx.snap.any() {- let len = (b - sa).hypot();- let hit = crate::snap::snap(- cx,- SnapRequest {- spread: sr,- gesture: Gesture::Create,- rect: Rect::from_points(b, b),- x_edges: [true, true, true],- y_edges: [true, true, true],- exclude: &[],- copying: false,- lengths: [len.is_finite().then_some(len), None],- angle: None,- radius: 0.0,- pointer: b,- },- );- // Position and length both land on the endpoint. Rescaling the segment would leave the other axis.- if hit.delta.x.is_finite() {- b.x += hit.delta.x;- }- if hit.delta.y.is_finite() {- b.y += hit.delta.y;- }- self.guides = hit.guides;+ b = if ev.mods.shift {+ snap_shift_line(cx, sr, sa, b, &mut self.guides)+ } else {+ snap_free_line(cx, sr, sa, b, &mut self.guides)+ };}out.push(Action::Preview("line.create".into(), json!({"spread": spread_json(sr), "a": [sa.x, sa.y], "b": [b.x, b.y]})));} else {- // Shift constrains the shape first. The free edges still snap.+ // Shift constrains the shape first. Only the driving edge snaps, then the other follows.let end = cx.layout.to_spread(sr, ev.pos);let mut r = drag_rect(sa, end, ev.mods);if cx.snap.any() {- let (x_edges, y_edges) = moving_edges(sa, end, r, ev.mods.alt);+ let (mut x_edges, mut y_edges) = moving_edges(sa, end, r, ev.mods.alt);+ let driver_x = (end.x - sa.x).abs() >= (end.y - sa.y).abs();+ if ev.mods.shift {+ if driver_x {+ y_edges = [false, false, false];+ } else {+ x_edges = [false, false, false];+ }+ }let hit = crate::snap::snap(cx,SnapRequest {@@ -203,6 +395,9 @@ impl Tool for FrameTool {},);r = crate::snap::nudge_edges(r, x_edges, y_edges, hit.delta);+ if ev.mods.shift {+ r = restore_shift_frame(sa, end, r, driver_x, ev.mods.alt);+ }self.guides = hit.guides;}self.last = Some((spread_json(sr), r));diff --git a/crates/tools/src/lib.rs b/crates/tools/src/lib.rsindex c28e4fe66..247494f84 100644--- a/crates/tools/src/lib.rs+++ b/crates/tools/src/lib.rs@@ -250,7 +250,7 @@ impl ToolContext<'_> {self.doc.item(id)}- /// Canvas bounds of the selected items.+ /// Canvas bounds of the selected items' paths. Handles and resize use this geometric box.pub fn selection_bounds(&self) -> Option<Rect> {let mut r: Option<Rect> = None;for id in &self.selection.items {@@ -260,6 +260,21 @@ impl ToolContext<'_> {}r}++ /// Canvas union of the selection's visible bounds. A group uses the alignment box.+ pub fn selection_visible_bounds(&self) -> Option<Rect> {+ let mut acc: Option<Rect> = None;+ for id in &self.selection.items {+ let (Some(it), Some(xf)) = (self.doc.item(*id), self.item_canvas_xf(*id)) else { continue };+ let Some(local) = crate::snap::moving_bounds(it) else { continue };+ let b = xf.transform_rect_bbox(local);+ if !(b.x0.is_finite() && b.y0.is_finite() && b.x1.is_finite() && b.y1.is_finite()) {+ continue;+ }+ acc = Some(acc.map_or(b, |have| have.union(b)));+ }+ acc+ }}/// Visual feedback (canvas coordinates) drawn by the UI.diff --git a/crates/tools/src/select.rs b/crates/tools/src/select.rsindex 07c470d0e..8f59c3503 100644--- a/crates/tools/src/select.rs+++ b/crates/tools/src/select.rs@@ -445,7 +445,7 @@ impl Tool for SelectionTool {if hit && !cx.selection.items.is_empty() {let sr = cx.selection.items.first().and_then(|i| cx.doc.find(*i)).map(|l| l.spread).unwrap_or(SpreadRef::Doc(0));let exclude = cx.selection.items.clone();- self.drag = Drag::Move { start, origin_spread: sr, bounds0: cx.selection_bounds(), exclude };+ self.drag = Drag::Move { start, origin_spread: sr, bounds0: cx.selection_visible_bounds(), exclude };let label = if ev.mods.alt { "Duplicate" } else { "Move" };let mut v = vec![Action::Begin(label.into())];v.extend(self.pointer(cx, ev));@@ -468,27 +468,38 @@ impl Tool for SelectionTool {screen_x_locked = true;}}+ // Snap on the spread under the pointer. Shift uses that spread's view rotation.+ let target = cx.layout.spread_at(p).map(|(s, _)| s).unwrap_or(origin_spread);// 180 degrees keeps the screen axis. 90 and 270 swap it into the other spread axis.- let odd_turn = cx.layout.slot(origin_spread).is_some_and(|slot| slot.rotation % 2 == 1);+ let odd_turn = cx.layout.slot(target).is_some_and(|slot| slot.rotation % 2 == 1);let spread_x_locked = if odd_turn { screen_y_locked } else { screen_x_locked };let spread_y_locked = if odd_turn { screen_x_locked } else { screen_y_locked };let x_edges = if spread_x_locked { [false; 3] } else { [true; 3] };let y_edges = if spread_y_locked { [false; 3] } else { [true; 3] };self.guides.clear();- // The movement in the spread's own coordinates (its view may be turned).+ // The movement in the origin spread's coordinates (its view may be turned).let mut ds = cx.layout.delta_to_spread(origin_spread, d);let b0s = bounds0.map(|b| cx.layout.xf(origin_spread).inverse().transform_rect_bbox(b));+ let q0 = b0s.map_or(Point::ORIGIN, |b| Point::new(b.x0, b.y0));+ // Same corner conversion transform.move already uses when the spread changes.+ let mut landed = cx.layout.to_spread(target, cx.layout.to_canvas(origin_spread, q0 + ds));// Command suspends snapping. A Shift-locked spread axis is not offered.if !ev.mods.cmd&& cx.snap.any()&& let Some(b0) = b0s{+ let proposed = if target == origin_spread {+ b0 + ds+ } else {+ let shift = landed - q0;+ Rect::new(b0.x0 + shift.x, b0.y0 + shift.y, b0.x1 + shift.x, b0.y1 + shift.y)+ };let hit = crate::snap::snap(cx,SnapRequest {- spread: origin_spread,+ spread: target,gesture: Gesture::Move,- rect: b0 + ds,+ rect: proposed,x_edges,y_edges,exclude: &exclude,@@ -496,26 +507,37 @@ impl Tool for SelectionTool {lengths: [None, None],angle: None,radius: 0.0,- pointer: cx.layout.to_spread(origin_spread, p),+ pointer: cx.layout.to_spread(target, p),},);- if x_edges != [false, false, false] {- ds.x += hit.delta.x;- }- if y_edges != [false, false, false] {- ds.y += hit.delta.y;+ if target == origin_spread {+ if x_edges != [false, false, false] && hit.delta.x.is_finite() {+ ds.x += hit.delta.x;+ }+ if y_edges != [false, false, false] && hit.delta.y.is_finite() {+ ds.y += hit.delta.y;+ }+ } else {+ if x_edges != [false, false, false] && hit.delta.x.is_finite() {+ landed.x += hit.delta.x;+ }+ if y_edges != [false, false, false] && hit.delta.y.is_finite() {+ landed.y += hit.delta.y;+ }}self.guides = hit.guides;}- // Dragging to another spread moves the items there.- let target = cx.layout.spread_at(p).map(|(s, _)| s).unwrap_or(origin_spread);- let mut params = json!({"dx": ds.x, "dy": ds.y, "copy": ev.mods.alt});- if target != origin_spread {- // Where the selection's corner lands, in the target spread.- let q0 = b0s.map_or(Point::ORIGIN, |b| Point::new(b.x0, b.y0));- let landed = cx.layout.to_spread(target, cx.layout.to_canvas(origin_spread, q0 + ds));+ // Same spread: dx, dy are the origin spread translation. Crossing: the corner+ // conversion, so the reparented item lands on the snapped target point.+ let (dx, dy) = if target == origin_spread {+ (ds.x, ds.y)+ } else {let dt = landed - q0;- params = json!({"dx": dt.x, "dy": dt.y, "copy": ev.mods.alt, "toSpread": spread_json(target)});+ (dt.x, dt.y)+ };+ let mut params = json!({"dx": dx, "dy": dy, "copy": ev.mods.alt});+ if target != origin_spread {+ params = json!({"dx": dx, "dy": dy, "copy": ev.mods.alt, "toSpread": spread_json(target)});}vec![Action::Preview("transform.move".into(), params)]}diff --git a/crates/tools/src/snap.rs b/crates/tools/src/snap.rsindex 92b0417eb..c3b251754 100644--- a/crates/tools/src/snap.rs+++ b/crates/tools/src/snap.rs@@ -252,14 +252,15 @@ fn zone_tol(cx: &ToolContext) -> Option<f64> {/// Matched rotation, in the same degrees `transform.rotate` receives.////// Runs only for [`Gesture::Rotate`], and only when Smart Guides and Smart Dimensions are on.-/// `angle` is compared with `decompose(item.xf).rotation` in the same sign. The tolerance is-/// the zone length subtended at `radius` (`atan(zone / radius)` in degrees). A radius below-/// 1 pt, or a non-finite angle, radius, or zone, does not hit. Candidates are visible items-/// on the requested spread, including children of a group, plus shown parent items. Each-/// candidate is that item's own transform, not an ancestor composed in. Hidden items and the-/// shared exclude list are skipped. An unrotated item contributes 0. The closest angle wins,-/// folding whole turns so a few degrees across 0 still match. The measure is the angle in-/// degrees and there is no guide line.+/// `angle` is compared with `decompose` of the absolute transform in the same sign. That+/// transform is the ancestor chain composed with `item.xf`. A top-level item has no ancestor,+/// so it stays `decompose(item.xf)`. The tolerance is the zone length subtended at `radius`+/// (`atan(zone / radius)` in degrees). A radius below 1 pt, or a non-finite angle, radius, or+/// zone, does not hit. Candidates are visible items on the requested spread, including children+/// of a group, plus shown parent items. A child inside a rotated group uses the composed angle,+/// not its local 0. Hidden items and the shared exclude list are skipped. An unrotated item+/// contributes 0. The closest angle wins, folding whole turns so a few degrees across 0 still+/// match. The measure is the angle in degrees and there is no guide line.fn rotation_snap(cx: &ToolContext, req: &SnapRequest<'_>, zone_length: f64) -> Snap {let Some(angle) = match_rotation(cx, req, zone_length) else {return Snap::default();@@ -288,7 +289,7 @@ fn match_rotation(cx: &ToolContext, req: &SnapRequest<'_>, zone_length: f64) ->let mut seen = HashSet::new();if let Some(spread) = cx.doc.spread(req.spread) {for item in &spread.items {- push_rotation(&mut best, cx.selection, req, item, false, 0, &mut seen, proposed, tol);+ push_rotation(&mut best, cx.selection, req, item, Affine::IDENTITY, false, 0, &mut seen, proposed, tol);}}// Parent editing already lists those items on the spread. Do not add them again.@@ -299,7 +300,7 @@ fn match_rotation(cx: &ToolContext, req: &SnapRequest<'_>, zone_length: f64) ->}/// Shown parent items, same page and `based_on` walk as parent lengths.-/// Each item is passed through [`push_rotation`], so the angle is still its own `xf`.+/// Parent items are only translated onto the page, so the angle is still `item.xf`.fn push_parent_rotations(best: &mut Option<(f64, f64)>,cx: &ToolContext,@@ -351,7 +352,7 @@ fn push_parent_rotation_chain(if parent.pages.len() > 1 && parent.page_at_x(item.bounds().center().x) != Some(page_idx) {continue;}- push_rotation(best, cx.selection, req, item, false, 0, seen_items, proposed, tol);+ push_rotation(best, cx.selection, req, item, Affine::IDENTITY, false, 0, seen_items, proposed, tol);}}let Some(next_id) = next else { return };@@ -364,6 +365,7 @@ fn push_rotation(selection: &Selection,req: &SnapRequest<'_>,item: &Item,+ ancestor: Affine,skipped: bool,depth: usize,seen: &mut HashSet<ItemId>,@@ -373,32 +375,36 @@ fn push_rotation(if depth >= ALIGN_GROUP_DEPTH || !seen.insert(item.id) || item.hidden {return;}+ let abs = ancestor * item.xf;let skip = skipped || align_skips_item(selection, req, item.id);- if !skip && let Some(angle) = own_rotation(item) {+ if !skip && let Some(angle) = rotation_of(abs) {let dist = angular_distance(proposed, angle);if dist.is_finite() && dist <= tol && best.is_none_or(|(have, _)| dist < have) {*best = Some((dist, angle));}}+ if !xf_finite(abs) {+ return;+ }for child in item.children() {- push_rotation(best, selection, req, child, skip, depth + 1, seen, proposed, tol);+ push_rotation(best, selection, req, child, abs, skip, depth + 1, seen, proposed, tol);}}-/// `item.xf` alone. A non-finite transform contributes nothing, and identity contributes 0.-fn own_rotation(item: &Item) -> Option<f64> {- if !xf_finite(item.xf) {+/// Decompose rotation of an absolute transform. A non-finite matrix contributes nothing.+fn rotation_of(xf: Affine) -> Option<f64> {+ if !xf_finite(xf) {return None;}- let rotation = designcraft_geom::decompose::decompose(item.xf).rotation;+ let rotation = designcraft_geom::decompose::decompose(xf).rotation;rotation.is_finite().then_some(rotation)}-/// Decompose rotation of the first selected item, captured before a preview changes `xf`.-/// None when nothing is selected.+/// Decompose rotation of the first selected item's own `xf`, captured before a preview changes it.+/// None when nothing is selected. The command composes onto that `xf`, so ancestors stay out.pub(crate) fn reference_rotation(cx: &ToolContext) -> Option<f64> {let id = *cx.selection.items.first()?;- own_rotation(cx.doc.item(id)?)+ rotation_of(cx.doc.item(id)?.xf)}/// Degrees folded into the range `decompose` reports, `(-180, 180]`.@@ -961,6 +967,38 @@ pub(crate) fn lay_dimension_guides(}}+/// Move a line's dimension tick onto the committed segment.+///+/// The dimensions pass draws a short horizontal tick at the proposed endpoint because the+/// length is carried on x. The guide that remains is the segment from the anchor to the+/// endpoint the gesture commits.+pub(crate) fn lay_line_dimension(guides: &mut Vec<Overlay>, xf: Affine, anchor: Point, proposed: Point, committed: Point, diff: f64) {+ if !diff.is_finite() {+ return;+ }+ let rect = Rect::from_points(proposed, proposed);+ let Some((old_a, old_b)) = dimension_segment(rect, Axis::X, [true, true, true], diff) else { return };+ let (oa, ob) = (xf * old_a, xf * old_b);+ let (na, nb) = (xf * anchor, xf * committed);+ if !point_finite(na) || !point_finite(nb) {+ return;+ }+ let mut found = false;+ for g in guides.iter_mut() {+ if let Overlay::Guide { a, b } = g+ && segment_same(*a, *b, oa, ob)+ {+ *a = na;+ *b = nb;+ found = true;+ break;+ }+ }+ if !found {+ guides.push(Overlay::Guide { a: na, b: nb });+ }+}+fn segment_same(a0: Point, b0: Point, a1: Point, b1: Point) -> bool {let close = |p: Point, q: Point| (p.x - q.x).abs() <= 1e-6 && (p.y - q.y).abs() <= 1e-6;(close(a0, a1) && close(b0, b1)) || (close(a0, b1) && close(b0, a1))@@ -1172,8 +1210,9 @@ const ALIGN_GROUP_DEPTH: usize = 32;/// `align_centers` is on, and only when the request's middle flag is set. Hidden items are/// skipped. Without copying, excluded items are skipped. With copying, that list is the/// drag-start set and stays a target. Live selection items outside that set are preview-/// copies and are skipped. A group with children uses the union of those children's visible-/// bounds in group space, then the group's transform. It does not use the group's own stroke.+/// copies and are skipped. A group with children uses the union of each child's visible bounds+/// after that child's transform, then the group's transform. Transform each child, then union.+/// It does not rotate the local union as one rectangle, and it does not use the group's own stroke./// Parent items are added for a document page that shows them, in document spread space./// A layout built for parent editing already has those items on the spread, so they are not/// added again.@@ -1221,18 +1260,42 @@ fn item_target_rect(selection: &Selection, req: &SnapRequest<'_>, item: &Item) -rect_finite(bounds).then_some(bounds)}-/// Union of children's visible bounds in this group's space, then `item.xf`.+/// Union of each child's visible bounds transformed by `item.xf`.+///+/// Transform each child, then union. Rotating the local union as one rectangle is larger when+/// a rotated group's children do not fill that rectangle. Hidden and excluded children stay out.+/// Nested groups use the same rule. A child's stroke is part of that child's visible bounds.+/// The group's own stroke is not added.fn group_target_rect(selection: &Selection, req: &SnapRequest<'_>, item: &Item, seen: &mut HashSet<ItemId>, depth: usize) -> Option<Rect> {+ group_box(item, seen, depth, Some((selection, req)))+}++/// Visible box of an item being moved. Groups use the same box as alignment, with no exclude list.+pub(crate) fn moving_bounds(item: &Item) -> Option<Rect> {+ if item.is_group() && !item.children().is_empty() {+ let mut seen = HashSet::new();+ return group_box(item, &mut seen, 0, None);+ }+ let bounds = item.visible_bounds();+ rect_finite(bounds).then_some(bounds)+}++fn group_box(item: &Item, seen: &mut HashSet<ItemId>, depth: usize, filter: Option<(&Selection, &SnapRequest<'_>)>) -> Option<Rect> {if depth >= ALIGN_GROUP_DEPTH || !seen.insert(item.id) {return None;}let mut acc: Option<Rect> = None;for child in item.children() {- if child.hidden || align_skips_item(selection, req, child.id) {+ if child.hidden {+ continue;+ }+ if let Some((selection, req)) = filter+ && align_skips_item(selection, req, child.id)+ {continue;}let local = if child.is_group() && !child.children().is_empty() {- group_target_rect(selection, req, child, seen, depth + 1)+ group_box(child, seen, depth + 1, filter)} else {let bounds = child.visible_bounds();rect_finite(bounds).then_some(bounds)@@ -1241,9 +1304,16 @@ fn group_target_rect(selection: &Selection, req: &SnapRequest<'_>, item: &Item,if !rect_finite(local) {continue;}- acc = Some(acc.map_or(local, |have| have.union(local)));+ let placed = item.xf.transform_rect_bbox(local);+ if !rect_finite(placed) {+ continue;+ }+ acc = Some(match acc {+ Some(have) => have.union(placed),+ None => placed,+ });}- acc.map(|r| item.xf.transform_rect_bbox(r)).filter(|r| rect_finite(*r))+ acc.filter(|r| rect_finite(*r))}/// Parent items shown on the document spread, shifted into that spread's space.@@ -1992,4 +2062,80 @@ mod tests {let angle = hit.angle.expect("parent rotation hit");assert!((angle - 30.0).abs() < 1e-6);}++ #[test]+ fn rotated_group_uses_the_per_child_union() {+ // Two children do not fill their local union. Rotating that union as one rectangle+ // swings the empty corners out. The snap target is each child's visible box, transformed, then united.+ let mut doc = Document::new(&NewDocument::default());+ let layer = doc.default_layer();+ let mut child_a = Item::new(ItemId(doc.alloc()), layer, Shape::Rectangle, shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)));+ child_a.stroke = Stroke { weight: 2.0, ..Stroke::default() };+ let child_b = Item::new(ItemId(doc.alloc()), layer, Shape::Rectangle, shapes::rectangle(Rect::new(40.0, 30.0, 50.0, 40.0)));+ let mut group = Item::new(ItemId(doc.alloc()), layer, Shape::Group, designcraft_geom::PathData::default());+ let xf = Affine::translate((300.0, 400.0)) * Affine::rotate((-45.0_f64).to_radians());+ group.xf = xf;+ group.content = designcraft_doc::Content::Group { items: vec![Arc::new(child_a), Arc::new(child_b)] };+ doc.insert_item(SpreadRef::Doc(0), group, None).unwrap();+ let a_vis = Rect::new(-1.0, -1.0, 11.0, 11.0);+ let b_vis = Rect::new(40.0, 30.0, 50.0, 40.0);+ let per_child = xf.transform_rect_bbox(a_vis).union(xf.transform_rect_bbox(b_vis));+ let rotated_union = xf.transform_rect_bbox(a_vis.union(b_vis));+ // At 45 degrees the empty corners move y, not x. The two boxes share x0.+ assert!((per_child.y0 - rotated_union.y0).abs() > 1.0, "fixture does not separate the two boxes");+ let gap = 2.0;+ // A short rect just above the per-child top. Its other edges stay outside the zone of the rotated union.+ let moving = Rect::new(per_child.x0, per_child.y0 - gap - 4.0, per_child.x0 + 20.0, per_child.y0 - gap);+ let cache = Cache::new();+ let layout = CanvasLayout::new(&doc, false);+ let sel = Selection::default();+ let mut cx = ctx_on(&doc, &sel, &cache, &layout);+ cx.snap.snap_to_guides = false;+ cx.snap.snap_to_document_grid = false;+ let hit = snap(&cx, y_req(moving));+ assert!((hit.delta.y - gap).abs() < 1e-4, "delta.y {}, want {gap} onto {}", hit.delta.y, per_child.y0);+ let wrong = rotated_union.y0 - moving.y1;+ assert!((hit.delta.y - wrong).abs() > 1.0, "delta matched the rotated local union");+ }++ #[test]+ fn rotated_group_child_does_not_offer_local_zero() {+ // The group is at 30 degrees. Its child stays at local 0, so the absolute angle is 30.+ // 2 degrees is inside the zone of 0 and far from 30. Local 0 must not win.+ let mut doc = Document::new(&NewDocument::default());+ let layer = doc.default_layer();+ let child = Item::new(ItemId(doc.alloc()), layer, Shape::Rectangle, shapes::rectangle(Rect::new(0.0, 0.0, 40.0, 20.0)));+ let mut group = Item::new(ItemId(doc.alloc()), layer, Shape::Group, designcraft_geom::PathData::default());+ group.xf = Affine::rotate((-30.0_f64).to_radians());+ group.content = designcraft_doc::Content::Group { items: vec![Arc::new(child)] };+ doc.insert_item(SpreadRef::Doc(0), group, None).unwrap();+ let cache = Cache::new();+ let layout = CanvasLayout::new(&doc, false);+ let sel = Selection::default();+ let mut cx = ctx_on(&doc, &sel, &cache, &layout);+ cx.snap.snap_to_guides = false;+ let ask = |angle: f64| {+ snap(+ &cx,+ SnapRequest {+ spread: SpreadRef::Doc(0),+ gesture: Gesture::Rotate,+ rect: Rect::new(100.0, 100.0, 160.0, 140.0),+ x_edges: [false, false, false],+ y_edges: [false, false, false],+ exclude: &[],+ copying: false,+ lengths: [None, None],+ angle: Some(angle),+ radius: 80.0,+ pointer: Point::new(180.0, 120.0),+ },+ )+ };+ let near_zero = ask(2.0);+ assert!(near_zero.angle.is_none(), "local 0 was a target: {:?}", near_zero.angle);+ let near_group = ask(28.0);+ let angle = near_group.angle.expect("absolute 30");+ assert!((angle - 30.0).abs() < 1e-6, "angle {angle}");+ }}diff --git a/crates/tools/src/tests.rs b/crates/tools/src/tests.rsindex b2cb2c314..6c75b0da6 100644--- a/crates/tools/src/tests.rs+++ b/crates/tools/src/tests.rs@@ -2,7 +2,7 @@ use std::sync::Arc;use designcraft_compose::Cache;use designcraft_doc::build::NewDocument;-use designcraft_doc::{Document, Guide, Item, ItemId, Orientation, ParaFormat, Selection, Shape, SpreadRef};+use designcraft_doc::{Document, Guide, Item, ItemId, Orientation, ParaFormat, Selection, Shape, SpreadRef, Stroke};use designcraft_geom::shapes;use designcraft_geom::{Point, Rect, Unit};@@ -399,9 +399,162 @@ fn line_length_keeps_the_crossed_guide() {let end = params["b"].as_array().unwrap();let (bx, by) = (end[0].as_f64().unwrap(), end[1].as_f64().unwrap());let len = 80.0_f64.hypot(40.0);- let expect_x = 180.0 + (92.0 - len);+ let target = 92.0_f64;+ let dy = 142.0 - 100.0;+ // Y stays on the guide. X is solved so the segment length is 92, not by adding the difference to x.+ let remain = target * target - dy * dy;+ let expect_x = 100.0 + remain.sqrt();assert!((by - 142.0).abs() < 1e-4, "endpoint y {by} left the guide at 142 (x {bx})");- assert!((bx - expect_x).abs() < 1e-4, "endpoint x {bx}, want {expect_x} from the length delta on X only");+ assert!((bx - expect_x).abs() < 1e-4, "endpoint x {bx}, want {expect_x}");+ let got = (bx - 100.0).hypot(by - 100.0);+ assert!((got - target).abs() < 1e-4, "length {got}, raw was {len}");+ assert!((bx - (180.0 + (target - len))).abs() > 0.1, "x still took the raw length difference");+}++#[test]+fn stroked_move_aligns_visible_edges() {+ // 2 pt centered strokes. The other path ends at 70, so its visible edge is 71.+ // A geometric move would land the path on 71. The visible edge must land there instead.+ let mut doc = Document::new(&NewDocument::default());+ let layer = doc.default_layer();+ let stroke = Stroke { weight: 2.0, ..Stroke::default() };+ let make = |doc: &mut Document, rect: Rect| {+ let id = ItemId(doc.alloc());+ let mut item = Item::new(id, layer, Shape::Rectangle, shapes::rectangle(rect));+ item.stroke = stroke.clone();+ doc.insert_item(SpreadRef::Doc(0), item, None).unwrap();+ id+ };+ let _other = make(&mut doc, Rect::new(40.0, 100.0, 70.0, 140.0));+ let moving = make(&mut doc, Rect::new(100.0, 100.0, 160.0, 140.0));+ let sel = Selection::items(vec![moving]);+ let cache = Cache::new();+ let layout = CanvasLayout::new(&doc, false);+ let cx = dims_ctx(&doc, &sel, &cache, &layout, true);+ let mut t = create("selection");+ let down = spread_pt(&layout, 130.0, 120.0);+ let drag = spread_pt(&layout, 103.0, 120.0);+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, down.x, down.y));+ let actions = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, drag.x, drag.y));+ let dx = match actions.last() {+ Some(Action::Preview(cmd, p)) => {+ assert_eq!(cmd, "transform.move");+ p["dx"].as_f64().unwrap()+ }+ other => panic!("{other:?}"),+ };+ assert!((dx - -28.0).abs() < 1e-4, "dx {dx}, want -28 so the visible edge meets 71");+}++#[test]+fn vertical_line_length_matches_along_the_segment() {+ // Vertical, length 80, near a 84 side. The match must move y, not add 4 to x.+ let mut doc = Document::new(&NewDocument::default());+ add_rect(&mut doc, Rect::new(400.0, 400.0, 450.0, 484.0));+ let sel = Selection::default();+ let cache = Cache::new();+ let layout = CanvasLayout::new(&doc, false);+ let cx = dims_ctx(&doc, &sel, &cache, &layout, false);+ let mut t = create("line");+ let a = spread_pt(&layout, 100.0, 100.0);+ let b = spread_pt(&layout, 100.0, 180.0);+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, a.x, a.y));+ let actions = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, b.x, b.y));+ let params = actions+ .iter()+ .find_map(|act| match act {+ Action::Preview(cmd, p) if cmd == "line.create" => Some(p),+ _ => None,+ })+ .unwrap();+ let end = params["b"].as_array().unwrap();+ let (bx, by) = (end[0].as_f64().unwrap(), end[1].as_f64().unwrap());+ assert!((bx - 100.0).abs() < 1e-4, "x moved to {bx}");+ assert!((by - 184.0).abs() < 1e-4, "y {by}, want 184");+ let xf = layout.xf(SpreadRef::Doc(0));+ let seg = (xf * Point::new(100.0, 100.0), xf * Point::new(100.0, 184.0));+ let overlays = t.overlays(&cx);+ assert!(guide_matches(&overlays, seg.0, seg.1), "guide is not the segment [{}]", guide_list(&overlays));+}++#[test]+fn shift_frame_stays_square_on_the_driving_guide() {+ // Pointer dx is larger, so x drives. The square's right edge is 3 pt from the guide at 203.+ // Y must follow that snapped size, not stay at the unconstrained square.+ let mut doc = Document::new(&NewDocument::default());+ doc.settings.baseline_grid.increment = 0.0;+ Arc::make_mut(&mut doc.spreads[0]).pages[0].guides.push(Guide {+ orientation: Orientation::Vertical,+ position: 203.0,+ spread: true,+ locked: false,+ layer: None,+ liquid: false,+ });+ let sel = Selection::default();+ let cache = Cache::new();+ let layout = CanvasLayout::new(&doc, false);+ let mut cx = ctx(&doc, &sel, &cache, &layout);+ cx.snap = SnapView::FACTORY;+ cx.snap.snap_to_document_grid = false;+ cx.snap.smart_dimensions = false;+ let mut t = create("rectangle");+ let mods = Mods { shift: true, ..Mods::default() };+ let a = spread_pt(&layout, 120.0, 120.0);+ let b = spread_pt(&layout, 200.0, 150.0);+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, a.x, a.y).with_mods(mods));+ let actions = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, b.x, b.y).with_mods(mods));+ let rect = actions+ .iter()+ .find_map(|act| match act {+ Action::Preview(cmd, p) if cmd == "frame.create" => p["rect"].as_array(),+ _ => None,+ })+ .unwrap();+ let (x0, y0, x1, y1) = (rect[0].as_f64().unwrap(), rect[1].as_f64().unwrap(), rect[2].as_f64().unwrap(), rect[3].as_f64().unwrap());+ assert!((x1 - 203.0).abs() < 1e-4, "driving edge {x1} left the guide");+ assert!((y1 - y0 - (x1 - x0)).abs() < 1e-4, "not square: {x0} {y0} {x1} {y1}");+ assert!((y1 - 203.0).abs() < 1e-4, "other edge {y1} did not follow the snapped size");+}++#[test]+fn drag_onto_the_next_spread_snaps_to_that_guide() {+ // The origin spread has a guide 4 pt from the unsnapped top. The destination guide is 2 pt away.+ // Snapping on the origin would move by 4. Snapping under the pointer moves by 2.+ let mut doc = Document::new(&NewDocument { pages: 2, facing_pages: false, ..NewDocument::default() });+ doc.settings.baseline_grid.increment = 0.0;+ let id = add_rect(&mut doc, Rect::new(100.0, 100.0, 160.0, 140.0));+ let guide = |position: f64| Guide { orientation: Orientation::Horizontal, position, spread: true, locked: false, layer: None, liquid: false };+ Arc::make_mut(&mut doc.spreads[1]).pages[0].guides.push(guide(52.0));+ let sel = Selection::items(vec![id]);+ let cache = Cache::new();+ let layout = CanvasLayout::new(&doc, false);+ assert_eq!(layout.slots.len(), 2);+ let item = Rect::new(100.0, 100.0, 160.0, 140.0);+ let raw_top = 50.0;+ let corner0 = layout.to_canvas(SpreadRef::Doc(0), Point::new(item.x0, item.y0));+ let corner_raw = layout.to_canvas(SpreadRef::Doc(1), Point::new(item.x0, raw_top));+ let travel = designcraft_geom::Vec2::new(corner_raw.x - corner0.x, corner_raw.y - corner0.y);+ let origin_top = item.y0 + layout.delta_to_spread(SpreadRef::Doc(0), travel).y;+ Arc::make_mut(&mut doc.spreads[0]).pages[0].guides.push(guide(origin_top - 4.0));+ let mut cx = ctx(&doc, &sel, &cache, &layout);+ cx.snap = SnapView::FACTORY;+ cx.snap.snap_to_document_grid = false;+ let down = layout.to_canvas(SpreadRef::Doc(0), item.center());+ let drag_at = Point::new(down.x + (corner_raw.x - corner0.x), down.y + (corner_raw.y - corner0.y));+ let mut t = create("selection");+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, down.x, down.y));+ let actions = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, drag_at.x, drag_at.y));+ let params = match actions.last() {+ Some(Action::Preview(cmd, p)) => {+ assert_eq!(cmd, "transform.move");+ p+ }+ other => panic!("{other:?}"),+ };+ let dy = params["dy"].as_f64().unwrap();+ assert_eq!(params["toSpread"], spread_json(SpreadRef::Doc(1)));+ assert!((dy - (52.0 - item.y0)).abs() < 1e-3, "dy {dy}, origin snap would not land on 52");}#[test]