190 lines
6.7 KiB
Rust
190 lines
6.7 KiB
Rust
use midra_layout::{Geometry, Layout, ResizeHandle, ResizeMode, snapping::Snapping};
|
|
|
|
fn near(a: f64, b: f64) {
|
|
assert!((a - b).abs() < 1e-7, "{a} != {b}");
|
|
}
|
|
fn pivot(g: Geometry, relative: [f64; 2]) -> [f64; 2] {
|
|
[g.x + g.width * relative[0], g.y + g.height * relative[1]]
|
|
}
|
|
|
|
#[test]
|
|
fn all_handles_keep_custom_pivots_fixed_in_each_resize_mode() {
|
|
for mode in [
|
|
ResizeMode::Individual,
|
|
ResizeMode::Same,
|
|
ResizeMode::Mirror,
|
|
ResizeMode::Opposite,
|
|
] {
|
|
for ratio in [false, true] {
|
|
for relative in [[0.5, 0.5], [0.2, 0.7], [-0.25, 1.25]] {
|
|
for index in [0, 1] {
|
|
let mut layout = Layout::default();
|
|
layout
|
|
.apply(
|
|
1,
|
|
Geometry {
|
|
width: 320.0,
|
|
height: 240.0,
|
|
..layout.layers()[1]
|
|
},
|
|
)
|
|
.unwrap();
|
|
let before = layout.layers().clone();
|
|
for (handle, start) in ResizeHandle::positions(before[index]) {
|
|
layout.set_selection([true; 2]);
|
|
let formats = layout.formats().clone();
|
|
layout
|
|
.start_selected_resize(index, handle, start, ratio, mode)
|
|
.unwrap();
|
|
layout.set_resize_pivot(relative);
|
|
layout.use_resize_pivot(true);
|
|
layout.drag_to([start[0] + 17.0, start[1] + 11.0]);
|
|
for (i, original) in before.iter().enumerate() {
|
|
if mode == ResizeMode::Individual && i != index {
|
|
assert_eq!(layout.layers()[i], *original);
|
|
continue;
|
|
}
|
|
let mut rp = relative;
|
|
if i != index {
|
|
if matches!(mode, ResizeMode::Mirror | ResizeMode::Opposite) {
|
|
rp[0] = 1.0 - rp[0];
|
|
}
|
|
if mode == ResizeMode::Opposite {
|
|
rp[1] = 1.0 - rp[1];
|
|
}
|
|
}
|
|
let old = pivot(*original, rp);
|
|
let new = pivot(layout.layers()[i], rp);
|
|
near(old[0], new[0]);
|
|
near(old[1], new[1]);
|
|
if ratio {
|
|
near(
|
|
layout.layers()[i].width / layout.layers()[i].height,
|
|
original.width / original.height,
|
|
);
|
|
}
|
|
}
|
|
let resized = layout.layers().clone();
|
|
layout.finish_drag();
|
|
layout.undo();
|
|
assert_eq!(layout.layers(), &before);
|
|
assert_eq!(layout.formats(), &formats);
|
|
layout.redo();
|
|
assert_eq!(layout.layers(), &resized);
|
|
layout.undo();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pivot_toggle_recomputes_without_drift_and_degenerate_handles_stay_valid() {
|
|
let mut layout = Layout::default();
|
|
let before = layout.layers().clone();
|
|
layout.start_handle_resize(1, ResizeHandle::Right, [1800.0, 360.0], false);
|
|
for _ in 0..3 {
|
|
layout.use_resize_pivot(true);
|
|
layout.drag_to([1900.0, 360.0]);
|
|
near(layout.layers()[1].center()[0], before[1].center()[0]);
|
|
near(layout.layers()[1].width, 840.0);
|
|
layout.use_resize_pivot(false);
|
|
layout.drag_to([1900.0, 360.0]);
|
|
near(layout.layers()[1].x, before[1].x);
|
|
near(layout.layers()[1].width, 740.0);
|
|
}
|
|
layout.set_resize_pivot([1.0, 0.5]);
|
|
layout.use_resize_pivot(true);
|
|
layout.drag_to([1900.0, 360.0]);
|
|
assert_eq!(layout.layers(), &before);
|
|
layout.cancel_drag();
|
|
assert_eq!(layout.layers(), &before);
|
|
}
|
|
|
|
#[test]
|
|
fn pivot_resizing_preserves_screen_and_mirror_contact_snaps() {
|
|
for ratio in [false, true] {
|
|
let mut layout = Layout::default();
|
|
let before = layout.layers().clone();
|
|
layout.set_selection([true; 2]);
|
|
layout
|
|
.start_selected_resize(
|
|
0,
|
|
ResizeHandle::Right,
|
|
[760.0, 360.0],
|
|
ratio,
|
|
ResizeMode::Mirror,
|
|
)
|
|
.unwrap();
|
|
layout.set_resize_pivot([0.25, 0.6]);
|
|
layout.use_resize_pivot(true);
|
|
let guides = layout.drag_to_snapped(
|
|
[958.0, 360.0],
|
|
Snapping {
|
|
enabled: true,
|
|
..Default::default()
|
|
},
|
|
6.0,
|
|
);
|
|
assert_eq!(guides[0], Some(960.0));
|
|
near(
|
|
layout.layers()[0].x + layout.layers()[0].width,
|
|
layout.layers()[1].x,
|
|
);
|
|
near(
|
|
pivot(layout.layers()[0], [0.25, 0.6])[0],
|
|
pivot(before[0], [0.25, 0.6])[0],
|
|
);
|
|
layout.cancel_drag();
|
|
layout.start_handle_resize(1, ResizeHandle::Right, [1800.0, 360.0], ratio);
|
|
layout.use_resize_pivot(true);
|
|
let guides = layout.drag_to_snapped(
|
|
[1918.0, 360.0],
|
|
Snapping {
|
|
enabled: true,
|
|
..Default::default()
|
|
},
|
|
6.0,
|
|
);
|
|
assert_eq!(guides[0], Some(1920.0));
|
|
near(layout.layers()[1].center()[0], before[1].center()[0]);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn ratio_locked_corner_snaps_without_shifting_pivot() {
|
|
use midra_layout::Corner;
|
|
let mut layout = Layout::default();
|
|
let g = layout.layers()[1];
|
|
let relative = [0.2, 0.7];
|
|
let fixed = pivot(g, relative);
|
|
layout.start_handle_resize(
|
|
1,
|
|
ResizeHandle::Corner(Corner::BottomRight),
|
|
[1800.0, 540.0],
|
|
true,
|
|
);
|
|
layout.set_resize_pivot(relative);
|
|
layout.use_resize_pivot(true);
|
|
let point = [
|
|
1918.0,
|
|
540.0 + 118.0 * (540.0 - fixed[1]) / (1800.0 - fixed[0]),
|
|
];
|
|
let guides = layout.drag_to_snapped(
|
|
point,
|
|
Snapping {
|
|
enabled: true,
|
|
..Default::default()
|
|
},
|
|
6.0,
|
|
);
|
|
assert_eq!(guides[0], Some(1920.0));
|
|
near(pivot(layout.layers()[1], relative)[0], fixed[0]);
|
|
near(pivot(layout.layers()[1], relative)[1], fixed[1]);
|
|
near(
|
|
layout.layers()[1].width / layout.layers()[1].height,
|
|
g.width / g.height,
|
|
);
|
|
}
|