DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
Snap: dimension guides follow the final edge
Cameron Gilroy8e7cff341fad
diff --git a/crates/tools/src/frame.rs b/crates/tools/src/frame.rsindex 0e913eccf..b7e94412b 100644--- a/crates/tools/src/frame.rs+++ b/crates/tools/src/frame.rs@@ -170,23 +170,12 @@ impl Tool for FrameTool {pointer: b,},);- if hit.length_delta[1].is_none() {- b.y += hit.delta.y;- }- if hit.length_delta[0].is_none() {+ // 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 let Some(diff) = hit.length_delta[0]- && diff.is_finite()- {- let v = b - sa;- let cur = v.hypot();- if cur > 1e-9 {- let next = cur + diff;- if next.is_finite() {- b = sa + v * (next / cur);- }- }+ if hit.delta.y.is_finite() {+ b.y += hit.delta.y;}self.guides = hit.guides;}diff --git a/crates/tools/src/select.rs b/crates/tools/src/select.rsindex d00a8d94b..77baa8bdb 100644--- a/crates/tools/src/select.rs+++ b/crates/tools/src/select.rs@@ -198,6 +198,77 @@ fn apply_aspect(from: Rect, handle: usize, rect: Rect, s: f64) -> Rect {Rect::new(x0, y0, x1, y1)}+/// Snap changes the size. Shift then restores the aspect, and Alt places that size on the original center.+///+/// Nudging one edge of an already centered rect walks the center. Mirroring that nudge doubles a length match.+fn finish_snapped_resize(+ from: Rect,+ handle: usize,+ proposed: Rect,+ mods: Mods,+ driver_x: bool,+ x_edges: [bool; 3],+ y_edges: [bool; 3],+ hit: &crate::Snap,+) -> Rect {+ if !mods.alt {+ let mut to = crate::snap::nudge_edges(proposed, x_edges, y_edges, hit.delta);+ if mods.shift && from.width() > 1e-9 && from.height() > 1e-9 {+ let s = if driver_x { (to.x1 - to.x0) / from.width() } else { (to.y1 - to.y0) / from.height() };+ if s.is_finite() {+ to = apply_aspect(from, handle, to, s);+ }+ }+ return to;+ }+ let mut w = proposed.x1 - proposed.x0;+ let mut h = proposed.y1 - proposed.y0;+ w += centered_size_delta(x_edges, hit.delta.x, hit.length_delta[0]);+ h += centered_size_delta(y_edges, hit.delta.y, hit.length_delta[1]);+ if mods.shift && from.width() > 1e-9 && from.height() > 1e-9 {+ if driver_x {+ let s = w / from.width();+ if s.is_finite() {+ h = from.height() * s;+ }+ } else {+ let s = h / from.height();+ if s.is_finite() {+ w = from.width() * s;+ }+ }+ }+ if !(w.is_finite() && h.is_finite()) {+ return proposed;+ }+ let c = from.center();+ Rect::new(c.x - w / 2.0, c.y - h / 2.0, c.x + w / 2.0, c.y + h / 2.0)+}++/// Length match: add the difference once. Position match: the flagged edge moves and the other side mirrors.+fn centered_size_delta(edges: [bool; 3], delta: f64, length_delta: Option<f64>) -> f64 {+ if let Some(diff) = length_delta.filter(|d| d.is_finite()) {+ return diff;+ }+ let edge = axis_size_delta(edges, delta);+ if edge.is_finite() { edge * 2.0 } else { 0.0 }+}++/// Signed change in `hi - lo` when one flagged edge moves by `delta`.+fn axis_size_delta(edges: [bool; 3], delta: f64) -> f64 {+ if !delta.is_finite() {+ return 0.0;+ }+ let [low_edge, _, high_edge] = edges;+ if high_edge && !low_edge {+ delta+ } else if low_edge && !high_edge {+ -delta+ } else {+ 0.0+ }+}+fn apply_alt(from: Rect, handle: usize, rect: Rect) -> Rect {let (x0, y0, x1, y1) = (rect.x0, rect.y0, rect.x1, rect.y1);let c = from.center();@@ -424,29 +495,25 @@ impl Tool for SelectionTool {}let exclude = cx.selection.items.clone();let (pad_x, pad_y) = single_stroke_pad(cx);- let hit = crate::snap::snap(+ let proposed = to;+ let mut hit = crate::snap::snap(cx,SnapRequest {spread,gesture: Gesture::Resize,- rect: to,+ rect: proposed,x_edges,y_edges,exclude: &exclude,copying: false,- lengths: [axis_length(x_edges, to.width(), pad_x), axis_length(y_edges, to.height(), pad_y)],+ lengths: [axis_length(x_edges, proposed.width(), pad_x), axis_length(y_edges, proposed.height(), pad_y)],angle: None,radius: 0.0,pointer,},);- to = crate::snap::nudge_edges(to, x_edges, y_edges, hit.delta);- if ev.mods.shift && !ev.mods.alt && from.width() > 1e-9 && from.height() > 1e-9 {- let s = if driver_x { (to.x1 - to.x0) / from.width() } else { (to.y1 - to.y0) / from.height() };- if s.is_finite() {- to = apply_aspect(from, handle, to, s);- }- }+ to = finish_snapped_resize(from, handle, proposed, ev.mods, driver_x, x_edges, y_edges, &hit);+ crate::snap::lay_dimension_guides(&mut hit.guides, cx.layout.xf(spread), proposed, to, x_edges, y_edges, hit.length_delta);self.guides = hit.guides;}vec![Action::Preview(diff --git a/crates/tools/src/snap.rs b/crates/tools/src/snap.rsindex 3f962de78..41d12db4a 100644--- a/crates/tools/src/snap.rs+++ b/crates/tools/src/snap.rs@@ -8,7 +8,7 @@ use std::collections::HashSet;use designcraft_doc::{Item, ItemId, Orientation, PageSide, Selection, SpreadId, SpreadRef, StrokeAlign};use designcraft_geom::snap::snap_to_grid;-use designcraft_geom::{Point, Rect, Vec2, format_measure};+use designcraft_geom::{Affine, Point, Rect, Vec2, format_measure};pub use crate::{Gesture, Snap, SnapRequest, SnapView};@@ -384,10 +384,11 @@ fn pass_spacing(_cx: &ToolContext, _req: &SnapRequest<'_>, _axis: Axis, _tol: f6/// Other items' own side lengths, on resize and create.////// Own size is the path box in item space, inflated the way [`Item::visible_bounds`] inflates,-/// then multiplied by the absolute scale (ancestors included, rotation dropped). Width and height-/// are both candidates for whichever length is set. The closest length inside the zone wins.-/// Delta is the length difference applied from the moving edge. A rotated rectangle contributes-/// its side lengths, not the axis-aligned box.+/// then scaled by the absolute transform. That transform is the parent chain composed with the+/// item and decomposed once, so a rotated child inside a non-uniform group keeps the spread-space+/// sides. Rotation is dropped. Width and height are both candidates for whichever length is set.+/// The closest length inside the zone wins. Delta is the length difference applied from the moving+/// edge. A rotated rectangle contributes its side lengths, not the axis-aligned box.fn pass_dimensions(cx: &ToolContext, req: &SnapRequest<'_>, axis: Axis, tol: f64) -> Option<AxisHit> {if !matches!(req.gesture, Gesture::Resize | Gesture::Create) || !cx.snap.smart_guides || !cx.snap.smart_dimensions {return None;@@ -441,8 +442,15 @@ fn length_edge_delta(flags: [bool; 3], diff: f64) -> f64 {/// Guide along the side whose length matched, after the edge has moved.fn dimension_mark(req: &SnapRequest<'_>, axis: Axis, diff: f64, text: String) -> DimMark {- let rect = req.rect;- let flags = axis_flags(req, axis);+ let (a, b) = dimension_segment(req.rect, axis, axis_flags(req, axis), diff).unwrap_or((Point::ORIGIN, Point::ORIGIN));+ DimMark { a, b, text }+}++/// Spread-space segment along the matched side. `diff` 0 is the side of `rect` itself.+fn dimension_segment(rect: Rect, axis: Axis, flags: [bool; 3], diff: f64) -> Option<(Point, Point)> {+ if !diff.is_finite() || !rect_finite(rect) {+ return None;+ }let (a, b) = match axis {Axis::X => {let (x0, x1) = grown_span(rect.x0, rect.x1, flags, diff);@@ -455,7 +463,59 @@ fn dimension_mark(req: &SnapRequest<'_>, axis: Axis, diff: f64, text: String) ->(Point::new(x, y0), Point::new(x, y1))}};- DimMark { a, b, text }+ (point_finite(a) && point_finite(b)).then_some((a, b))+}++fn point_finite(p: Point) -> bool {+ p.x.is_finite() && p.y.is_finite()+}++/// Move dimension guides onto the rect the gesture commits.+///+/// Snap draws the guide on `pre` plus the length difference along the flagged edge. Aspect re-lock+/// and a centered scale move that side afterwards. The guide then follows the committed side.+pub(crate) fn lay_dimension_guides(+ guides: &mut Vec<Overlay>,+ xf: Affine,+ pre: Rect,+ committed: Rect,+ x_edges: [bool; 3],+ y_edges: [bool; 3],+ length_delta: [Option<f64>; 2],+) {+ if !rect_finite(committed) {+ return;+ }+ let axes = [(Axis::X, x_edges, length_delta[0]), (Axis::Y, y_edges, length_delta[1])];+ for (axis, edges, diff) in axes {+ let Some(diff) = diff else { continue };+ let Some((old_a, old_b)) = dimension_segment(pre, axis, edges, diff) else { continue };+ let Some((new_a, new_b)) = dimension_segment(committed, axis, edges, 0.0) else { continue };+ let (oa, ob) = (xf * old_a, xf * old_b);+ let (na, nb) = (xf * new_a, xf * new_b);+ if !point_finite(na) || !point_finite(nb) {+ continue;+ }+ 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))}fn grown_span(a0: f64, a1: f64, flags: [bool; 3], diff: f64) -> (f64, f64) {@@ -477,7 +537,7 @@ fn dimension_lengths(cx: &ToolContext, req: &SnapRequest<'_>) -> Vec<f64> {let mut seen = HashSet::new();if let Some(sp) = cx.doc.spread(req.spread) {for item in &sp.items {- push_own_lengths(&mut out, cx.selection, req, item, 1.0, 1.0, false, 0, &mut seen);+ push_own_lengths(&mut out, cx.selection, req, item, Affine::IDENTITY, false, 0, &mut seen);}}if !layout_edits_parents(cx) {@@ -491,8 +551,7 @@ fn push_own_lengths(selection: &Selection,req: &SnapRequest<'_>,item: &Item,- ancestor_sx: f64,- ancestor_sy: f64,+ ancestor: Affine,skipped: bool,depth: usize,seen: &mut HashSet<ItemId>,@@ -500,29 +559,32 @@ fn push_own_lengths(if depth >= ALIGN_GROUP_DEPTH || !seen.insert(item.id) || item.hidden {return;}+ let abs = ancestor * item.xf;+ if !xf_finite(abs) {+ return;+ }let skip = skipped || align_skips_item(selection, req, item.id);if item.is_group() && !item.children().is_empty() {- let decomposed = designcraft_geom::decompose::decompose(item.xf);- let sx = ancestor_sx * decomposed.scale_x.abs();- let sy = ancestor_sy * decomposed.scale_y.abs();- if !sx.is_finite() || !sy.is_finite() {- return;- }for child in item.children() {- push_own_lengths(out, selection, req, child, sx, sy, skip, depth + 1, seen);+ push_own_lengths(out, selection, req, child, abs, skip, depth + 1, seen);}return;}if skip {return;}- let Some((w, h)) = leaf_own_size(item, ancestor_sx, ancestor_sy) else { return };+ let Some((w, h)) = leaf_own_size(item, abs) else { return };out.push(w);out.push(h);}-/// Path bounds in item space, stroke outset, then absolute scale. Rotation is not applied.-fn leaf_own_size(item: &Item, ancestor_sx: f64, ancestor_sy: f64) -> Option<(f64, f64)> {+fn xf_finite(m: Affine) -> bool {+ m.as_coeffs().iter().all(|c| c.is_finite())+}++/// Path bounds in item space, stroke outset, then one decompose of the absolute transform.+/// Rotation is not applied to the side lengths.+fn leaf_own_size(item: &Item, abs: Affine) -> Option<(f64, f64)> {let local = item.path.bounds()?;if !rect_finite(local) {return None;@@ -535,9 +597,9 @@ fn leaf_own_size(item: &Item, ancestor_sx: f64, ancestor_sy: f64) -> Option<(f64if !rect_finite(local) {return None;}- let decomposed = designcraft_geom::decompose::decompose(item.xf);- let sx = ancestor_sx * decomposed.scale_x.abs();- let sy = ancestor_sy * decomposed.scale_y.abs();+ let decomposed = designcraft_geom::decompose::decompose(abs);+ let sx = decomposed.scale_x.abs();+ let sy = decomposed.scale_y.abs();if !sx.is_finite() || !sy.is_finite() {return None;}@@ -601,7 +663,7 @@ fn push_parent_length_chain(if parent.pages.len() > 1 && parent.page_at_x(item.bounds().center().x) != Some(page_idx) {continue;}- push_own_lengths(out, cx.selection, req, item, 1.0, 1.0, false, 0, seen_items);+ push_own_lengths(out, cx.selection, req, item, Affine::IDENTITY, false, 0, seen_items);}}let Some(next_id) = next else { return };@@ -1278,4 +1340,46 @@ mod tests {assert!((hit.delta.x - 3.0).abs() < 1e-6);assert!(matches!(hit.guides.last(), Some(Overlay::Measure { text, .. }) if text.contains("200")));}++ #[test]+ fn grouped_child_matches_spread_side() {+ // Group scale 2 on X and 1 on Y. Child rotated -90 degrees (decompose reports +90).+ // Spread-space sides are local width times 1 (100) and local height times 2 (80).+ // 82 is 2 pt from 80 and far from 200, which is what per-node scales would offer.+ let mut doc = Document::new(&NewDocument::default());+ let layer = doc.default_layer();+ let child_id = ItemId(doc.alloc());+ let mut child = Item::new(child_id, layer, Shape::Rectangle, shapes::rectangle(Rect::new(0.0, 0.0, 100.0, 40.0)));+ child.xf = Affine::rotate((-90.0_f64).to_radians());+ let group_id = ItemId(doc.alloc());+ let mut group = Item::new(group_id, layer, Shape::Group, designcraft_geom::PathData::default());+ group.xf = Affine::scale_non_uniform(2.0, 1.0);+ group.content = designcraft_doc::Content::Group { items: vec![std::sync::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;+ cx.snap.snap_to_document_grid = false;+ cx.snap.align_edges = false;+ cx.snap.align_centers = false;+ let hit = snap(+ &cx,+ SnapRequest {+ spread: SpreadRef::Doc(0),+ gesture: Gesture::Resize,+ rect: Rect::new(200.0, 200.0, 282.0, 240.0),+ x_edges: [false, false, true],+ y_edges: [false, false, false],+ exclude: &[],+ copying: false,+ lengths: [Some(82.0), None],+ angle: None,+ radius: 0.0,+ pointer: Point::new(282.0, 220.0),+ },+ );+ assert!((hit.delta.x - -2.0).abs() < 1e-6, "delta.x = {}, want -2 toward local height times 2", hit.delta.x);+ }}diff --git a/crates/tools/src/tests.rs b/crates/tools/src/tests.rsindex c47595fc5..dcbf815d1 100644--- a/crates/tools/src/tests.rs+++ b/crates/tools/src/tests.rs@@ -1,7 +1,8 @@use designcraft_compose::Cache;use designcraft_doc::build::NewDocument;-use designcraft_doc::{Document, ParaFormat, Selection, SpreadRef};-use designcraft_geom::{Rect, Unit};+use designcraft_doc::{Document, Item, ItemId, ParaFormat, Selection, Shape, SpreadRef};+use designcraft_geom::shapes;+use designcraft_geom::{Point, Rect, Unit};use super::*;@@ -292,3 +293,191 @@ fn turned_spread_maps_points_both_ways() {let dv = slot.delta_to_spread(designcraft_geom::Vec2::new(10.0, 0.0));assert!(dv.x.abs() < 1e-9 && (dv.y + 10.0).abs() < 1e-9 || (dv.y - 10.0).abs() < 1e-9, "{dv:?}");}++fn add_rect(doc: &mut Document, rect: Rect) -> ItemId {+ let layer = doc.default_layer();+ let id = ItemId(doc.alloc());+ let item = Item::new(id, layer, Shape::Rectangle, shapes::rectangle(rect));+ doc.insert_item(SpreadRef::Doc(0), item, None).unwrap();+ id+}++/// Dimensions on, ruler guides and the document grid off. Alignment is optional.+fn dims_ctx<'a>(d: &'a Document, s: &'a Selection, c: &'a Cache, l: &'a CanvasLayout, align: bool) -> ToolContext<'a> {+ let mut cx = ctx(d, s, c, l);+ cx.snap = SnapView::FACTORY;+ cx.snap.snap_to_guides = false;+ cx.snap.snap_to_document_grid = false;+ cx.snap.align_edges = align;+ cx.snap.align_centers = align;+ cx+}++fn spread_pt(l: &CanvasLayout, x: f64, y: f64) -> Point {+ l.to_canvas(SpreadRef::Doc(0), Point::new(x, y))+}++fn near(a: Point, b: Point) -> bool {+ (a.x - b.x).abs() < 1e-4 && (a.y - b.y).abs() < 1e-4+}++fn guide_matches(overlays: &[Overlay], a: Point, b: Point) -> bool {+ overlays.iter().any(|o| match o {+ Overlay::Guide { a: ga, b: gb } => (near(*ga, a) && near(*gb, b)) || (near(*ga, b) && near(*gb, a)),+ _ => false,+ })+}++fn guide_list(overlays: &[Overlay]) -> String {+ overlays+ .iter()+ .filter_map(|o| match o {+ Overlay::Guide { a, b } => Some(format!("({:.4},{:.4})-({:.4},{:.4})", a.x, a.y, b.x, b.y)),+ _ => None,+ })+ .collect::<Vec<_>>()+ .join("; ")+}++#[test]+fn shift_alt_resize_keeps_aspect_and_center() {+ // 100 by 50, center (150, 125), aspect 2. Corner handle, Shift and Alt.+ // The centered width is 160. Another item's side is 163, inside the zone.+ let mut doc = Document::new(&NewDocument::default());+ let moving = add_rect(&mut doc, Rect::new(100.0, 100.0, 200.0, 150.0));+ add_rect(&mut doc, Rect::new(400.0, 400.0, 563.0, 430.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, false);+ let mut t = create("selection");+ let mods = Mods { shift: true, alt: true, ..Mods::default() };+ let down = spread_pt(&layout, 200.0, 150.0);+ let drag = spread_pt(&layout, 230.0, 155.0);+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, down.x, down.y).with_mods(mods));+ let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, drag.x, drag.y).with_mods(mods));+ let params = match &a[..] {+ [Action::Preview(cmd, p)] => {+ assert_eq!(cmd, "transform.resize");+ p+ }+ other => panic!("{other:?}"),+ };+ let to = params["to"].as_array().unwrap();+ let (x0, y0, x1, y1) = (to[0].as_f64().unwrap(), to[1].as_f64().unwrap(), to[2].as_f64().unwrap(), to[3].as_f64().unwrap());+ let (w, h) = (x1 - x0, y1 - y0);+ let (cx0, cy0) = ((x0 + x1) / 2.0, (y0 + y1) / 2.0);+ assert!((cx0 - 150.0).abs() < 1e-4 && (cy0 - 125.0).abs() < 1e-4, "center walked to ({cx0}, {cy0}) rect {to:?}");+ assert!((w / h - 2.0).abs() < 1e-4, "aspect {} rect {to:?}", w / h);+ assert!((w - 163.0).abs() < 1e-4, "driving length {w}, want the matched 163, not twice the correction");+}++#[test]+fn line_length_keeps_the_crossed_guide() {+ // Diagonal from (100, 100) to (180, 140). Length is about 89.44, near a 92 side.+ // Endpoint y is 2 pt from the other item's top, so Y is a position snap and X is the length.+ let mut doc = Document::new(&NewDocument::default());+ add_rect(&mut doc, Rect::new(400.0, 142.0, 492.0, 180.0));+ let sel = Selection::default();+ let cache = Cache::new();+ let layout = CanvasLayout::new(&doc, false);+ let cx = dims_ctx(&doc, &sel, &cache, &layout, true);+ let mut t = create("line");+ let a = spread_pt(&layout, 100.0, 100.0);+ let b = spread_pt(&layout, 180.0, 140.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());+ let len = 80.0_f64.hypot(40.0);+ let expect_x = 180.0 + (92.0 - len);+ 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");+}++#[test]+fn dimension_guide_lies_on_the_committed_side() {+ let mut problems = Vec::new();++ // Centered scale. Width 120 grows to the matched 123, so each side moves 1.5, not 3.+ let mut doc = Document::new(&NewDocument::default());+ let moving = add_rect(&mut doc, Rect::new(100.0, 100.0, 200.0, 160.0));+ add_rect(&mut doc, Rect::new(400.0, 400.0, 523.0, 440.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, false);+ let mut t = create("scale");+ let center = spread_pt(&layout, 150.0, 130.0);+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, center.x + 50.0, center.y + 30.0));+ let drag = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, center.x + 60.0, center.y + 40.0));+ let (sx, sy) = match &drag[..] {+ [Action::Preview(cmd, p)] => {+ assert_eq!(cmd, "transform.scale");+ (p["sx"].as_f64().unwrap(), p["sy"].as_f64().unwrap())+ }+ other => panic!("{other:?}"),+ };+ let committed = Rect::new(150.0 - 50.0 * sx.abs(), 130.0 - 30.0 * sy.abs(), 150.0 + 50.0 * sx.abs(), 130.0 + 30.0 * sy.abs());+ let xf = layout.xf(SpreadRef::Doc(0));+ let bottom = (xf * Point::new(committed.x0, committed.y1), xf * Point::new(committed.x1, committed.y1));+ let overlays = t.overlays(&cx);+ let scale_guides = overlays.iter().filter(|o| matches!(o, Overlay::Guide { .. })).count();+ if scale_guides != 1 || !guide_matches(&overlays, bottom.0, bottom.1) {+ problems.push(format!(+ "scale guide is not on the committed bottom ({:.4},{:.4})-({:.4},{:.4}), sx {sx} sy {sy}, {scale_guides} guides [{}]",+ bottom.0.x,+ bottom.0.y,+ bottom.1.x,+ bottom.1.y,+ guide_list(&overlays)+ ));+ }++ // Shift resize. Width snaps 130 to 133, then the height follows the aspect and the bottom moves.+ let mut doc = Document::new(&NewDocument::default());+ let moving = add_rect(&mut doc, Rect::new(100.0, 100.0, 200.0, 150.0));+ add_rect(&mut doc, Rect::new(400.0, 400.0, 533.0, 430.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, false);+ let mut t = create("selection");+ let mods = Mods { shift: true, ..Mods::default() };+ let down = spread_pt(&layout, 200.0, 150.0);+ let drag_at = spread_pt(&layout, 230.0, 155.0);+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, down.x, down.y));+ let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, drag_at.x, drag_at.y).with_mods(mods));+ let to = match &a[..] {+ [Action::Preview(cmd, p)] => {+ assert_eq!(cmd, "transform.resize");+ p["to"].as_array().unwrap()+ }+ other => panic!("{other:?}"),+ };+ let rect = Rect::new(to[0].as_f64().unwrap(), to[1].as_f64().unwrap(), to[2].as_f64().unwrap(), to[3].as_f64().unwrap());+ let xf = layout.xf(SpreadRef::Doc(0));+ let y = rect.y0.max(rect.y1);+ let (x0, x1) = (rect.x0.min(rect.x1), rect.x0.max(rect.x1));+ let side = (xf * Point::new(x0, y), xf * Point::new(x1, y));+ let overlays = t.overlays(&cx);+ let shift_guides = overlays.iter().filter(|o| matches!(o, Overlay::Guide { .. })).count();+ if shift_guides != 1 || !guide_matches(&overlays, side.0, side.1) {+ problems.push(format!(+ "shift guide is not on the committed side ({:.4},{:.4})-({:.4},{:.4}), rect {to:?}, {shift_guides} guides [{}]",+ side.0.x,+ side.0.y,+ side.1.x,+ side.1.y,+ guide_list(&overlays)+ ));+ }+ assert!(problems.is_empty(), "{}", problems.join(" | "));+}diff --git a/crates/tools/src/xform.rs b/crates/tools/src/xform.rsindex bb9e01000..24f89937f 100644--- a/crates/tools/src/xform.rs+++ b/crates/tools/src/xform.rs@@ -98,18 +98,18 @@ impl Tool for XformTool {if w0 > 1e-9 && h0 > 1e-9 {let center = from.center();let (mut w, mut h) = (w0 * sx.abs(), h0 * sy.abs());- let to = Rect::new(center.x - w / 2.0, center.y - h / 2.0, center.x + w / 2.0, center.y + h / 2.0);+ let pre = Rect::new(center.x - w / 2.0, center.y - h / 2.0, center.x + w / 2.0, center.y + h / 2.0);let pointer = cx.layout.to_spread(spread, ev.pos);let x_edges = if x_drives { edge_toward(pointer.x, center.x) } else { [false, false, false] };let y_edges = if x_drives && ev.mods.shift { [false, false, false] } else { edge_toward(pointer.y, center.y) };let exclude = cx.selection.items.clone();let (pad_x, pad_y) = scale_stroke_pad(cx);- let hit = crate::snap::snap(+ let mut hit = crate::snap::snap(cx,SnapRequest {spread,gesture: Gesture::Resize,- rect: to,+ rect: pre,x_edges,y_edges,exclude: &exclude,@@ -141,9 +141,21 @@ impl Tool for XformTool {w = w0 * (h / h0);}}- if w.is_finite() && h.is_finite() && w.abs() > 1e-9 && h.abs() > 1e-9 {- sx = (w / w0) * sign_x;- sy = (h / h0) * sign_y;+ if w.is_finite() && h.is_finite() {+ let committed = Rect::new(center.x - w / 2.0, center.y - h / 2.0, center.x + w / 2.0, center.y + h / 2.0);+ crate::snap::lay_dimension_guides(+ &mut hit.guides,+ cx.layout.xf(spread),+ pre,+ committed,+ x_edges,+ y_edges,+ hit.length_delta,+ );+ if w.abs() > 1e-9 && h.abs() > 1e-9 {+ sx = (w / w0) * sign_x;+ sy = (h / h0) * sign_y;+ }}self.guides = hit.guides;}