From e0fbb040868bb947e1de2da77ecb9976b3801a92 Mon Sep 17 00:00:00 2001 From: Dandaedre Date: Fri, 13 Nov 2026 12:24:27 +0100 Subject: [PATCH] Resize layers from corner handles with aspect ratio locking --- crates/midra-layout/src/gui.rs | 112 ++++++++++++++++++++++- crates/midra-layout/src/lib.rs | 78 +++++++++++++++- crates/midra-layout/tests/positioning.rs | 79 ++++++++++++++++ docs/midra-layout-plan.md | 5 + docs/midra-layout.md | 14 ++- 5 files changed, 283 insertions(+), 5 deletions(-) diff --git a/crates/midra-layout/src/gui.rs b/crates/midra-layout/src/gui.rs index effb1b0..7658763 100644 --- a/crates/midra-layout/src/gui.rs +++ b/crates/midra-layout/src/gui.rs @@ -12,6 +12,7 @@ pub struct Editor { panning: bool, marquee: Option, align_target: AlignTarget, + keep_aspect_ratio: bool, reference: Option, reference_open: bool, reference_error: String, @@ -60,6 +61,7 @@ impl Default for Editor { panning: false, marquee: None, align_target: AlignTarget::Selection, + keep_aspect_ratio: true, reference: None, reference_open: false, reference_error: String::new(), @@ -572,6 +574,20 @@ impl Editor { .font(egui::FontId::proportional(18.0)) .margin(Vec2::new(12.0, 10.0)), ); + if response.changed() + && self.keep_aspect_ratio + && index >= 2 + && let Ok(value) = self.fields[index].parse::() + && value.is_finite() + && value > 0.0 + { + let other = if index == 2 { + value * g.height / g.width + } else { + value * g.width / g.height + }; + self.fields[if index == 2 { 3 } else { 2 }] = number(other); + } if response.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)) { enter = true; } @@ -704,6 +720,23 @@ impl Editor { ); } } + fn resize_handle(&self, pointer: Pos2, origin: Pos2, scale: f32) -> Option<(usize, Corner)> { + for i in self.layout.selected_indices().into_iter().rev() { + let g = self.layout.layers()[i]; + for (corner, x, y) in [ + (Corner::TopLeft, g.x, g.y), + (Corner::TopRight, g.x + g.width, g.y), + (Corner::BottomLeft, g.x, g.y + g.height), + (Corner::BottomRight, g.x + g.width, g.y + g.height), + ] { + let center = origin + Vec2::new(x as f32, y as f32) * scale; + if Rect::from_center_size(center, Vec2::splat(14.0)).contains(pointer) { + return Some((i, corner)); + } + } + } + None + } fn workspace(&mut self, ui: &mut egui::Ui) { let r = ui.max_rect(); let ink = Ink::new(ui, r); @@ -749,6 +782,13 @@ impl Editor { if click(ui, &ink, [438.0, 20.0, 154.0, 34.0], "reference-settings") { self.reference_open = true; } + ui.put( + Rect::from_min_size(ink.point(24.0, 108.0), Vec2::new(310.0, 20.0)), + egui::Checkbox::new( + &mut self.keep_aspect_ratio, + "Keep aspect ratio when resizing", + ), + ); let (text, color) = if !self.reference_error.is_empty() { (self.reference_error.clone(), Color32::LIGHT_RED) } else if let Some((severe, warning)) = self.reference.as_ref().and_then(|r| r.warning()) { @@ -790,6 +830,17 @@ impl Editor { origin = area.center() - Vec2::new(960.0, 540.0) * scale + self.pan * scale; } } + if response.hovered() + && let Some(p) = pointer + && let Some((_, corner)) = self.resize_handle(p, origin, scale) + { + ui.ctx() + .set_cursor_icon(if matches!(corner, Corner::TopLeft | Corner::BottomRight) { + egui::CursorIcon::ResizeNwSe + } else { + egui::CursorIcon::ResizeNeSw + }); + } if response.drag_started_by(egui::PointerButton::Primary) || response.drag_started_by(egui::PointerButton::Middle) { @@ -804,10 +855,14 @@ impl Editor { if !self.panning && let Some(p) = ui.input(|i| i.pointer.press_origin()) { + let handle = self.resize_handle(p, origin, scale); let p = (p - origin) / scale; let point = [p.x as f64, p.y as f64]; let shift = ui.input(|i| i.modifiers.shift); - if shift || self.layout.hit(point).is_none() { + if let Some((i, corner)) = handle.filter(|_| !shift) { + self.layout + .start_resize(i, corner, point, self.keep_aspect_ratio); + } else if shift || self.layout.hit(point).is_none() { let previous = self.layout.selection_mask(); let base = if shift { previous } else { [false; 2] }; self.marquee = Some(Marquee { @@ -860,8 +915,11 @@ impl Editor { if response.clicked() && let Some(p) = pointer { + let handle = self.resize_handle(p, origin, scale); let p = (p - origin) / scale; - let hit = self.layout.hit([p.x as f64, p.y as f64]); + let hit = handle + .map(|(i, _)| i) + .or_else(|| self.layout.hit([p.x as f64, p.y as f64])); if click_shift_modifier(ui) { if let Some(i) = hit { self.layout.toggle(i); @@ -1022,7 +1080,7 @@ impl Editor { ink.text( 24.0, r.height() - 57.0, - "Drag to move or box-select · Shift-click toggles selection", + "Drag corners to resize · Drag to move · Shift-click selects", 12.0, MUTED, ); @@ -1176,6 +1234,54 @@ mod tests { } } #[test] + fn corner_handles_resize_at_different_zoom_levels_and_escape_restores() { + for zoom in [0.6, 1.0] { + for keep_aspect_ratio in [true, false] { + let mut app = Editor { + zoom, + keep_aspect_ratio, + ..Default::default() + }; + let ctx = egui::Context::default(); + let output = frame(&mut app, &ctx, vec![]); + let before = *app.layout.layers(); + let start = layer_rects(&output)[1].right_bottom(); + let end = start + Vec2::new(35.0, 5.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)]); + let resized = app.layout.layers()[1]; + assert!(resized.width > before[1].width); + assert_eq!([resized.x, resized.y], [before[1].x, before[1].y]); + assert_eq!(app.layout.layers()[0], before[0]); + let ratio_changed = + (resized.width / resized.height - before[1].width / before[1].height).abs() + > 1e-8; + assert_eq!(ratio_changed, !keep_aspect_ratio); + app.layout.undo(); + assert_eq!(*app.layout.layers(), before); + let output = frame(&mut app, &ctx, vec![]); + let start = layer_rects(&output)[1].left_top(); + frame( + &mut app, + &ctx, + vec![egui::Event::PointerMoved(start), mouse(start, true)], + ); + frame( + &mut app, + &ctx, + vec![egui::Event::PointerMoved(start - Vec2::splat(20.0))], + ); + frame(&mut app, &ctx, vec![key(egui::Key::Escape)]); + assert_eq!(*app.layout.layers(), before); + } + } + } + #[test] fn dropped_reference_warns_without_editing_layers_and_failed_replace_keeps_image() { let mut app = Editor::default(); let ctx = egui::Context::default(); diff --git a/crates/midra-layout/src/lib.rs b/crates/midra-layout/src/lib.rs index b065eb1..b16b09b 100644 --- a/crates/midra-layout/src/lib.rs +++ b/crates/midra-layout/src/lib.rs @@ -108,6 +108,14 @@ pub struct Layout { undo: Vec<[Geometry; 2]>, redo: Vec<[Geometry; 2]>, drag: Option<([bool; 2], [Geometry; 2], [f64; 2])>, + resize: Option, +} +struct Resize { + index: usize, + corner: Corner, + before: [Geometry; 2], + start: [f64; 2], + keep_ratio: bool, } impl Default for Layout { fn default() -> Self { @@ -132,6 +140,7 @@ impl Default for Layout { undo: Vec::new(), redo: Vec::new(), drag: None, + resize: None, } } } @@ -327,7 +336,68 @@ impl Layout { self.select(None); } } + /// Resize one selected layer, keeping its opposite corner fixed. + pub fn start_resize( + &mut self, + index: usize, + corner: Corner, + point: [f64; 2], + keep_ratio: bool, + ) { + self.finish_drag(); + if !self.selectable(index) || !self.selected[index] { + return; + } + self.select(Some(index)); + self.resize = Some(Resize { + index, + corner, + before: self.layers, + start: point, + keep_ratio, + }); + } pub fn drag_to(&mut self, point: [f64; 2]) { + if point.iter().any(|v| !v.is_finite()) { + return; + } + if let Some(r) = &self.resize { + let original = r.before[r.index]; + let left = matches!(r.corner, Corner::TopLeft | Corner::BottomLeft); + let top = matches!(r.corner, Corner::TopLeft | Corner::TopRight); + 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 (width, height) = 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 left { + original.x + original.width - width + } else { + original.x + }, + y: if top { + original.y + original.height - height + } else { + original.y + }, + width, + height, + }; + if next.validate().is_ok() { + self.layers[r.index] = next; + } + return; + } if let Some((selected, before, start)) = self.drag { let mut next = before; for i in 0..2 { @@ -342,14 +412,20 @@ impl Layout { } } pub fn dragging(&self) -> bool { - self.drag.is_some() + self.drag.is_some() || self.resize.is_some() } pub fn finish_drag(&mut self) { + if let Some(r) = self.resize.take() { + self.remember(r.before); + } if let Some((_, before, _)) = self.drag.take() { self.remember(before); } } pub fn cancel_drag(&mut self) { + if let Some(r) = self.resize.take() { + self.layers = r.before; + } if let Some((_, before, _)) = self.drag.take() { self.layers = before; } diff --git a/crates/midra-layout/tests/positioning.rs b/crates/midra-layout/tests/positioning.rs index 7568e67..2c0ee7f 100644 --- a/crates/midra-layout/tests/positioning.rs +++ b/crates/midra-layout/tests/positioning.rs @@ -562,3 +562,82 @@ fn locking_during_a_group_drag_restores_geometry_and_preserves_visibility() { 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(); + 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(); + 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(); + 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()); +} diff --git a/docs/midra-layout-plan.md b/docs/midra-layout-plan.md index 4f204e2..dc0cc0a 100644 --- a/docs/midra-layout-plan.md +++ b/docs/midra-layout-plan.md @@ -442,3 +442,8 @@ Reference-picture implementation update: PNG/JPEG/BMP import and file drop are available, with fill-screen or proportion-preserving fit, opacity and visibility. Resolution scaling produces a warning; aspect distortion a severe warning. Both remain non-blocking. Image offsets and persistent sessions remain future work. + +Corner-resizing implementation update: selected layers have interactive corner +handles with a fixed opposite anchor, ratio locking enabled by default, an explicit +free-resize toggle, Escape cancellation and one undo record per gesture. Numeric +width/height edits follow the same ratio toggle; pasted source sizes remain exact. diff --git a/docs/midra-layout.md b/docs/midra-layout.md index 09ea808..6967667 100644 --- a/docs/midra-layout.md +++ b/docs/midra-layout.md @@ -77,7 +77,7 @@ clipboard testing against a running draw.io instance remains to be done. - Drag a selected layer to move the whole selection together; dragging an unselected layer selects and moves it alone. Movement uses whole-screen-pixel deltas and preserves fractional starting positions, sizes and relative spacing. - Selection handles indicate bounds; resizing uses the single-layer numeric fields. + Drag a corner handle to resize that layer, or use the single-layer numeric fields. - Arrow keys move the selection by **1 px**; Shift-arrow moves it by **10 px**. - Choose one of the four corner markers. Switching corner changes the displayed offsets without moving the layer. Enter offsets, width and height, then click @@ -182,3 +182,15 @@ empty margins where needed; scaling still produces an amber warning. Files are limited to 64 MiB and dimensions to 8192 pixels per side or the GPU's texture limit, whichever is smaller. Invalid imports keep the previous image. Reference settings are session-only and independent of layer undo/redo. + +### Resizing with corner handles + +Drag a selected layer's gold corner handles to resize it; the opposite corner +stays fixed. **Keep aspect ratio when resizing**, above the viewport, is enabled +by default. Clear it to adjust width and height independently against the reference +picture. The same toggle links numeric width/height edits. Pasted dimensions +remain exactly as supplied by the source. + +Dragging a handle in a multiple selection selects and resizes only that layer. +Sizes cannot flip or shrink below one pixel during dragging. Escape cancels; +one Undo restores the complete resize. Locked or hidden layers cannot be resized.