From 7032587238e400bc8f112d47e1ec42ed0605bc90 Mon Sep 17 00:00:00 2001 From: Cameron Gilroy Date: Tue, 6 Oct 2026 00:45:19 +1100 Subject: [PATCH] Snap: document grid and baseline passes --- crates/tools/src/snap.rs | 219 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 215 insertions(+), 4 deletions(-) diff --git a/crates/tools/src/snap.rs b/crates/tools/src/snap.rs index 74b173a35..d5111515a 100644 --- a/crates/tools/src/snap.rs +++ b/crates/tools/src/snap.rs @@ -5,6 +5,7 @@ //! canvas coordinates. [`snap_rect`] is the older closest-target helper. use designcraft_doc::{ItemId, Orientation, SpreadRef}; +use designcraft_geom::snap::snap_to_grid; use designcraft_geom::{Point, Rect}; pub use crate::{Gesture, Snap, SnapRequest, SnapView}; @@ -199,12 +200,141 @@ fn first_on_axis(cx: &ToolContext, req: &SnapRequest<'_>, axis: Axis, tol: f64) .or_else(|| pass_dimensions(cx, req, axis, tol)) } -fn pass_grid(_cx: &ToolContext, _req: &SnapRequest<'_>, _axis: Axis, _tol: f64) -> Option { - None +/// Document grid. No overlay. +/// +/// The interval is the major spacing divided by the subdivision count. A count below 1 counts +/// as 1. `grid.vertical` spaces the vertical lines (x). `grid.horizontal` spaces the horizontal +/// lines (y). A spacing of 0 or less skips that axis. The origin is the page-bounds origin of +/// the page under the rect center. Whether the grid is shown is not read. +fn pass_grid(cx: &ToolContext, req: &SnapRequest<'_>, axis: Axis, tol: f64) -> Option { + if !cx.snap.snap_to_document_grid { + return None; + } + let spacing = grid_interval(cx, axis)?; + let origin = grid_origin(cx, req, axis)?; + let mut best: Option = None; + offer_enabled(&mut best, req.rect, axis_flags(req, axis), axis, tol, |v| Some(snap_to_grid(v, spacing, origin))); + best.map(|b| b.hit) } -fn pass_baseline(_cx: &ToolContext, _req: &SnapRequest<'_>, _axis: Axis, _tol: f64) -> Option { - None +/// Major spacing divided by the subdivision count. Non-finite or non-positive spacing is no hit. +fn grid_interval(cx: &ToolContext, axis: Axis) -> Option { + let grid = &cx.doc.settings.grid; + let major = match axis { + Axis::X => grid.vertical, + Axis::Y => grid.horizontal, + }; + if !major.is_finite() || major <= 0.0 { + return None; + } + let interval = major / f64::from(grid.subdivisions.max(1)); + (interval.is_finite() && interval > 0.0).then_some(interval) +} + +/// Page-bounds origin on `axis` for the page under the rect center. +fn grid_origin(cx: &ToolContext, req: &SnapRequest<'_>, axis: Axis) -> Option { + let spread = cx.doc.spread(req.spread)?; + let bounds = spread.pages.get(spread.page_at_x(req.rect.center().x)?)?.bounds(); + let origin = match axis { + Axis::X => bounds.x0, + Axis::Y => bounds.y0, + }; + origin.is_finite().then_some(origin) +} + +/// Baseline grid. No overlay. +/// +/// Lines are `page.y0 + start + n * increment` for n >= 0 while the line is inside the page +/// (the bottom edge is not a line, matching the canvas). An increment of 0 or less skips the +/// pass. `relative_to` and `view_threshold` are not read, and hiding the baseline grid does not +/// turn this off. Only a page the rect crosses on x contributes. +fn pass_baseline(cx: &ToolContext, req: &SnapRequest<'_>, axis: Axis, tol: f64) -> Option { + if !matches!(axis, Axis::Y) || !cx.snap.snap_to_guides { + return None; + } + let baseline = &cx.doc.settings.baseline_grid; + let increment = baseline.increment; + if !increment.is_finite() || increment <= 0.0 || !baseline.start.is_finite() { + return None; + } + let spread = cx.doc.spread(req.spread)?; + let flags = axis_flags(req, axis); + let (moving_lo, moving_hi) = perp_ends(req.rect, axis); + let mut best: Option = None; + for page in &spread.pages { + let bounds = page.bounds(); + let (lo, hi) = perp_ends(bounds, axis); + if !ranges_overlap(moving_lo, moving_hi, lo, hi) { + continue; + } + let origin = bounds.y0 + baseline.start; + offer_enabled(&mut best, req.rect, flags, axis, tol, |v| nearest_baseline(v, origin, increment, bounds.y0, bounds.y1)); + } + best.map(|b| b.hit) +} + +/// Nearest baseline at or after `origin`, strictly inside `[y0, y1)`. +fn nearest_baseline(v: f64, origin: f64, increment: f64, y0: f64, y1: f64) -> Option { + let (n_min, n_max) = baseline_n_range(origin, increment, y0, y1)?; + let snapped = snap_to_grid(v, increment, origin); + if baseline_line_ok(snapped, origin, increment, y0, y1) { + return Some(snapped); + } + let n = ((snapped - origin) / increment).round(); + if !n.is_finite() { + return None; + } + let n = if n < n_min { + n_min + } else if n > n_max { + n_max + } else { + n + }; + let line = origin + n * increment; + baseline_line_ok(line, origin, increment, y0, y1).then_some(line) +} + +fn baseline_n_range(origin: f64, increment: f64, y0: f64, y1: f64) -> Option<(f64, f64)> { + if !origin.is_finite() || !increment.is_finite() || increment <= 0.0 || !y0.is_finite() || !y1.is_finite() || y0 >= y1 { + return None; + } + let mut n_min = if origin < y0 { ((y0 - origin) / increment).ceil() } else { 0.0 }; + if !n_min.is_finite() || n_min < 0.0 { + return None; + } + if origin + n_min * increment < y0 { + n_min += 1.0; + } + let mut n_max = ((y1 - origin) / increment).floor(); + if !n_max.is_finite() { + return None; + } + if origin + n_max * increment >= y1 { + n_max -= 1.0; + } + (n_max >= n_min).then_some((n_min, n_max)) +} + +fn baseline_line_ok(line: f64, origin: f64, increment: f64, y0: f64, y1: f64) -> bool { + if !line.is_finite() || !increment.is_finite() || increment <= 0.0 || line < y0 || line >= y1 { + return false; + } + let n = ((line - origin) / increment).round(); + n.is_finite() && n >= 0.0 +} + +/// Each edge whose flag is set, against its own target. Nothing is drawn. +fn offer_enabled(best: &mut Option, moving: Rect, flags: [bool; 3], axis: Axis, tol: f64, mut target_at: impl FnMut(f64) -> Option) { + let (left, mid, right) = axis_triple(moving, axis); + let [use_left, use_mid, use_right] = flags; + for (on, v) in [(use_left, left), (use_mid, mid), (use_right, right)] { + if !on { + continue; + } + let Some(target) = target_at(v) else { continue }; + offer(best, v, target, tol, None); + } } fn pass_spacing(_cx: &ToolContext, _req: &SnapRequest<'_>, _axis: Axis, _tol: f64) -> Option { @@ -442,6 +572,38 @@ mod tests { ToolContext { doc, selection: sel, cache, layout, zoom: 1.0, layer: doc.default_layer(), snap: SnapView::FACTORY, unit: Unit::Points } } + fn y_req(rect: Rect) -> SnapRequest<'static> { + SnapRequest { + spread: SpreadRef::Doc(0), + gesture: Gesture::Move, + rect, + x_edges: [false, false, false], + y_edges: [true, true, true], + exclude: &[], + copying: false, + lengths: [None, None], + angle: None, + radius: 0.0, + pointer: Point::new(0.0, 0.0), + } + } + + fn move_req<'a>(rect: Rect, exclude: &'a [ItemId]) -> SnapRequest<'a> { + SnapRequest { + spread: SpreadRef::Doc(0), + gesture: Gesture::Move, + rect, + x_edges: [true, true, true], + y_edges: [false, false, false], + exclude, + copying: false, + lengths: [None, None], + angle: None, + radius: 0.0, + pointer: Point::new(0.0, 0.0), + } + } + #[test] fn guide_beats_a_closer_object_edge() { // Right edge at 100.5. Object edge at 100 (0.5 away). Guide at 104 (3.5 away). Zone is 4. @@ -594,4 +756,53 @@ mod tests { ); assert!((hit.delta.x - -1.0).abs() < 1e-6, "delta.x = {}", hit.delta.x); } + + #[test] + fn grid_beats_a_closer_guide() { + let mut doc = Document::new(&NewDocument::default()); + doc.settings.grid.horizontal = 72.0; + doc.settings.grid.vertical = 72.0; + doc.settings.grid.subdivisions = 8; // 9 pt + let layer = doc.default_layer(); + let id = ItemId(doc.alloc()); + let item = Item::new(id, layer, Shape::Rectangle, shapes::rectangle(Rect::new(10.0, 10.0, 40.0, 40.0))); + doc.insert_item(SpreadRef::Doc(0), item, None).unwrap(); + // Guide 1 pt away at x = 11. Subdivision line at 9 is 1 pt the other way. Grid must win. + Arc::make_mut(&mut doc.spreads[0]).pages[0].guides.push(Guide { + orientation: Orientation::Vertical, + position: 11.0, + spread: true, + locked: false, + layer: None, + liquid: false, + }); + 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_document_grid = true; + let hit = snap(&cx, move_req(Rect::new(10.0, 10.0, 40.0, 40.0), &[id])); + assert!((hit.delta.x - -1.0).abs() < 1e-6); + assert!(hit.guides.is_empty()); + } + + #[test] + fn hidden_baseline_still_snaps_and_zero_increment_does_not() { + let mut doc = Document::new(&NewDocument::default()); + doc.settings.baseline_grid.start = 36.0; + doc.settings.baseline_grid.increment = 12.0; + let cache = Cache::new(); + let layout = CanvasLayout::new(&doc, false); + let sel = Selection::default(); + let cx = ctx_on(&doc, &sel, &cache, &layout); + // Top at 49 wants the line at 48 (start 36, increment 12). The margin at 36 is 13 pt away. + let hit = snap(&cx, y_req(Rect::new(100.0, 49.0, 140.0, 80.0))); + assert!((hit.delta.y - -1.0).abs() < 1e-6); + let mut dead = doc.clone(); + dead.settings.baseline_grid.increment = 0.0; + let layout = CanvasLayout::new(&dead, false); + let cx = ctx_on(&dead, &sel, &cache, &layout); + let hit = snap(&cx, y_req(Rect::new(100.0, 49.0, 140.0, 80.0))); + assert_eq!(hit.delta.y, 0.0); + } }