Skip to content

DesignCraft: An open-source page and layout design editor written by scratch in pure Rust

Snap: document grid and baseline passes

Cameron Gilroy7032587238e4
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<AxisHit> {
- 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<AxisHit> {
+ 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<Best> = 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<AxisHit> {
- 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<f64> {
+ 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<f64> {
+ 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<AxisHit> {
+ 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<Best> = 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<f64> {
+ 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<Best>, moving: Rect, flags: [bool; 3], axis: Axis, tol: f64, mut target_at: impl FnMut(f64) -> Option<f64>) {
+ 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<AxisHit> {
@@ -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);
+ }
}