use midra_layout::{Corner, Geometry, Layout, parse_drawio}; const SAMPLE: &str = include_str!("fixtures/drawio-rectangle.txt"); fn xml(body: &str) -> String { format!( r#"{body}"# ) } fn vertex(geometry: &str, style: &str) -> String { xml(&format!( r#"{geometry}"# )) } 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#""#, "rounded=0;"); let a = parse_drawio(&raw).unwrap()[0].geometry; assert_eq!([a.x, a.y], [0.0, 0.0]); let raw = vertex( r#""#, "", ); 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#""#, ); let list = parse_drawio(&data).unwrap(); assert_eq!( list.iter().map(|s| s.id.as_str()).collect::>(), vec!["9", "2"] ); } #[test] fn invalid_clipboard_is_rejected_without_panicking() { for s in [ "", "%", "%3", "%GG", "%ff", "not geometry", "", "", "", "", ] { assert!(parse_drawio(s).is_err(), "{s}"); } assert!(parse_drawio(&"x".repeat(1_048_577)).is_err()); assert!( parse_drawio( r#"]>&e;"# ) .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!(""), "")).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#""#, style)).is_err()); } for geometry in [ r#""#, r#""#, r#""#, ] { assert!(parse_drawio(&vertex(geometry, "")).is_err()); } for body in [ r#""#, r#""#, r#""#, r#""#, r#""#, ] { assert!(parse_drawio(&xml(body)).is_err()); } } #[test] fn percent_decoding_is_once_and_does_not_treat_plus_as_space() { let raw = vertex(r#""#, ""); 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#""#, 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#""#, style)).is_err()); } let shape = parse_drawio(&vertex( r#""#, "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#""#, ); 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 midra_layout::{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 midra_layout::{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 midra_layout::{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( midra_layout::Alignment::Left, midra_layout::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 midra_layout::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 midra_layout::{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 midra_layout::{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 midra_layout::{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 midra_layout::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 midra_layout::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 midra_layout::{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] ); }