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

309 lines
9.9 KiB
Rust

use canvas_pilot::{
Geometry, Layout,
formats::{Crop, LayerFit},
project::Project,
};
fn box_geometry() -> Geometry {
Geometry {
x: 560.0,
y: 240.0,
width: 800.0,
height: 600.0,
}
}
fn near(a: f64, b: f64) {
assert!((a - b).abs() < 1e-7, "{a} != {b}");
}
#[test]
fn four_modes_apply_after_crop_and_center_the_image() {
let g = box_geometry();
for (mode, size, offset) in [
(LayerFit::OneToOne, [1920.0, 1080.0], [-560.0, -240.0]),
(LayerFit::Centered, [800.0, 450.0], [0.0, 75.0]),
(LayerFit::Fullscreen, [800.0, 600.0], [0.0, 0.0]),
(
LayerFit::Cropped,
[1066.6666666666667, 600.0],
[-133.33333333333334, 0.0],
),
] {
let image = mode.image([1920.0, 1080.0], g).unwrap();
near(image.width, size[0]);
near(image.height, size[1]);
near(image.x, g.x + offset[0]);
near(image.y, g.y + offset[1]);
// Removing 480 pixels produces 4:3 content, so fit/fill/stretch converge.
let retained = Crop {
left: 480.0,
..Default::default()
}
.remaining([1920.0, 1080.0])
.unwrap();
if mode != LayerFit::OneToOne {
assert_eq!(mode.image(retained, g).unwrap(), g);
}
}
let small = LayerFit::OneToOne.image([640.0, 360.0], g).unwrap();
assert_eq!(
small,
Geometry {
x: 640.0,
y: 360.0,
width: 640.0,
height: 360.0
}
);
let odd = LayerFit::Centered
.image(
[1920.0, 1080.0],
Geometry {
width: 801.0,
height: 601.0,
..g
},
)
.unwrap();
near(odd.height, 450.5625);
near(odd.y, g.y + 75.21875);
assert!(LayerFit::Centered.image([0.0, 1080.0], g).is_err());
}
#[test]
fn explicit_fit_survives_resize_undo_reordering_and_project_roundtrip() {
let mut layout = Layout::default();
let crop = Crop {
left: 120.0,
top: 60.0,
..Default::default()
};
layout
.set_layer_fit(0, Some(LayerFit::OneToOne), crop)
.unwrap();
layout.apply(0, box_geometry()).unwrap();
assert_eq!(layout.formats().advanced[0], crop);
let before = Project::from_layout(&layout);
assert_eq!(before.version, 15);
let loaded = Project::from_json(&before.to_json().unwrap()).unwrap();
assert_eq!(loaded, before);
assert_eq!(
loaded.layout().unwrap().formats().layer_fit[0],
Some(LayerFit::OneToOne)
);
let id = layout.layer_info(0).id;
layout.move_layer(id, 1).unwrap();
assert_eq!(layout.formats().layer_fit[1], Some(LayerFit::OneToOne));
layout.undo();
layout.set_layer_fit(0, None, crop).unwrap();
assert_eq!(layout.formats().layer_fit[0], None);
assert!(layout.formats().mapping(0, layout.layers()[0]).is_ok());
layout.undo();
assert_eq!(layout.formats().layer_fit[0], Some(LayerFit::OneToOne));
assert_eq!(layout.formats().advanced[0], crop);
}
#[test]
fn v13_migration_defaults_to_normal_crop_and_v14_requires_valid_fit() {
let text = include_str!("../../../docs/interfaces/canvas-pilot-v13.example.json");
let migrated = Project::from_json(text).unwrap();
assert_eq!(migrated.version, 15);
assert!(migrated.layers.iter().all(|l| l.layer_fit.is_none()));
let mut json = serde_json::to_value(&migrated).unwrap();
json["layers"][0]
.as_object_mut()
.unwrap()
.remove("layer_fit");
assert!(Project::from_json(&json.to_string()).is_err());
json["layers"][0]["layer_fit"] = "input_setting".into();
assert!(Project::from_json(&json.to_string()).is_err());
}
#[test]
fn current_documented_example_is_valid() {
let p = Project::from_json(include_str!(
"../../../docs/interfaces/canvas-pilot-v14.example.json"
))
.unwrap();
assert_eq!(p.version, 15);
p.layout().unwrap();
}
#[test]
fn one_to_one_handles_trim_source_edges_without_zoom_and_undo_atomically() {
use canvas_pilot::{Corner, ResizeHandle};
let g = box_geometry();
for (handle, delta, changes) in [
(ResizeHandle::Left, [25.0, 99.0], [50.0, 0.0, 0.0, 0.0]),
(ResizeHandle::Right, [-25.0, 99.0], [0.0, 50.0, 0.0, 0.0]),
(ResizeHandle::Top, [99.0, 15.0], [0.0, 0.0, 30.0, 0.0]),
(ResizeHandle::Bottom, [99.0, -15.0], [0.0, 0.0, 0.0, 30.0]),
(
ResizeHandle::Corner(Corner::TopLeft),
[25.0, 15.0],
[50.0, 0.0, 30.0, 0.0],
),
(
ResizeHandle::Corner(Corner::TopRight),
[-25.0, 15.0],
[0.0, 50.0, 30.0, 0.0],
),
(
ResizeHandle::Corner(Corner::BottomLeft),
[25.0, -15.0],
[50.0, 0.0, 0.0, 30.0],
),
(
ResizeHandle::Corner(Corner::BottomRight),
[-25.0, -15.0],
[0.0, 50.0, 0.0, 30.0],
),
] {
let mut layout = Layout::default();
layout.apply(0, g).unwrap();
layout.select(Some(0));
let initial = Crop {
left: 100.0,
right: 80.0,
top: 60.0,
bottom: 40.0,
};
layout
.set_layer_fit(0, Some(LayerFit::OneToOne), initial)
.unwrap();
let before = Project::from_layout(&layout);
let input = layout.formats().input(0).unwrap();
let image = LayerFit::OneToOne
.image(initial.remaining(input).unwrap(), g)
.unwrap();
let start = ResizeHandle::positions(image)
.into_iter()
.find(|(h, _)| *h == handle)
.unwrap()
.1;
layout.start_content_resize(0, handle, start);
layout.use_resize_pivot(true); // 1:1 never scales about a pivot.
layout.drag_to([start[0] + delta[0] / 2.0, start[1] + delta[1] / 2.0]);
layout.drag_to([start[0] + delta[0], start[1] + delta[1]]);
layout.finish_drag();
let crop = layout.formats().advanced[0];
assert_eq!(
[crop.left, crop.right, crop.top, crop.bottom],
[
100.0 + changes[0],
80.0 + changes[1],
60.0 + changes[2],
40.0 + changes[3]
]
);
assert_eq!(layout.layers()[0], g);
let retained = crop.remaining(input).unwrap();
let fitted = LayerFit::OneToOne.image(retained, g).unwrap();
assert_eq!([fitted.width, fitted.height], retained);
assert_eq!(fitted.center(), g.center());
let after = Project::from_layout(&layout);
layout.undo();
assert_eq!(Project::from_layout(&layout), before);
layout.redo();
assert_eq!(Project::from_layout(&layout), after);
layout.start_content_resize(0, handle, start);
layout.drag_to([start[0] + 100.0, start[1] + 100.0]);
layout.cancel_drag();
assert_eq!(Project::from_layout(&layout), after);
}
}
#[test]
fn one_to_one_crop_stops_at_source_limits_and_uncropped_image_cannot_move() {
use canvas_pilot::ResizeHandle;
let mut layout = Layout::default();
layout.select(Some(0));
layout
.set_layer_fit(0, Some(LayerFit::OneToOne), Crop::default())
.unwrap();
let input = layout.formats().input(0).unwrap();
layout.start_content_resize(0, ResizeHandle::Left, [0.0, 0.0]);
layout.drag_to([100000.0, 0.0]);
let crop = layout.formats().advanced[0];
near(crop.remaining(input).unwrap()[0], 0.001);
layout.drag_to([-100000.0, 0.0]);
assert_eq!(layout.formats().advanced[0], Crop::default());
layout.finish_drag();
layout.start_content_drag(0, [0.0, 0.0]);
layout.drag_to([50.0, -50.0]);
layout.finish_drag();
assert_eq!(layout.formats().advanced[0], Crop::default());
layout
.set_layer_fit(0, Some(LayerFit::Centered), Crop::default())
.unwrap();
layout.start_content_resize(0, ResizeHandle::Left, [0.0, 0.0]);
assert!(!layout.dragging());
}
#[test]
fn one_to_one_pan_preserves_crop_size_and_clamps_each_axis_with_undo_cancel() {
let mut layout = Layout::default();
layout.select(Some(0));
let crop = Crop {
left: 100.0,
right: 80.0,
top: 60.0,
bottom: 40.0,
};
layout
.set_layer_fit(0, Some(LayerFit::OneToOne), crop)
.unwrap();
let before = Project::from_layout(&layout);
let input = layout.formats().input(0).unwrap();
let g = layout.layers()[0];
layout.start_content_drag(0, [500.0, 400.0]);
layout.drag_to([510.0, 395.0]);
layout.drag_to([520.0, 390.0]);
layout.finish_drag();
assert_eq!(
layout.formats().advanced[0],
Crop {
left: 80.0,
right: 100.0,
top: 70.0,
bottom: 30.0
}
);
assert_eq!(
layout.formats().advanced[0].remaining(input).unwrap(),
crop.remaining(input).unwrap()
);
assert_eq!(layout.layers()[0], g);
assert_eq!(layout.formats().mapping(0, g).unwrap().scale, 1.0);
let after = Project::from_layout(&layout);
layout.undo();
assert_eq!(Project::from_layout(&layout), before);
layout.redo();
assert_eq!(Project::from_layout(&layout), after);
layout.start_content_drag(0, [0.0, 0.0]);
layout.drag_to([100000.0, -100000.0]);
assert_eq!(
layout.formats().advanced[0],
Crop {
left: 0.0,
right: 180.0,
top: 100.0,
bottom: 0.0
}
);
// Moving back uses the gesture's starting crop, so clamping cannot accumulate drift.
layout.drag_to([-100000.0, 100000.0]);
assert_eq!(
layout.formats().advanced[0],
Crop {
left: 180.0,
right: 0.0,
top: 0.0,
bottom: 100.0
}
);
layout.cancel_drag();
assert_eq!(Project::from_layout(&layout), after);
assert!(crop.pan_image([f64::NAN, 0.0]).is_err());
}