diff --git a/crates/midra-layout/src/gui.rs b/crates/midra-layout/src/gui.rs index 138dc40..832f90f 100644 --- a/crates/midra-layout/src/gui.rs +++ b/crates/midra-layout/src/gui.rs @@ -3,7 +3,7 @@ use super::*; mod format_ui; use format_ui::{FormatDraft, OutputDraft}; use midra_layout::import::{DetectedShape, ImportDocument, parse_svg, parse_values}; -use midra_layout::{AlignTarget, Alignment, Corner, Geometry, Layout, ResizeHandle}; +use midra_layout::{AlignTarget, Alignment, Corner, Geometry, Layout, ResizeHandle, ResizeMode}; pub struct Editor { layout: Layout, @@ -18,6 +18,7 @@ pub struct Editor { marquee: Option, align_target: AlignTarget, keep_aspect_ratio: bool, + resize_mode: ResizeMode, format_draft: Option, output_draft: Option, edit_content: bool, @@ -170,6 +171,7 @@ impl Default for Editor { marquee: None, align_target: AlignTarget::Selection, keep_aspect_ratio: true, + resize_mode: ResizeMode::Individual, format_draft: None, output_draft: None, edit_content: false, @@ -271,6 +273,9 @@ impl Editor { self.reference_open = open; } fn sync(&mut self) { + if self.layout.selected_indices().len() < 2 { + self.resize_mode = ResizeMode::Individual; + } if let Some(i) = self.layout.selected() { let g = self.layout.layers()[i]; let [x, y] = self.corner.offsets_on(g, self.layout.formats().output); @@ -432,6 +437,7 @@ impl Editor { } if ctx.input(|i| i.key_pressed(egui::Key::Escape)) { self.edit_content = false; + self.resize_mode = ResizeMode::Individual; self.layout.cancel_drag(); if let Some(m) = self.marquee.take() { self.layout.set_selection(m.previous); @@ -980,14 +986,49 @@ impl Editor { 12.0, MUTED, ); - ink.text( - 0.0, - 263.0, - "Alignment changes position, never size.", - 12.0, - MUTED, + ui.scope_builder( + egui::UiBuilder::new().max_rect(Rect::from_min_size( + ink.point(0.0, 254.0), + Vec2::new(w, 34.0), + )), + |ui| { + egui::ComboBox::from_id_salt("resize-selected-mode") + .width(w - 12.0) + .selected_text(match self.resize_mode { + ResizeMode::Individual => "Resize: individual layer", + ResizeMode::Same => "Same resize", + ResizeMode::Mirror => "Mirror resize", + }) + .show_ui(ui, |ui| { + ui.selectable_value( + &mut self.resize_mode, + ResizeMode::Individual, + "Resize: individual layer", + ); + ui.selectable_value(&mut self.resize_mode, ResizeMode::Same, "Same resize"); + ui.add_enabled_ui(self.layout.selected_indices().len() == 2, |ui| { + ui.selectable_value( + &mut self.resize_mode, + ResizeMode::Mirror, + "Mirror resize (two layers)", + ); + }); + }); + }, ); - ink.text(0.0, 286.0, "A reference layer stays fixed.", 12.0, MUTED); + ui.put(Rect::from_min_size(ink.point(0.0, 292.0), Vec2::new(w, 52.0)), egui::Label::new(egui::RichText::new( + match self.resize_mode { + ResizeMode::Individual => "Choose Same or Mirror, then drag a selected layer's handle to resize the selection.", + ResizeMode::Same => "Matching handles, equal proportional scaling. Drag any selected handle. Escape exits.", + ResizeMode::Mirror => "Opposite handles, equal proportional scaling. Exactly two layers. Escape exits.", + } + ).size(12.0).color(MUTED)).wrap().halign(egui::Align::Min)); + let shifted = Ink { + painter: ink.painter.clone(), + origin: ink.origin + Vec2::new(0.0, 42.0), + scale: ink.scale, + }; + let ink = &shifted; ink.line([0.0, 319.0], [w, 319.0], LINE); ink.text(0.0, 341.0, "VISIBLE BOX / CENTER POSITIONS", 11.0, CYAN); for (row, i) in self.layout.selected_indices().into_iter().enumerate() { @@ -1009,7 +1050,7 @@ impl Editor { ink.text( 0.0, 609.0, - "Select one layer to edit its size; paste accepts the full selection.", + "Numeric edits require one selected layer.", 12.0, MUTED, ); @@ -1321,8 +1362,15 @@ impl Editor { self.layout.start_content_drag(i, point); } } else if let Some((i, corner)) = handle.filter(|_| !shift) { - self.layout - .start_handle_resize(i, corner, point, self.keep_aspect_ratio); + if let Err(e) = self.layout.start_selected_resize( + i, + corner, + point, + self.keep_aspect_ratio, + self.resize_mode, + ) { + self.layout.gesture_error = Some(e); + } } else if shift || self.layout.hit(point).is_none() { let previous = self.layout.selection_mask(); let base = if shift { previous } else { [false; 2] }; @@ -1387,8 +1435,13 @@ impl Editor { self.layout.toggle(i); } } else { - self.layout.select(hit); + if self.resize_mode == ResizeMode::Individual + || hit.is_none_or(|i| !self.layout.selection_mask()[i]) + { + self.layout.select(hit); + } if response.double_clicked_by(egui::PointerButton::Primary) && hit.is_some() { + self.layout.select(hit); self.edit_content = true; } } @@ -1593,7 +1646,11 @@ impl Editor { ink.text( 24.0, r.height() - 57.0, - "Corners resize · Side handles keep opposite edge fixed · Shift-click selects", + match self.resize_mode { + ResizeMode::Individual => "Corners resize · Side handles keep opposite edge fixed · Shift-click selects", + ResizeMode::Same => "Same resize · Matching handles scale selected layers proportionally · Escape exits", + ResizeMode::Mirror => "Mirror resize · Opposite handles scale both layers proportionally · Escape exits", + }, 12.0, MUTED, ); @@ -2246,6 +2303,61 @@ mod tests { assert_eq!(app.layout.layers()[1], g); } #[test] + fn selected_resize_mode_control_keeps_selection_during_handle_drag() { + for (title, mode) in [ + ("Same resize", ResizeMode::Same), + ("Mirror resize (two layers)", ResizeMode::Mirror), + ] { + let mut app = Editor::default(); + app.layout.set_selection([true; 2]); + let ctx = egui::Context::default(); + frame(&mut app, &ctx, vec![]); + for text in ["Resize: individual layer", title] { + let output = frame(&mut app, &ctx, vec![]); + let pos = output + .shapes + .iter() + .find_map(|s| match &s.shape { + egui::epaint::Shape::Text(t) if t.galley.job.text == text => { + Some(t.pos + Vec2::new(12.0, 6.0)) + } + _ => None, + }) + .unwrap(); + frame( + &mut app, + &ctx, + vec![egui::Event::PointerMoved(pos), mouse(pos, true)], + ); + frame(&mut app, &ctx, vec![mouse(pos, false)]); + } + assert_eq!(app.resize_mode, mode); + let before = *app.layout.layers(); + let output = frame(&mut app, &ctx, vec![]); + let start = layer_rects(&output)[1].right_center(); + let end = start + Vec2::new(20.0, 0.0); + frame( + &mut app, + &ctx, + vec![egui::Event::PointerMoved(start), mouse(start, true)], + ); + frame(&mut app, &ctx, vec![egui::Event::PointerMoved(end)]); + frame(&mut app, &ctx, vec![mouse(end, false)]); + assert_eq!(app.layout.selection_mask(), [true; 2]); + assert!( + app.layout + .layers() + .iter() + .zip(before) + .all(|(g, old)| g.width > old.width) + ); + app.layout.undo(); + assert_eq!(*app.layout.layers(), before); + frame(&mut app, &ctx, vec![key(egui::Key::Escape)]); + assert_eq!(app.resize_mode, ResizeMode::Individual); + } + } + #[test] fn side_handle_hit_regions_resize_at_multiple_zoom_levels() { for zoom in [0.6, 1.0] { for side in 0..4 { diff --git a/crates/midra-layout/src/lib.rs b/crates/midra-layout/src/lib.rs index a1d465e..217ab2a 100644 --- a/crates/midra-layout/src/lib.rs +++ b/crates/midra-layout/src/lib.rs @@ -21,7 +21,30 @@ pub enum ResizeHandle { Left, Right, } +/// How a handle drag affects selected layers. +#[derive(Clone, Copy, Debug, Default, PartialEq)] +pub enum ResizeMode { + #[default] + Individual, + Same, + Mirror, +} impl ResizeHandle { + pub fn opposite(self) -> Self { + match self { + Self::Top => Self::Bottom, + Self::Bottom => Self::Top, + Self::Left => Self::Right, + Self::Right => Self::Left, + Self::Corner(corner) => Self::Corner(match corner { + Corner::TopLeft => Corner::BottomRight, + Corner::TopRight => Corner::BottomLeft, + Corner::BottomLeft => Corner::TopRight, + Corner::BottomRight => Corner::TopLeft, + }), + } + } + pub fn positions(g: Geometry) -> [(Self, [f64; 2]); 8] { let [cx, cy] = g.center(); [ @@ -39,6 +62,99 @@ impl ResizeHandle { ] } } +fn resized_geometry( + original: Geometry, + handle: ResizeHandle, + delta: [f64; 2], + keep_ratio: bool, +) -> Geometry { + let left = matches!( + handle, + ResizeHandle::Corner(Corner::TopLeft | Corner::BottomLeft) | ResizeHandle::Left + ); + let top = matches!( + handle, + ResizeHandle::Corner(Corner::TopLeft | Corner::TopRight) | ResizeHandle::Top + ); + let dx = delta[0].round() * if left { -1.0 } else { 1.0 }; + let dy = delta[1].round() * if top { -1.0 } else { 1.0 }; + let side = !matches!(handle, ResizeHandle::Corner(_)); + let horizontal = matches!(handle, ResizeHandle::Left | ResizeHandle::Right); + let (width, height) = if side { + if horizontal { + let width = (original.width + dx).max(if keep_ratio { + (original.width / original.height).max(1.0) + } else { + 1.0 + }); + ( + width, + if keep_ratio { + width * original.height / original.width + } else { + original.height + }, + ) + } else { + let height = (original.height + dy).max(if keep_ratio { + (original.height / original.width).max(1.0) + } else { + 1.0 + }); + ( + if keep_ratio { + height * original.width / original.height + } else { + original.width + }, + height, + ) + } + } else if keep_ratio { + let factor = ((original.width * (original.width + dx) + + original.height * (original.height + dy)) + / (original.width * original.width + original.height * original.height)) + .max((1.0 / original.width).max(1.0 / original.height)); + (original.width * factor, original.height * factor) + } else { + ( + (original.width + dx).max(1.0), + (original.height + dy).max(1.0), + ) + }; + anchored_resize(original, handle, width, height) +} +fn anchored_resize(original: Geometry, handle: ResizeHandle, width: f64, height: f64) -> Geometry { + let side = !matches!(handle, ResizeHandle::Corner(_)); + let horizontal = matches!(handle, ResizeHandle::Left | ResizeHandle::Right); + let left = matches!( + handle, + ResizeHandle::Left | ResizeHandle::Corner(Corner::TopLeft | Corner::BottomLeft) + ); + let top = matches!( + handle, + ResizeHandle::Top | ResizeHandle::Corner(Corner::TopLeft | Corner::TopRight) + ); + Geometry { + x: if side && !horizontal { + original.center()[0] - width / 2.0 + } else if left { + original.x + original.width - width + } else { + original.x + }, + y: if side && horizontal { + original.center()[1] - height / 2.0 + } else if top { + original.y + original.height - height + } else { + original.y + }, + width, + height, + } +} + /// Visible layer bounds, in output screen pixels. No crop or camera transform. #[derive(Clone, Copy, Debug, PartialEq)] pub struct Geometry { @@ -170,6 +286,8 @@ pub struct Layout { } #[derive(Clone)] struct Resize { + mode: ResizeMode, + targets: [bool; 2], index: usize, handle: ResizeHandle, before: Snapshot, @@ -645,6 +763,8 @@ impl Layout { } self.select(Some(index)); self.resize = Some(Resize { + mode: ResizeMode::Individual, + targets: self.selected, index, handle, before: self.snapshot(), @@ -652,6 +772,41 @@ impl Layout { keep_ratio, }); } + /// Start proportional resizing from matching or opposite handles, without changing selection. + pub fn start_selected_resize( + &mut self, + index: usize, + handle: ResizeHandle, + point: [f64; 2], + keep_ratio: bool, + mode: ResizeMode, + ) -> Result<(), String> { + if mode == ResizeMode::Individual { + self.start_handle_resize(index, handle, point, keep_ratio); + return Ok(()); + } + let count = self.selected_indices().len(); + if count < 2 || (mode == ResizeMode::Mirror && count != 2) { + return Err( + "Select at least two layers for Same resize, or exactly two for Mirror resize." + .into(), + ); + } + if !self.selectable(index) || !self.selected.get(index).copied().unwrap_or(false) { + return Err("Resize from a selected, visible, unlocked layer.".into()); + } + self.finish_drag(); + self.resize = Some(Resize { + mode, + targets: self.selected, + index, + handle, + before: self.snapshot(), + start: point, + keep_ratio, + }); + Ok(()) + } pub fn drag_to(&mut self, point: [f64; 2]) { if point.iter().any(|v| !v.is_finite()) { return; @@ -677,85 +832,52 @@ impl Layout { } if let Some(r) = &self.resize { let original = r.before.layers[r.index]; - let left = matches!( + let next = resized_geometry( + original, r.handle, - ResizeHandle::Corner(Corner::TopLeft | Corner::BottomLeft) | ResizeHandle::Left + [point[0] - r.start[0], point[1] - r.start[1]], + r.keep_ratio, ); - let top = matches!( - r.handle, - ResizeHandle::Corner(Corner::TopLeft | Corner::TopRight) | ResizeHandle::Top - ); - let dx = (point[0] - r.start[0]).round() * if left { -1.0 } else { 1.0 }; - let dy = (point[1] - r.start[1]).round() * if top { -1.0 } else { 1.0 }; - let side = !matches!(r.handle, ResizeHandle::Corner(_)); - let horizontal = matches!(r.handle, ResizeHandle::Left | ResizeHandle::Right); - let (width, height) = if side { - if horizontal { - let width = (original.width + dx).max(if r.keep_ratio { - (original.width / original.height).max(1.0) - } else { - 1.0 - }); - ( - width, - if r.keep_ratio { - width * original.height / original.width - } else { - original.height - }, - ) - } else { - let height = (original.height + dy).max(if r.keep_ratio { - (original.height / original.width).max(1.0) - } else { - 1.0 - }); - ( - if r.keep_ratio { - height * original.width / original.height - } else { - original.width - }, - height, - ) + let result = (|| { + let mut layers = r.before.layers; + let mut formats = r.before.formats; + let mut sx = next.width / original.width; + let mut sy = next.height / original.height; + if r.mode != ResizeMode::Individual { + for (i, g) in layers.iter().enumerate() { + if r.targets[i] { + sx = sx.max(1.0 / g.width); + sy = sy.max(1.0 / g.height); + } + } + if r.keep_ratio { + sx = sx.max(sy); + sy = sx; + } } - } else if r.keep_ratio { - let factor = ((original.width * (original.width + dx) - + original.height * (original.height + dy)) - / (original.width * original.width + original.height * original.height)) - .max((1.0 / original.width).max(1.0 / original.height)); - (original.width * factor, original.height * factor) - } else { - ( - (original.width + dx).max(1.0), - (original.height + dy).max(1.0), - ) - }; - let next = Geometry { - x: if side && !horizontal { - original.center()[0] - width / 2.0 - } else if left { - original.x + original.width - width - } else { - original.x - }, - y: if side && horizontal { - original.center()[1] - height / 2.0 - } else if top { - original.y + original.height - height - } else { - original.y - }, - width, - height, - }; - let mut formats = r.before.formats; - match next - .validate() - .and_then(|_| formats.resize(r.index, original, next)) - { - Ok(()) => { - self.layers[r.index] = next; + for (i, geometry) in layers.iter_mut().enumerate() { + if !r.targets[i] { + continue; + } + let before = *geometry; + let handle = if r.mode == ResizeMode::Mirror && i != r.index { + r.handle.opposite() + } else { + r.handle + }; + *geometry = if r.mode == ResizeMode::Individual { + next + } else { + anchored_resize(before, handle, before.width * sx, before.height * sy) + }; + geometry.validate()?; + formats.resize(i, before, *geometry)?; + } + Ok::<_, String>((layers, formats)) + })(); + match result { + Ok((layers, formats)) => { + self.layers = layers; self.formats = formats; self.gesture_error = None; } diff --git a/crates/midra-layout/tests/positioning.rs b/crates/midra-layout/tests/positioning.rs index 47a4479..6d87290 100644 --- a/crates/midra-layout/tests/positioning.rs +++ b/crates/midra-layout/tests/positioning.rs @@ -719,3 +719,141 @@ fn corner_alignment_to_unselected_reference_is_one_undo_step() { 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] { + 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(); + let formats = *l.formats(); + 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(); + 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 mode == M::Mirror && i != initiator { + handle.opposite() + } 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(); + let formats = *l.formats(); + 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() + ); +} diff --git a/docs/midra-layout.md b/docs/midra-layout.md index beefca4..21f0a7d 100644 --- a/docs/midra-layout.md +++ b/docs/midra-layout.md @@ -141,6 +141,26 @@ clipboard testing against a running draw.io instance remains to be done. offsets are not copied. Crop zoom is included separately as a percentage and can be toggled on paste. This is not a native WebRCS clipboard payload. +## Resize selected layers together + +Select multiple layers, then choose **Same resize** or **Mirror resize** in the +right-hand inspector’s resize dropdown. Drag a corner or side handle on any +selected layer to scale the selection together. Both modes use **equal +proportional scaling**, not equal pixel additions: a 10% width increase applies +to every selected layer’s own width. + +- **Same resize** uses the matching handle on every layer. +- **Mirror resize** requires exactly two layers. The other layer uses the opposite + handle: right/left, top/bottom, and diagonally opposite corners. +- Each layer keeps the opposite edge or corner fixed. With aspect ratio locked, + both dimensions use the same scale; otherwise width and height scale + independently. Side handles affect only their axis when the ratio is unlocked. +- Minimum sizes constrain the shared scale. Invalid geometry rejects the whole + update. Crops adjust with sizing, and one Undo restores all layers and crops. +- **Escape** cancels an active drag and exits the mode. Choose **Resize: individual + layer** to return to normal handles; reducing the selection below two also + leaves group resize. Locking/hiding during a drag cancels the entire gesture. + ## Align selected layers Open the **Align selected layers** icon menu beside the view/history toolbar. @@ -158,7 +178,8 @@ only their axis; corner buttons change both axes. Hover an icon for its label. Every action preserves layer sizes and is one undo step, including corner moves. The menu also works with one selected layer and a different reference layer. The inspector lists each selected layer's resulting center coordinates; select -exactly one layer to resize. Paste/import accepts the full selection. +one layer for numeric size editing, or use Same/Mirror resize for the selection. +Paste/import accepts the full selection. Text inputs receive normal text paste and arrow navigation while focused; they never interpret these actions as geometry import or layer movement. Paste preview