214 lines
6.7 KiB
Rust
214 lines
6.7 KiB
Rust
use midra_layout::{Layout, snapping::Snapping};
|
|
|
|
#[test]
|
|
fn screen_snapping_recomputes_from_original_and_is_one_undo_step() {
|
|
let mut layout = Layout::default();
|
|
let before = layout.layers().clone();
|
|
let formats = layout.formats().clone();
|
|
let options = Snapping {
|
|
enabled: true,
|
|
layer_edges: false,
|
|
..Default::default()
|
|
};
|
|
layout.start_drag([1200.0, 200.0]);
|
|
assert_eq!(
|
|
layout.drag_to_snapped([1317.0, 201.0], options, 6.0),
|
|
[Some(1920.0), None]
|
|
);
|
|
assert_eq!(layout.layers()[1].x, 1280.0);
|
|
layout.drag_to_snapped([1250.0, 200.0], options, 6.0);
|
|
assert_eq!(layout.layers()[1].x, before[1].x + 50.0);
|
|
layout.drag_to_snapped([1317.0, 201.0], options, 6.0);
|
|
layout.finish_drag();
|
|
assert_eq!(*layout.formats(), formats);
|
|
layout.undo();
|
|
assert_eq!(*layout.layers(), before);
|
|
layout.redo();
|
|
assert_eq!(layout.layers()[1].x, 1280.0);
|
|
}
|
|
#[test]
|
|
fn visible_layer_edges_include_locked_targets_but_not_hidden_targets() {
|
|
let options = Snapping {
|
|
enabled: true,
|
|
screen_edges: false,
|
|
pixels: false,
|
|
..Default::default()
|
|
};
|
|
for hidden in [false, true] {
|
|
let mut layout = Layout::default();
|
|
layout.set_locked(0, true);
|
|
if hidden {
|
|
layout.set_visible(0, false);
|
|
}
|
|
layout.start_drag([1160.0, 180.0]);
|
|
let guides = layout.drag_to_snapped([763.0, 190.0], options, 6.0);
|
|
assert_eq!(guides[0], if hidden { None } else { Some(760.0) });
|
|
assert_eq!(layout.layers()[1].x, if hidden { 763.0 } else { 760.0 });
|
|
}
|
|
}
|
|
#[test]
|
|
fn group_snapping_preserves_spacing_and_cancel_restores_geometry() {
|
|
let mut layout = Layout::default();
|
|
layout.set_selection([true; 2]);
|
|
let before = layout.layers().clone();
|
|
layout.start_drag([200.0, 200.0]);
|
|
layout.drag_to_snapped(
|
|
[83.0, 200.0],
|
|
Snapping {
|
|
enabled: true,
|
|
..Default::default()
|
|
},
|
|
6.0,
|
|
);
|
|
assert_eq!(layout.layers()[0].x, 0.0);
|
|
assert_eq!(
|
|
layout.layers()[1].x - layout.layers()[0].x,
|
|
before[1].x - before[0].x
|
|
);
|
|
layout.cancel_drag();
|
|
assert_eq!(*layout.layers(), before);
|
|
layout.start_drag([200.0, 200.0]);
|
|
assert_eq!(
|
|
layout.drag_to_snapped([83.0, 200.0], Snapping::default(), 6.0),
|
|
[None; 2]
|
|
);
|
|
assert_eq!(layout.layers()[0].x, 3.0);
|
|
}
|
|
#[test]
|
|
fn pixel_snap_can_be_disabled_and_numeric_entry_bypasses_it() {
|
|
let mut layout = Layout::default();
|
|
let mut g = layout.layers()[1];
|
|
g.x = 1160.25;
|
|
layout.apply(1, g).unwrap();
|
|
for pixels in [false, true] {
|
|
layout.start_drag([1200.0, 200.0]);
|
|
layout.drag_to_snapped(
|
|
[1200.2, 200.0],
|
|
Snapping {
|
|
enabled: true,
|
|
pixels,
|
|
screen_edges: false,
|
|
layer_edges: false,
|
|
},
|
|
6.0,
|
|
);
|
|
assert!((layout.layers()[1].x - if pixels { 1160.0 } else { 1160.45 }).abs() < 1e-8);
|
|
layout.cancel_drag();
|
|
assert_eq!(layout.layers()[1], g);
|
|
}
|
|
}
|
|
#[test]
|
|
fn resize_snaps_to_screen_keeps_anchor_and_undo() {
|
|
use midra_layout::ResizeHandle;
|
|
let mut layout = Layout::default();
|
|
layout.select(Some(0));
|
|
let before = layout.layers().clone();
|
|
let g = before[0];
|
|
layout.start_handle_resize(
|
|
0,
|
|
ResizeHandle::Right,
|
|
[g.x + g.width, g.y + g.height / 2.0],
|
|
true,
|
|
);
|
|
let guides = layout.drag_to_snapped(
|
|
[1918.0, g.y + g.height / 2.0],
|
|
Snapping {
|
|
enabled: true,
|
|
pixels: false,
|
|
screen_edges: true,
|
|
layer_edges: false,
|
|
},
|
|
6.0,
|
|
);
|
|
let next = layout.layers()[0];
|
|
assert_eq!(guides, [Some(1920.0), None]);
|
|
assert_eq!(next.x, g.x);
|
|
assert_eq!(next.x + next.width, 1920.0);
|
|
assert!((next.width / next.height - g.width / g.height).abs() < 1e-9);
|
|
layout.finish_drag();
|
|
layout.undo();
|
|
assert_eq!(*layout.layers(), before);
|
|
}
|
|
#[test]
|
|
fn resize_can_bypass_snapping_and_cancel() {
|
|
use midra_layout::ResizeHandle;
|
|
let mut layout = Layout::default();
|
|
layout.select(Some(0));
|
|
let g = layout.layers()[0];
|
|
layout.start_handle_resize(0, ResizeHandle::Top, [g.x + g.width / 2.0, g.y], false);
|
|
let options = Snapping {
|
|
enabled: true,
|
|
pixels: false,
|
|
screen_edges: true,
|
|
layer_edges: false,
|
|
};
|
|
assert_eq!(
|
|
layout.drag_to_snapped([g.x + g.width / 2.0, 2.0], options, 6.0),
|
|
[None, Some(0.0)]
|
|
);
|
|
assert_eq!(
|
|
layout.layers()[0].y + layout.layers()[0].height,
|
|
g.y + g.height
|
|
);
|
|
layout.drag_to_snapped(
|
|
[g.x + g.width / 2.0, 2.0],
|
|
Snapping {
|
|
enabled: false,
|
|
..options
|
|
},
|
|
6.0,
|
|
);
|
|
assert_eq!(layout.layers()[0].y, 2.0);
|
|
layout.cancel_drag();
|
|
assert_eq!(layout.layers()[0], g);
|
|
}
|
|
|
|
#[test]
|
|
fn ratio_locked_corners_reach_fractional_layer_edges() {
|
|
use midra_layout::{Corner, ResizeHandle};
|
|
for corner in [
|
|
Corner::TopLeft,
|
|
Corner::TopRight,
|
|
Corner::BottomLeft,
|
|
Corner::BottomRight,
|
|
] {
|
|
let mut layout = Layout::default();
|
|
let mut target = layout.layers()[1];
|
|
target.x = 900.25;
|
|
layout.apply(1, target).unwrap();
|
|
layout.select(Some(0));
|
|
let g = layout.layers()[0];
|
|
let handle = ResizeHandle::Corner(corner);
|
|
let start = ResizeHandle::positions(g)
|
|
.into_iter()
|
|
.find(|(h, _)| *h == handle)
|
|
.unwrap()
|
|
.1;
|
|
let left = matches!(corner, Corner::TopLeft | Corner::BottomLeft);
|
|
let target_x = if left { 0.0 } else { target.x };
|
|
layout.start_handle_resize(0, handle, start, true);
|
|
// Move along the aspect-ratio diagonal to just inside the snap radius.
|
|
let dx = target_x - start[0] + if left { 2.0 } else { -2.0 };
|
|
let same_sign = matches!(corner, Corner::TopLeft | Corner::BottomRight);
|
|
let point = [
|
|
start[0] + dx,
|
|
start[1] + dx * g.height / g.width * if same_sign { 1.0 } else { -1.0 },
|
|
];
|
|
let guides = layout.drag_to_snapped(
|
|
point,
|
|
Snapping {
|
|
enabled: true,
|
|
pixels: false,
|
|
screen_edges: true,
|
|
layer_edges: true,
|
|
},
|
|
6.0,
|
|
);
|
|
let next = layout.layers()[0];
|
|
let edge = if left { next.x } else { next.x + next.width };
|
|
assert!((edge - target_x).abs() < 1e-6, "{corner:?}: {edge}");
|
|
assert_eq!(guides[0], Some(target_x));
|
|
assert!((next.width / next.height - g.width / g.height).abs() < 1e-9);
|
|
}
|
|
}
|