beffroi-tools/crates/canvas-pilot/tests/positioning.rs

1033 lines
34 KiB
Rust

use canvas_pilot::{Corner, Geometry, Layout, parse_drawio};
const SAMPLE: &str = include_str!("fixtures/drawio-rectangle.txt");
fn xml(body: &str) -> String {
format!(
r#"<mxGraphModel><root><mxCell id="0"/><mxCell id="1" parent="0"/>{body}</root></mxGraphModel>"#
)
}
fn vertex(geometry: &str, style: &str) -> String {
xml(&format!(
r#"<mxCell id="2" parent="1" vertex="1" style="{style}">{geometry}</mxCell>"#
))
}
fn g() -> Geometry {
Geometry {
x: 12.0,
y: 271.0,
width: 945.0,
height: 531.58,
}
}
#[test]
fn supplied_clipboard_preserves_decimals_and_converts_center() {
let shapes = parse_drawio(SAMPLE).unwrap();
assert_eq!(shapes.len(), 1);
assert_eq!(shapes[0].id, "2");
assert_eq!(shapes[0].geometry, g());
assert_eq!(shapes[0].geometry.center(), [484.5, 536.79]);
assert!((g().width / g().height - 16.0 / 9.0).abs() > 0.000001); // no preset snapping
}
#[test]
fn raw_xml_defaults_missing_origin_and_keeps_negative_and_fractional_coordinates() {
let raw = vertex(r#"<mxGeometry width="20.5" height="30"/>"#, "rounded=0;");
let a = parse_drawio(&raw).unwrap()[0].geometry;
assert_eq!([a.x, a.y], [0.0, 0.0]);
let raw = vertex(
r#"<mxGeometry x="-12.25" y="2.5" width="20.5" height="30"/>"#,
"",
);
let a = parse_drawio(&raw).unwrap()[0].geometry;
assert_eq!([a.x, a.y], [-12.25, 2.5]);
}
#[test]
fn multiple_rectangles_keep_source_order() {
let data = xml(
r#"<mxCell id="9" vertex="1" parent="1"><mxGeometry width="50" height="30"/></mxCell><mxCell id="2" vertex="1" parent="1"><mxGeometry x="100" width="10" height="10"/></mxCell>"#,
);
let list = parse_drawio(&data).unwrap();
assert_eq!(
list.iter().map(|s| s.id.as_str()).collect::<Vec<_>>(),
vec!["9", "2"]
);
}
#[test]
fn invalid_clipboard_is_rejected_without_panicking() {
for s in [
"",
"%",
"%3",
"%GG",
"%ff",
"not geometry",
"<mxGraphModel>",
"<mxfile/>",
"<mxGraphModel/>",
"<mxGraphModel><root/></mxGraphModel>",
] {
assert!(parse_drawio(s).is_err(), "{s}");
}
assert!(parse_drawio(&"x".repeat(1_048_577)).is_err());
assert!(
parse_drawio(
r#"<!DOCTYPE a [<!ENTITY e "hello">]><mxGraphModel><root>&e;</root></mxGraphModel>"#
)
.is_err()
);
}
#[test]
fn invalid_sizes_or_nonfinite_numbers_cannot_enter_document() {
for attr in [
r#"width="0" height="2""#,
r#"width="-1" height="2""#,
r#"width="NaN" height="2""#,
r#"width="2" height="inf""#,
r#"x="1e300" width="2" height="2""#,
r#"height="20""#,
] {
assert!(parse_drawio(&vertex(&format!("<mxGeometry {attr}/>"), "")).is_err());
}
let mut layout = Layout::default();
let before = layout.layers().clone();
assert!(
layout
.apply(
1,
Geometry {
width: f64::NAN,
..g()
}
)
.is_err()
);
assert_eq!(*layout.layers(), before);
assert!(layout.apply(7, g()).is_err());
assert_eq!(*layout.layers(), before);
}
#[test]
fn transforms_groups_connections_and_ambiguous_geometry_are_refused() {
for style in [
"rotation=90;",
"flipH=1;",
"shape=ellipse;",
"ellipse;",
"group;",
] {
assert!(parse_drawio(&vertex(r#"<mxGeometry width="10" height="10"/>"#, style)).is_err());
}
for geometry in [
r#"<mxGeometry relative="1" width="10" height="10"/>"#,
r#"<mxGeometry width="10" height="10"><mxPoint x="2" as="offset"/></mxGeometry>"#,
r#"<mxGeometry width="10" height="10"/><mxGeometry width="20" height="20"/>"#,
] {
assert!(parse_drawio(&vertex(geometry, "")).is_err());
}
for body in [
r#"<mxCell id="2" parent="1" edge="1"/>"#,
r#"<object><mxCell id="2"/></object>"#,
r#"<mxCell id="1"/>"#,
r#"<mxCell id="2" parent="missing" vertex="1"><mxGeometry width="10" height="10"/></mxCell>"#,
r#"<mxCell id="2" parent="1" vertex="1"><mxGeometry width="10" height="10"/></mxCell><mxCell id="3" parent="2" vertex="1"><mxGeometry width="5" height="5"/></mxCell>"#,
] {
assert!(parse_drawio(&xml(body)).is_err());
}
}
#[test]
fn percent_decoding_is_once_and_does_not_treat_plus_as_space() {
let raw = vertex(r#"<mxGeometry x="+12" width="10" height="10"/>"#, "");
let encoded = raw.replace('<', "%3C").replace('>', "%3E");
assert_eq!(parse_drawio(&encoded).unwrap()[0].geometry.x, 12.0);
assert!(parse_drawio(&encoded.replace('%', "%25")).is_err());
}
#[test]
fn corners_roundtrip_without_moving_or_rounding_the_box() {
for c in [
Corner::TopLeft,
Corner::TopRight,
Corner::BottomLeft,
Corner::BottomRight,
] {
let [x, y] = c.offsets(g());
let result = c.geometry(x, y, g().width, g().height).unwrap();
assert!((result.x - g().x).abs() < 1e-10);
assert!((result.y - g().y).abs() < 1e-10);
assert_eq!(result.width, g().width);
}
let a = Corner::TopRight
.geometry(120.0, 180.0, 640.0, 360.0)
.unwrap();
assert_eq!(a.center(), [1480.0, 360.0]);
}
#[test]
fn paste_and_undo_change_only_the_target() {
let mut l = Layout::default();
let original = l.layers().clone();
l.apply(1, parse_drawio(SAMPLE).unwrap()[0].geometry)
.unwrap();
assert_eq!(l.layers()[0], original[0]);
assert_eq!(l.layers()[1], g());
l.undo();
assert_eq!(*l.layers(), original);
l.redo();
assert_eq!(l.layers()[1], g());
l.undo();
l.nudge(1.0, 0.0).unwrap();
let nudged = l.layers().clone();
l.redo();
assert_eq!(*l.layers(), nudged);
}
#[test]
fn drag_uses_original_position_and_is_one_undo_record() {
let mut l = Layout::default();
l.apply(1, g()).unwrap();
let original = l.layers().clone();
l.start_drag([20.0, 280.0]);
for n in 1..10 {
l.drag_to([20.0 + n as f64, 280.0 + n as f64]);
}
l.finish_drag();
assert_eq!(
l.layers()[1],
Geometry {
x: 21.0,
y: 280.0,
..g()
}
);
l.undo();
assert_eq!(*l.layers(), original);
l.redo();
assert_eq!(l.layers()[1].x, 21.0);
}
#[test]
fn cancel_drag_restores_geometry_and_retains_fractional_origin() {
let mut l = Layout::default();
l.apply(1, Geometry { x: 12.25, ..g() }).unwrap();
let original = l.layers().clone();
l.start_drag([20.0, 280.0]);
l.drag_to([22.8, 282.2]);
assert_eq!(l.layers()[1].x, 15.25);
l.cancel_drag();
assert_eq!(*l.layers(), original);
assert!(!l.dragging());
}
#[test]
fn hit_testing_matches_stacking_and_background_deselects() {
let mut l = Layout::default();
l.apply(0, g()).unwrap();
l.apply(1, g()).unwrap();
assert_eq!(l.hit([20.0, 280.0]), Some(1));
l.start_drag([-100.0, -100.0]);
assert_eq!(l.selected(), None);
l.nudge(10.0, 10.0).unwrap();
assert_eq!(l.layers()[0], g());
l.select(Some(77));
assert_eq!(l.selected(), None);
}
#[test]
fn offscreen_placement_is_preserved_and_nudging_keeps_size() {
let mut l = Layout::default();
l.apply(
1,
Geometry {
x: -20.25,
y: 1200.0,
..g()
},
)
.unwrap();
l.nudge(1.0, -10.0).unwrap();
let a = l.layers()[1];
assert_eq!(a.x, -19.25);
assert_eq!(a.y, 1190.0);
assert_eq!(a.width, 945.0);
assert!(a.outside());
}
#[test]
fn outline_expands_sample_without_moving_center_and_position_only_is_unadjusted() {
let shape = parse_drawio(SAMPLE).unwrap().remove(0);
assert_eq!(shape.stroke_width, 5.0);
let before = Geometry {
x: 100.0,
y: 200.0,
width: 300.0,
height: 250.0,
};
assert_eq!(shape.paste_geometry(before, true, false).unwrap(), g());
let outlined = shape.paste_geometry(before, true, true).unwrap();
assert_eq!(
outlined,
Geometry {
x: 9.5,
y: 268.5,
width: 950.0,
height: 536.58
}
);
assert_eq!(outlined.center(), g().center());
assert_eq!(
shape.paste_geometry(before, false, true).unwrap(),
Geometry {
x: 12.0,
y: 271.0,
..before
}
);
}
#[test]
fn default_fractional_and_hidden_outlines_are_handled() {
for (style, width) in [
("", 1.0),
("strokeWidth=0.5;", 0.5),
("strokeWidth=0;", 0.0),
("strokeWidth=5;strokeColor=none;", 0.0),
("strokeWidth=5;strokeColor=transparent;", 0.0),
("strokeWidth=5;strokeOpacity=0;", 0.0),
("strokeWidth=5;opacity=0;", 0.0),
("strokeWidth=2;strokeWidth=6;", 6.0),
] {
let shape = parse_drawio(&vertex(r#"<mxGeometry width="10" height="20"/>"#, style))
.unwrap()
.remove(0);
assert_eq!(shape.stroke_width, width, "{style}");
let result = shape.paste_geometry(g(), true, true).unwrap();
assert_eq!(result.x, -width / 2.0);
assert_eq!(result.width, 10.0 + width);
assert_eq!(result.center(), [5.0, 10.0]);
}
}
#[test]
fn invalid_outline_settings_and_expansion_beyond_limits_are_refused() {
for style in [
"strokeWidth=NaN;",
"strokeWidth=-1;",
"strokeWidth=inf;",
"strokeWidth=huge;",
"strokeOpacity=101;",
"opacity=-1;",
] {
assert!(parse_drawio(&vertex(r#"<mxGeometry width="10" height="20"/>"#, style)).is_err());
}
let shape = parse_drawio(&vertex(
r#"<mxGeometry width="1000000" height="20"/>"#,
"strokeWidth=5;",
))
.unwrap()
.remove(0);
assert!(shape.paste_geometry(g(), true, false).is_ok());
assert!(shape.paste_geometry(g(), true, true).is_err());
}
#[test]
fn each_pasted_rectangle_keeps_its_own_outline_width() {
let data = xml(
r#"<mxCell id="2" vertex="1" parent="1" style="strokeWidth=2;"><mxGeometry width="10" height="20"/></mxCell><mxCell id="3" vertex="1" parent="1" style="strokeWidth=8;"><mxGeometry width="30" height="40"/></mxCell>"#,
);
let shapes = parse_drawio(&data).unwrap();
assert_eq!(
shapes[0].paste_geometry(g(), true, true).unwrap().width,
12.0
);
assert_eq!(
shapes[1].paste_geometry(g(), true, true).unwrap().width,
38.0
);
}
#[test]
fn selection_toggle_and_marquee_are_independent_of_geometry_history() {
let mut l = Layout::default();
let original = l.layers().clone();
l.toggle(0);
assert_eq!(l.selected_indices(), vec![0, 1]);
assert_eq!(l.selected(), None);
l.toggle(1);
assert_eq!(l.selected(), Some(0));
l.toggle(0);
assert!(l.selected_indices().is_empty());
l.select_region([1800.0, 600.0], [100.0, 100.0], [false; 2]);
assert_eq!(l.selected_indices(), vec![0, 1]);
l.select_region([100.0, 100.0], [125.0, 185.0], [false, true]);
assert_eq!(l.selected_indices(), vec![0, 1]);
assert_eq!(*l.layers(), original);
l.undo();
assert_eq!(*l.layers(), original);
}
#[test]
fn selected_layers_drag_and_nudge_together_with_atomic_undo() {
let mut l = Layout::default();
l.set_selection([true; 2]);
let before = l.layers().clone();
l.start_drag([130.0, 190.0]);
l.drag_to([155.0, 200.0]);
l.finish_drag();
for (i, g) in before.iter().enumerate() {
assert_eq!(
l.layers()[i],
Geometry {
x: g.x + 25.0,
y: g.y + 10.0,
..*g
}
);
}
l.undo();
assert_eq!(*l.layers(), before);
l.redo();
l.nudge(1.0, -10.0).unwrap();
for (i, g) in before.iter().enumerate() {
assert_eq!(
l.layers()[i],
Geometry {
x: g.x + 26.0,
y: g.y,
..*g
}
);
}
l.undo();
l.undo();
assert_eq!(*l.layers(), before);
l.start_drag([130.0, 190.0]);
l.drag_to([150.0, 220.0]);
l.cancel_drag();
assert_eq!(*l.layers(), before);
}
#[test]
fn align_edges_and_centers_to_explicit_targets_without_resizing() {
use canvas_pilot::{AlignTarget as T, Alignment as A};
let initial = [
Geometry {
x: 100.5,
y: 70.25,
width: 300.0,
height: 210.0,
},
Geometry {
x: 700.25,
y: 350.5,
width: 100.0,
height: 80.0,
},
];
for target in [T::Selection, T::Screen, T::Layer(0), T::Layer(1)] {
for alignment in [
A::Left,
A::Right,
A::Top,
A::Bottom,
A::HorizontalCenter,
A::VerticalCenter,
] {
let mut l = Layout::default();
for (i, g) in initial.iter().enumerate() {
l.apply(i, *g).unwrap();
}
l.set_selection([true; 2]);
let reference = match target {
T::Screen => Geometry {
x: 0.0,
y: 0.0,
width: 1920.0,
height: 1080.0,
},
T::Selection => l.selection_bounds().unwrap(),
T::Layer(i) => initial[i],
};
l.align(alignment, target).unwrap();
for (i, g) in l.layers().iter().enumerate() {
assert_eq!([g.width, g.height], [initial[i].width, initial[i].height]);
let (actual, wanted) = match alignment {
A::Left => (g.x, reference.x),
A::Right => (g.x + g.width, reference.x + reference.width),
A::Top => (g.y, reference.y),
A::Bottom => (g.y + g.height, reference.y + reference.height),
A::HorizontalCenter => (g.center()[0], reference.center()[0]),
A::VerticalCenter => (g.center()[1], reference.center()[1]),
};
assert!((actual - wanted).abs() < 1e-9);
if matches!(alignment, A::Left | A::Right | A::HorizontalCenter) {
assert_eq!(g.y, initial[i].y);
} else {
assert_eq!(g.x, initial[i].x);
}
}
if let T::Layer(i) = target {
assert_eq!(l.layers()[i], initial[i]);
}
let aligned = l.layers().clone();
l.undo();
assert_eq!(*l.layers(), initial);
l.redo();
assert_eq!(*l.layers(), aligned);
}
}
}
#[test]
fn alignment_refuses_invalid_reference_and_failed_group_moves_are_atomic() {
use canvas_pilot::{AlignTarget as T, Alignment as A};
let mut l = Layout::default();
let before = l.layers().clone();
assert!(l.align(A::Top, T::Layer(99)).is_err());
assert_eq!(*l.layers(), before);
l.select(None);
assert!(l.align(A::Left, T::Screen).is_err());
l.apply(
1,
Geometry {
x: 1_000_000.0,
..before[1]
},
)
.unwrap();
l.set_selection([true; 2]);
let before = l.layers().clone();
assert!(l.nudge(1.0, 0.0).is_err());
assert_eq!(*l.layers(), before);
l.start_drag([130.0, 190.0]);
l.drag_to([140.0, 190.0]);
l.finish_drag();
assert_eq!(*l.layers(), before);
}
#[test]
fn alignment_moves_only_selected_layers_and_is_order_independent() {
use canvas_pilot::{AlignTarget as T, Alignment as A};
let mut l = Layout::default();
let before = l.layers().clone();
l.align(A::Left, T::Screen).unwrap();
assert_eq!(l.layers()[0], before[0]);
assert_eq!(l.layers()[1].x, 0.0);
l.undo();
l.select(Some(0));
l.toggle(1);
l.align(A::Left, T::Selection).unwrap();
let first = l.layers().clone();
l.undo();
l.select(Some(1));
l.toggle(0);
l.align(A::Left, T::Selection).unwrap();
assert_eq!(*l.layers(), first);
}
#[test]
fn protected_layers_are_excluded_from_selection_and_edits() {
for hidden in [false, true] {
let mut layout = Layout::default();
let before = layout.layers().clone();
layout.set_selection([true; 2]);
if hidden {
layout.set_visible(1, false);
} else {
layout.set_locked(1, true);
}
assert_eq!(layout.selected(), Some(0));
assert_eq!(layout.hit(before[1].center()), None);
layout.select(Some(1));
layout.toggle(1);
assert_eq!(layout.selected(), None);
layout.select_region([0.0, 0.0], [1920.0, 1080.0], [true; 2]);
assert_eq!(layout.selected(), Some(0));
layout.nudge(10.0, 20.0).unwrap();
layout
.align(
canvas_pilot::Alignment::Left,
canvas_pilot::AlignTarget::Screen,
)
.unwrap();
assert_eq!(layout.layers()[1], before[1]);
assert!(layout.apply(1, before[0]).is_err());
layout.start_drag(before[1].center());
assert!(!layout.dragging());
layout.set_visible(1, true);
layout.set_locked(1, false);
layout.select(Some(1));
assert_eq!(layout.selected(), Some(1));
assert_eq!(layout.layers()[1], before[1]);
}
}
#[test]
fn locking_during_a_group_drag_restores_geometry_and_preserves_visibility() {
let mut layout = Layout::default();
let before = layout.layers().clone();
layout.set_selection([true; 2]);
layout.start_drag(before[0].center());
layout.drag_to([500.0, 500.0]);
layout.set_locked(0, true);
assert_eq!(*layout.layers(), before);
assert!(!layout.dragging());
assert!(layout.visible(0));
layout.set_visible(0, false);
layout.set_visible(0, true);
assert!(layout.locked(0));
layout.select(Some(0));
assert_eq!(layout.selected(), None);
}
#[test]
fn corner_resize_preserves_opposite_anchor_ratio_and_atomic_history() {
for corner in [
Corner::TopLeft,
Corner::TopRight,
Corner::BottomLeft,
Corner::BottomRight,
] {
for keep_ratio in [true, false] {
let mut layout = Layout::default();
let before = layout.layers().clone();
let left = matches!(corner, Corner::TopLeft | Corner::BottomLeft);
let top = matches!(corner, Corner::TopLeft | Corner::TopRight);
let anchor = |g: Geometry| {
[
if left { g.x + g.width } else { g.x },
if top { g.y + g.height } else { g.y },
]
};
let start = [
if left {
before[1].x
} else {
before[1].x + before[1].width
},
if top {
before[1].y
} else {
before[1].y + before[1].height
},
];
let end = [
start[0] + if left { -160.0 } else { 160.0 },
start[1] + if top { -90.0 } else { 90.0 },
];
layout.start_resize(1, corner, start, keep_ratio);
layout.drag_to(end);
layout.drag_to(end); // no incremental drift
layout.finish_drag();
let after = layout.layers().clone();
assert_eq!(after[0], before[0]);
assert_eq!(anchor(after[1]), anchor(before[1]));
assert_eq!([after[1].width, after[1].height], [800.0, 450.0]);
layout.undo();
assert_eq!(*layout.layers(), before);
layout.redo();
assert_eq!(*layout.layers(), after);
}
}
}
#[test]
fn free_resize_changes_ratio_and_cancels_without_flipping_or_moving_locked_layers() {
let mut layout = Layout::default();
let before = layout.layers().clone();
layout.start_resize(1, Corner::BottomRight, [0.0, 0.0], false);
layout.drag_to([100.0, 20.0]);
assert_eq!(
[layout.layers()[1].width, layout.layers()[1].height],
[740.0, 380.0]
);
layout.drag_to([-2000.0, -2000.0]);
assert_eq!(
[layout.layers()[1].width, layout.layers()[1].height],
[1.0, 1.0]
);
layout.cancel_drag();
assert_eq!(*layout.layers(), before);
layout.start_resize(1, Corner::BottomRight, [0.0, 0.0], true);
layout.drag_to([100.0, 0.0]);
assert!((layout.layers()[1].width / layout.layers()[1].height - 16.0 / 9.0).abs() < 1e-10);
layout.drag_to([f64::NAN, 0.0]);
assert!(layout.layers()[1].validate().is_ok());
layout.set_locked(1, true);
assert_eq!(*layout.layers(), before);
layout.start_resize(1, Corner::BottomRight, [0.0, 0.0], false);
assert!(!layout.dragging());
}
#[test]
fn midpoint_handles_fix_opposite_edge_and_preserve_undo_and_ratio() {
use canvas_pilot::ResizeHandle as H;
for handle in [H::Left, H::Right, H::Top, H::Bottom] {
for keep_ratio in [true, false] {
let mut layout = Layout::default();
let before = layout.layers().clone();
let center = before[1].center();
let (handle, start) = H::positions(before[1])
.into_iter()
.find(|(h, _)| *h == handle)
.unwrap();
let end = match handle {
H::Left => [start[0] - 20.0, start[1]],
H::Right => [start[0] + 20.0, start[1]],
H::Top => [start[0], start[1] - 20.0],
H::Bottom => [start[0], start[1] + 20.0],
_ => unreachable!(),
};
layout.start_handle_resize(1, handle, start, keep_ratio);
layout.drag_to(end);
layout.finish_drag();
let after = layout.layers()[1];
match handle {
H::Left => assert_eq!(after.x + after.width, before[1].x + before[1].width),
H::Right => assert_eq!(after.x, before[1].x),
H::Top => assert_eq!(after.y + after.height, before[1].y + before[1].height),
H::Bottom => assert_eq!(after.y, before[1].y),
_ => unreachable!(),
}
assert_eq!(layout.layers()[0], before[0]);
if matches!(handle, H::Left | H::Right) {
assert_eq!(after.width, 660.0);
assert_eq!(after.center()[1], center[1]);
if !keep_ratio {
assert_eq!(after.height, 360.0);
}
} else {
assert_eq!(after.height, 380.0);
assert_eq!(after.center()[0], center[0]);
if !keep_ratio {
assert_eq!(after.width, 640.0);
}
}
if keep_ratio {
assert!((after.width / after.height - 16.0 / 9.0).abs() < 1e-10);
}
layout.undo();
assert_eq!(*layout.layers(), before);
layout.redo();
assert_eq!(layout.layers()[1], after);
layout.start_handle_resize(1, handle, start, false);
layout.drag_to(end);
layout.cancel_drag();
assert_eq!(layout.layers()[1], after);
}
}
}
#[test]
fn corner_alignment_to_unselected_reference_is_one_undo_step() {
use canvas_pilot::{AlignTarget as T, Alignment as A};
let mut l = Layout::default();
let before = l.layers().clone();
l.align_axes(&[A::Right, A::Bottom], T::Layer(0)).unwrap();
assert_eq!(l.layers()[0], before[0]);
assert_eq!(
l.layers()[1].x + l.layers()[1].width,
before[0].x + before[0].width
);
assert_eq!(
l.layers()[1].y + l.layers()[1].height,
before[0].y + before[0].height
);
l.undo();
assert_eq!(*l.layers(), before);
}
#[test]
fn selected_resize_scales_proportionally_with_same_or_opposite_anchors() {
use canvas_pilot::{ResizeHandle as H, ResizeMode as M};
for mode in [M::Same, M::Mirror, M::Opposite] {
for keep_ratio in [false, true] {
for initiator in 0..2 {
for (handle, _) in H::positions(Layout::default().layers()[0]) {
let mut l = Layout::default();
l.apply(
0,
Geometry {
x: 100.0,
y: 80.0,
width: 300.0,
height: 200.0,
},
)
.unwrap();
l.set_selection([true; 2]);
let before = l.layers().clone();
let formats = l.formats().clone();
let start = H::positions(before[initiator])
.into_iter()
.find(|(h, _)| *h == handle)
.unwrap()
.1;
let dx = if matches!(
handle,
H::Left | H::Corner(Corner::TopLeft | Corner::BottomLeft)
) {
-30.0
} else {
30.0
};
let dy = if matches!(
handle,
H::Top | H::Corner(Corner::TopLeft | Corner::TopRight)
) {
-20.0
} else {
20.0
};
l.start_selected_resize(initiator, handle, start, keep_ratio, mode)
.unwrap();
l.drag_to([start[0] + dx, start[1] + dy]);
l.finish_drag();
assert_eq!(l.selection_mask(), [true; 2]);
let after = l.layers().clone();
assert!(
(after[0].width / before[0].width - after[1].width / before[1].width).abs()
< 1e-10
);
assert!(
(after[0].height / before[0].height - after[1].height / before[1].height)
.abs()
< 1e-10
);
for i in 0..2 {
let actual = if i != initiator {
match mode {
M::Mirror => handle.mirrored_horizontally(),
M::Opposite => handle.opposite(),
_ => handle,
}
} else {
handle
};
let anchor = |g| {
H::positions(g)
.into_iter()
.find(|(h, _)| *h == actual.opposite())
.unwrap()
.1
};
for (a, b) in anchor(before[i]).into_iter().zip(anchor(after[i])) {
assert!((a - b).abs() < 1e-8);
}
if keep_ratio {
assert!(
(after[i].width / after[i].height
- before[i].width / before[i].height)
.abs()
< 1e-10
);
}
}
l.undo();
assert_eq!(*l.layers(), before);
assert_eq!(*l.formats(), formats);
l.redo();
assert_eq!(*l.layers(), after);
}
}
}
}
}
#[test]
fn selected_resize_limits_cancel_and_protection_are_atomic() {
use canvas_pilot::{ResizeHandle as H, ResizeMode as M};
let mut l = Layout::default();
assert!(
l.start_selected_resize(1, H::Right, [0.0; 2], false, M::Mirror)
.is_err()
);
l.apply(
0,
Geometry {
x: 100.0,
y: 80.0,
width: 300.0,
height: 200.0,
},
)
.unwrap();
l.set_selection([true; 2]);
let before = l.layers().clone();
let formats = l.formats().clone();
l.start_selected_resize(0, H::Right, [0.0; 2], false, M::Same)
.unwrap();
l.drag_to([800_000.0, 0.0]);
assert!(l.gesture_error.is_some());
assert_eq!(*l.layers(), before);
assert_eq!(*l.formats(), formats);
l.drag_to([30.0, 0.0]);
assert_ne!(*l.layers(), before);
l.cancel_drag();
assert_eq!(*l.layers(), before);
assert_eq!(*l.formats(), formats);
l.start_selected_resize(0, H::Right, [0.0; 2], false, M::Mirror)
.unwrap();
l.drag_to([30.0, 0.0]);
l.set_locked(1, true);
assert_eq!(*l.layers(), before);
assert_eq!(*l.formats(), formats);
assert!(!l.dragging());
assert!(
l.start_selected_resize(0, H::Right, [0.0; 2], false, M::Mirror)
.is_err()
);
}
#[test]
fn resize_handle_modes_distinguish_horizontal_mirror_from_opposite() {
use canvas_pilot::ResizeHandle as H;
for (handle, mirrored, opposite) in [
(
H::Corner(Corner::BottomRight),
H::Corner(Corner::BottomLeft),
H::Corner(Corner::TopLeft),
),
(
H::Corner(Corner::TopRight),
H::Corner(Corner::TopLeft),
H::Corner(Corner::BottomLeft),
),
(H::Right, H::Left, H::Left),
(H::Top, H::Top, H::Bottom),
(H::Bottom, H::Bottom, H::Top),
] {
assert_eq!(handle.mirrored_horizontally(), mirrored);
assert_eq!(mirrored.mirrored_horizontally(), handle);
assert_eq!(handle.opposite(), opposite);
assert_eq!(opposite.opposite(), handle);
}
}
#[test]
fn selection_never_changes_viewport_stacking_or_hit_order() {
let mut l = Layout::default();
l.apply(0, g()).unwrap();
l.apply(1, g()).unwrap();
let before = l.layers().clone();
for (selection, order, hit) in [
([false, false], [0, 1], Some(1)),
([true, false], [0, 1], Some(1)),
([false, true], [0, 1], Some(1)),
([true, true], [0, 1], Some(1)),
] {
l.set_selection(selection);
assert_eq!(l.viewport_order(), order);
assert_eq!(l.hit([20.0, 280.0]), hit);
assert_eq!(*l.layers(), before);
}
l.select(Some(0));
l.set_locked(0, true);
assert_eq!(l.hit([20.0, 280.0]), Some(1));
l.set_visible(1, false);
assert_eq!(l.hit([20.0, 280.0]), None);
}
#[test]
fn crop_corner_zoom_keeps_layer_fixed_and_supports_limits_history_and_cancel() {
use canvas_pilot::ResizeHandle;
for handle in [
ResizeHandle::Corner(Corner::TopLeft),
ResizeHandle::Corner(Corner::TopRight),
ResizeHandle::Corner(Corner::BottomLeft),
ResizeHandle::Corner(Corner::BottomRight),
ResizeHandle::Top,
ResizeHandle::Bottom,
ResizeHandle::Left,
ResizeHandle::Right,
] {
let mut l = Layout::default();
let i = 1;
let before = l.layers().clone();
let formats = l.formats().clone();
let g = before[i];
let start = ResizeHandle::positions(g)
.into_iter()
.find(|(h, _)| *h == handle)
.unwrap()
.1;
let opposite = ResizeHandle::positions(g)
.into_iter()
.find(|(h, _)| *h == handle.opposite())
.unwrap()
.1;
let end = std::array::from_fn(|axis| opposite[axis] + 2.0 * (start[axis] - opposite[axis]));
l.start_content_resize(i, handle, start);
l.drag_to(end);
l.finish_drag();
assert_eq!(*l.layers(), before);
let after = l.formats().clone();
let m = after.mapping(i, g).unwrap();
assert!((m.framing.zoom - 2.0).abs() < 1e-8);
let crop = after.advanced[i];
let input = after.input(i).unwrap();
let full = Geometry {
x: g.x - crop.left * m.scale,
y: g.y - crop.top * m.scale,
width: input[0] * m.scale,
height: input[1] * m.scale,
};
let fixed = ResizeHandle::positions(full)
.into_iter()
.find(|(h, _)| *h == handle.opposite())
.unwrap()
.1;
for axis in 0..2 {
assert!((fixed[axis] - opposite[axis]).abs() < 1e-7);
}
l.undo();
assert_eq!(*l.formats(), formats);
l.redo();
assert_eq!(*l.formats(), after);
l.start_content_resize(i, handle, end);
l.drag_to(opposite);
let m = l.formats().mapping(i, g).unwrap();
assert!((m.framing.zoom - 1.0).abs() < 1e-8);
l.cancel_drag();
assert_eq!(*l.formats(), after);
l.start_content_resize(i, handle, end);
l.drag_to(std::array::from_fn(|axis| {
opposite[axis] + 1000.0 * (start[axis] - opposite[axis])
}));
assert!((l.formats().mapping(i, g).unwrap().framing.zoom - 100.0).abs() < 1e-6);
l.set_locked(i, true);
assert_eq!(*l.formats(), after);
l.start_content_resize(i, handle, start);
assert!(!l.dragging());
}
}
#[test]
fn independent_measurement_points_roundtrip_and_resize_about_the_layer_endpoint() {
use canvas_pilot::{PositionPoint, PositionReference};
let points = [
PositionPoint::TopLeft,
PositionPoint::TopRight,
PositionPoint::BottomLeft,
PositionPoint::BottomRight,
PositionPoint::Center,
];
let output = [1921, 1081];
let geometry = Geometry {
x: -120.25,
y: 183.5,
width: 641.5,
height: 361.25,
};
for screen in points {
for layer in points {
let reference = PositionReference { screen, layer };
let [x, y] = reference.offsets_on(geometry, output);
assert_eq!(
reference
.geometry_on(x, y, geometry.width, geometry.height, output)
.unwrap(),
geometry
);
let resized = reference.geometry_on(x, y, 200.25, 400.5, output).unwrap();
assert_eq!(layer.point_on(resized), layer.point_on(geometry));
assert_eq!(reference.offsets_on(resized, output), [x, y]);
}
}
let reference = PositionReference {
screen: PositionPoint::TopLeft,
layer: PositionPoint::Center,
};
assert_eq!(reference.offsets_on(geometry, output), geometry.center());
assert_eq!(
reference
.geometry_on(960.5, 540.5, 640.0, 360.0, output)
.unwrap()
.center(),
[960.5, 540.5]
);
}