beffroi-tools/crates/midra-layout/src/snapping.rs

440 lines
18 KiB
Rust

//! Proximity snapping for layer movement and anchored single/group resizing.
use crate::{Geometry, Layout, ResizeHandle, ResizeMode};
#[derive(Clone, Copy, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Snapping {
pub enabled: bool,
pub pixels: bool,
pub screen_edges: bool,
pub layer_edges: bool,
pub grid: bool,
pub show_grid: bool,
pub grid_divisions: [u32; 2],
}
impl Default for Snapping {
fn default() -> Self {
Self {
enabled: false,
pixels: true,
screen_edges: true,
layer_edges: true,
grid: false,
show_grid: true,
grid_divisions: [8, 6],
}
}
}
impl Snapping {
/// Output-relative overlay lines, bounded for rendering and snapping alike.
pub fn grid_guides(self, size: u32, axis: usize) -> Vec<f64> {
let count = self.grid_divisions[axis].clamp(1, 64);
(0..=count)
.map(|i| size as f64 * i as f64 / count as f64)
.collect()
}
}
// Screen coordinates remain fractional for custom resolutions not divisible by four.
fn screen_guides(size: u32) -> [f64; 5] {
[0.0, 0.25, 0.5, 0.75, 1.0].map(|fraction| size as f64 * fraction)
}
impl Layout {
/// Snap a pivot without editing geometry. Local anchors take precedence over
/// grid/edge options; the caller may bypass them for precise free placement.
pub fn snap_pivot(
&self,
index: usize,
point: [f64; 2],
options: Snapping,
tolerance: f64,
grid: Option<f64>,
anchors: bool,
) -> ([f64; 2], [Option<f64>; 2]) {
let Some(g) = self.layers.get(index).copied() else {
return (point, [None; 2]);
};
if !tolerance.is_finite() || tolerance < 0.0 || point.iter().any(|v| !v.is_finite()) {
return (point, [None; 2]);
}
if anchors {
let distance = |p: [f64; 2]| (p[0] - point[0]).hypot(p[1] - point[1]);
if let Some(target) = ResizeHandle::positions(g)
.into_iter()
.map(|(_, p)| p)
.chain(std::iter::once(g.center()))
.filter(|p| distance(*p) <= tolerance)
.min_by(|a, b| distance(*a).total_cmp(&distance(*b)))
{
return (target, target.map(Some));
}
}
if let Some(spacing) = grid.filter(|s| s.is_finite() && *s > 0.0) {
let target = point.map(|v| (v / spacing).round() * spacing);
return (target, target.map(Some));
}
if !options.enabled {
return (point, [None; 2]);
}
let mut target = point;
let mut guides = [None; 2];
for axis in 0..2 {
let mut edges = Vec::new();
if options.screen_edges {
edges.extend(screen_guides(self.formats.output[axis]));
}
if options.grid {
edges.extend(options.grid_guides(self.formats.output[axis], axis));
}
if options.layer_edges {
for (i, other) in self.layers.iter().enumerate() {
if i != index && self.visible(i) {
edges.extend(if axis == 0 {
[other.x, other.x + other.width]
} else {
[other.y, other.y + other.height]
});
}
}
}
if let Some(edge) = edges
.into_iter()
.filter(|e| (*e - point[axis]).abs() <= tolerance)
.min_by(|a, b| (a - point[axis]).abs().total_cmp(&(b - point[axis]).abs()))
{
target[axis] = edge;
guides[axis] = Some(edge);
} else if options.pixels {
target[axis] = point[axis].round();
}
}
(target, guides)
}
/// Recompute from the gesture's original snapshot, never from a previous snapped frame.
/// `tolerance` is in screen pixels; the UI converts its fixed logical hit distance.
/// Layer resize handles preserve anchors/ratios; content crop gestures do not snap.
pub fn drag_to_snapped(
&mut self,
point: [f64; 2],
options: Snapping,
tolerance: f64,
) -> [Option<f64>; 2] {
if self.resize.is_some() && options.enabled && tolerance.is_finite() && tolerance >= 0.0 {
return self.resize_to_snapped(point, options, tolerance, None);
}
let mut guides = [None; 2];
let Some((selected, before, start)) = self.drag.clone() else {
self.drag_to(point);
return guides;
};
if !options.enabled || !tolerance.is_finite() || tolerance < 0.0 {
self.drag_to(point);
return guides;
}
if point.iter().any(|v| !v.is_finite()) {
return guides;
}
let mut delta = [point[0] - start[0], point[1] - start[1]];
let edge = |g: Geometry, axis: usize| {
if axis == 0 {
[g.x, g.x + g.width]
} else {
[g.y, g.y + g.height]
}
};
for axis in 0..2 {
let mut targets = Vec::new();
if options.screen_edges {
targets.extend(screen_guides(self.formats.output[axis]));
}
let grid_targets = if options.grid {
options.grid_guides(self.formats.output[axis], axis)
} else {
Vec::new()
};
targets.extend(grid_targets.iter().copied());
if options.layer_edges {
for (i, g) in before.layers.iter().enumerate() {
if !selected[i] && self.visible[i] {
targets.extend(edge(*g, axis));
}
}
}
let mut best: Option<(f64, f64)> = None;
for (i, g) in before.layers.iter().enumerate() {
if !selected[i] {
continue;
}
for (anchor, moving) in edge(*g, axis)
.into_iter()
.chain(std::iter::once(g.center()[axis]))
.enumerate()
{
for target in &targets {
// Centers align to screen interior guides and overlay grid lines;
// other targets retain edge-to-edge behavior.
if anchor == 2
&& (!options.screen_edges
|| !screen_guides(self.formats.output[axis])[1..4].contains(target))
&& !grid_targets.contains(target)
{
continue;
}
let correction = *target - (moving + delta[axis]);
if correction.abs() <= tolerance
&& best.is_none_or(|(d, _)| correction.abs() < d.abs())
{
best = Some((correction, *target));
}
}
}
}
if let Some((correction, target)) = best {
delta[axis] += correction;
guides[axis] = Some(target);
} else if options.pixels
&& let Some(i) = selected.iter().position(|v| *v)
{
let coordinate = edge(before.layers[i], axis)[0] + delta[axis];
delta[axis] += coordinate.round() - coordinate;
}
}
let mut next = before.layers;
for (i, g) in next.iter_mut().enumerate() {
if selected[i] {
g.x += delta[0];
g.y += delta[1];
}
}
if next.iter().all(|g| g.validate().is_ok()) {
self.layers = next;
} else {
guides = [None; 2];
}
guides
}
/// Snap a layer move or resize to an absolute screen-pixel grid.
/// Groups move rigidly using their bounding top-left; crop gestures bypass this grid.
pub fn drag_to_grid(&mut self, point: [f64; 2], spacing: f64) -> [Option<f64>; 2] {
if !spacing.is_finite() || spacing <= 0.0 || point.iter().any(|v| !v.is_finite()) {
return [None; 2];
}
if self.resize.is_some() {
return self.resize_to_snapped(
point,
Snapping {
enabled: true,
pixels: true,
screen_edges: false,
layer_edges: false,
..Default::default()
},
0.0,
Some(spacing),
);
}
let Some((selected, before, start)) = self.drag.clone() else {
self.drag_to(point);
return [None; 2];
};
let mut origin = [f64::INFINITY; 2];
for (i, g) in before.layers.iter().enumerate() {
if selected[i] {
origin[0] = origin[0].min(g.x);
origin[1] = origin[1].min(g.y);
}
}
let target: [f64; 2] = std::array::from_fn(|axis| {
((origin[axis] + point[axis] - start[axis]) / spacing).round() * spacing
});
let delta = [target[0] - origin[0], target[1] - origin[1]];
let mut next = before.layers;
for (i, g) in next.iter_mut().enumerate() {
if selected[i] {
g.x += delta[0];
g.y += delta[1];
}
}
if next.iter().all(|g| g.validate().is_ok()) {
self.layers = next;
target.map(Some)
} else {
[None; 2]
}
}
fn resize_to_snapped(
&mut self,
point: [f64; 2],
options: Snapping,
tolerance: f64,
grid: Option<f64>,
) -> [Option<f64>; 2] {
let r = self.resize.clone().expect("resize gesture");
self.drag_to_with_precision(point, grid.is_some());
if self.gesture_error.is_some() || point.iter().any(|v| !v.is_finite()) {
return [None; 2];
}
let base = self.snapshot();
let handle_point = |geometry| {
ResizeHandle::positions(geometry)
.into_iter()
.find(|(handle, _)| *handle == r.handle)
.unwrap()
.1
};
let current = handle_point(self.layers[r.index]);
// Free corners can reach both grid axes; proportional corners choose one
// driving axis below so the fixed anchor and aspect ratio remain exact.
if let Some(spacing) = grid
&& !r.keep_ratio
&& matches!(r.handle, ResizeHandle::Corner(_))
{
let targets = current.map(|v| (v / spacing).round() * spacing);
self.drag_to_with_precision(
std::array::from_fn(|axis| point[axis] + targets[axis] - current[axis]),
true,
);
if self.gesture_error.is_some() {
self.restore(base);
return [None; 2];
}
let reached = handle_point(self.layers[r.index]);
return std::array::from_fn(|axis| {
((reached[axis] - targets[axis]).abs() < 1e-6).then_some(targets[axis])
});
}
let mut candidates = Vec::new();
for (axis, _) in current.iter().enumerate() {
if (axis == 0 && matches!(r.handle, ResizeHandle::Top | ResizeHandle::Bottom))
|| (axis == 1 && matches!(r.handle, ResizeHandle::Left | ResizeHandle::Right))
{
continue;
}
let mut targets = Vec::new();
if options.screen_edges {
targets.extend(screen_guides(self.formats.output[axis]));
}
if options.grid {
targets.extend(options.grid_guides(self.formats.output[axis], axis));
}
if options.layer_edges {
for (i, g) in r.before.layers.iter().enumerate() {
if !r.targets[i] && self.visible(i) {
targets.extend(if axis == 0 {
[g.x, g.x + g.width]
} else {
[g.y, g.y + g.height]
});
}
}
}
if let Some(target) = targets
.into_iter()
.filter(|t| (*t - current[axis]).abs() <= tolerance)
.min_by(|a, b| {
(a - current[axis])
.abs()
.total_cmp(&(b - current[axis]).abs())
})
{
candidates.push((1, (target - current[axis]).abs(), axis, target, None));
}
if options.layer_edges && matches!(r.mode, ResizeMode::Mirror | ResizeMode::Opposite) {
let original = r.before.layers[r.index];
let moving = handle_point(original)[axis];
let anchor = r.anchor(r.index)[axis];
for (i, other) in r.before.layers.iter().enumerate() {
if i == r.index || !r.targets[i] || !self.visible(i) {
continue;
}
let other_handle = if r.mode == ResizeMode::Mirror {
r.handle.mirrored_horizontally()
} else {
r.handle.opposite()
};
let other_moving = ResizeHandle::positions(*other)
.into_iter()
.find(|(h, _)| *h == other_handle)
.unwrap()
.1[axis];
let other_anchor = r.anchor(i)[axis];
let span = moving - anchor;
let other_span = other_moving - other_anchor;
// Both edges move with the same scale factor, in opposite
// directions. Solve their meeting point, not a stale edge.
if span * other_span >= 0.0 {
continue;
}
let factor = (other_anchor - anchor) / (span - other_span);
let target = anchor + span * factor;
if factor > 0.0
&& target.is_finite()
&& (target - current[axis]).abs() <= tolerance
{
candidates.push((0, (target - current[axis]).abs(), axis, target, Some(i)));
}
}
}
if options.pixels {
let spacing = grid.unwrap_or(1.0);
let target = (current[axis] / spacing).round() * spacing;
candidates.push((2, (target - current[axis]).abs(), axis, target, None));
}
}
candidates.sort_by(|a, b| a.0.cmp(&b.0).then(a.1.total_cmp(&b.1)));
for (priority, _, axis, target, meeting) in candidates {
let mut adjusted = point;
// The regular preview may be pixel-rounded. Correct from the exact
// pointer geometry, or fractional viewport scales can miss the snap.
self.drag_to_with_precision(point, true);
adjusted[axis] += target - handle_point(self.layers[r.index])[axis];
if r.keep_ratio && matches!(r.handle, ResizeHandle::Corner(_)) {
let original = r.before.layers[r.index];
let original_handle = handle_point(original);
let anchor = r.anchor(r.index);
if (original_handle[axis] - anchor[axis]).abs() < 1e-9 {
self.restore(base.clone());
continue;
}
let factor = (target - anchor[axis]) / (original_handle[axis] - anchor[axis]);
for j in 0..2 {
adjusted[j] = r.start[j] + (original_handle[j] - anchor[j]) * (factor - 1.0);
}
}
self.drag_to_with_precision(adjusted, true);
let touching = meeting.is_none_or(|i| {
let a = self.layers[r.index];
let b = self.layers[i];
let other_axis = 1 - axis;
let low = |g: Geometry| if other_axis == 0 { g.x } else { g.y };
let size = |g: Geometry| if other_axis == 0 { g.width } else { g.height };
let other_handle = if r.mode == ResizeMode::Mirror {
r.handle.mirrored_horizontally()
} else {
r.handle.opposite()
};
let other_edge = ResizeHandle::positions(b)
.into_iter()
.find(|(h, _)| *h == other_handle)
.unwrap()
.1[axis];
(other_edge - target).abs() < 1e-6
&& low(a).max(low(b)) < (low(a) + size(a)).min(low(b) + size(b))
});
// Ratio/minimum-size constraints can prevent the requested snap. Never show a false guide.
if self.gesture_error.is_none()
&& touching
&& (handle_point(self.layers[r.index])[axis] - target).abs() < 1e-6
{
let mut guides = [None; 2];
if priority < 2 || grid.is_some() {
guides[axis] = Some(target);
}
return guides;
}
self.restore(base.clone());
}
[None; 2]
}
}