diff --git a/crates/midra-layout/src/gui.rs b/crates/midra-layout/src/gui.rs index d06e5c8..d7f20e5 100644 --- a/crates/midra-layout/src/gui.rs +++ b/crates/midra-layout/src/gui.rs @@ -1222,6 +1222,34 @@ impl Editor { .filter(|bounds| bounds.contains(pointer)) .map(|_| i) } + fn crop_bounds(&self, origin: Pos2, scale: f32) -> Option { + if !self.edit_content { + return None; + } + let i = self.layout.selected()?; + let g = self.layout.layers()[i]; + let rect = Rect::from_min_size( + origin + Vec2::new(g.x as f32, g.y as f32) * scale, + Vec2::new(g.width as f32, g.height as f32) * scale, + ); + format_ui::content_bounds( + rect, + self.layout.formats().sources[self.layout.formats().source_for[i]], + self.layout.formats().advanced[i], + ) + } + fn crop_handle(&self, pointer: Pos2, origin: Pos2, scale: f32) -> Option { + let rect = self.crop_bounds(origin, scale)?; + [ + (Corner::TopLeft, rect.left_top()), + (Corner::TopRight, rect.right_top()), + (Corner::BottomLeft, rect.left_bottom()), + (Corner::BottomRight, rect.right_bottom()), + ] + .into_iter() + .find(|(_, p)| Rect::from_center_size(*p, Vec2::splat(14.0)).contains(pointer)) + .map(|(corner, _)| corner) + } fn resize_handle( &self, pointer: Pos2, @@ -1461,6 +1489,15 @@ impl Editor { { ui.ctx().set_cursor_icon(egui::CursorIcon::Grab); } + if self.edit_content + && response.hovered() + && let Some(corner) = pointer.and_then(|p| self.crop_handle(p, origin, scale)) + { + ui.ctx().set_cursor_icon(match corner { + Corner::TopLeft | Corner::BottomRight => egui::CursorIcon::ResizeNwSe, + _ => egui::CursorIcon::ResizeNeSw, + }); + } if !self.edit_content && response.hovered() && let Some(p) = pointer @@ -1491,11 +1528,16 @@ impl Editor { { let handle = self.resize_handle(p, origin, scale); let content = self.content_hit(p, origin, scale); + let crop_handle = self.crop_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 self.edit_content { - if let Some(i) = content { + if let Some(corner) = crop_handle { + if let Some(i) = self.layout.selected() { + self.layout.start_content_resize(i, corner, point); + } + } else if let Some(i) = content { self.layout.start_content_drag(i, point); } } else if let Some((i, corner)) = handle.filter(|_| !shift) { @@ -1560,7 +1602,10 @@ impl Editor { } if response.clicked() && self.edit_content - && pointer.is_some_and(|p| self.content_hit(p, origin, scale).is_none()) + && pointer.is_some_and(|p| { + self.content_hit(p, origin, scale).is_none() + && self.crop_handle(p, origin, scale).is_none() + }) { self.edit_content = false; } @@ -1713,7 +1758,7 @@ impl Editor { ); } } - if self.layout.selection_mask()[i] { + if self.layout.selection_mask()[i] && !self.edit_content { for corner in [ rect.left_top(), rect.right_top(), @@ -1748,6 +1793,24 @@ impl Editor { ); } } + if let Some(rect) = self.crop_bounds(origin, scale) { + let p = &screen.painter; + p.rect_stroke(rect, 0.0, Stroke::new(1.5_f32, CYAN), StrokeKind::Inside); + for corner in [ + rect.left_top(), + rect.right_top(), + rect.left_bottom(), + rect.right_bottom(), + ] { + p.rect( + Rect::from_center_size(corner, Vec2::splat(9.0)), + 1.0, + PANEL, + Stroke::new(1.5_f32, CYAN), + StrokeKind::Inside, + ); + } + } if let Some(m) = self.marquee { let from = origin + Vec2::new(m.start[0] as f32, m.start[1] as f32) * scale; let to = origin + Vec2::new(m.end[0] as f32, m.end[1] as f32) * scale; @@ -1804,12 +1867,12 @@ impl Editor { ink.text( 24.0, r.height() - 57.0, - match self.resize_mode { + if self.edit_content { "Crop mode · Drag cyan corners to zoom content · Drag image to reposition · Click outside to finish" } else { match self.resize_mode { ResizeMode::Individual => "Corners resize · Side handles keep opposite edge fixed · Shift-click selects", ResizeMode::Same => "Same handles · Matching handles scale selected layers proportionally · Escape exits", ResizeMode::Mirror => "Mirror horizontally · Left/right mirrored handles · Escape exits", ResizeMode::Opposite => "Opposite handles · Opposite corners or edges · Escape exits", - }, + } }, 12.0, MUTED, ); @@ -2257,6 +2320,44 @@ mod tests { frame(&mut app, &ctx, vec![key(egui::Key::Escape)]); assert!(!app.edit_content); } + #[test] + fn crop_corner_gesture_zooms_content_without_resizing_layer() { + for zoom in [0.6, 1.0] { + let mut app = Editor { + edit_content: true, + keep_aspect_ratio: false, + zoom, + ..Default::default() + }; + let ctx = egui::Context::default(); + let before = *app.layout.layers(); + let formats = *app.layout.formats(); + let output = frame(&mut app, &ctx, vec![]); + let start = layer_rects(&output)[1].right_bottom(); + let end = start + Vec2::new(20.0, 15.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!(app.edit_content); + assert_eq!(*app.layout.layers(), before); + assert!( + app.layout + .formats() + .mapping(1, before[1]) + .unwrap() + .framing + .zoom + > 1.0 + ); + app.layout.undo(); + assert_eq!(*app.layout.formats(), formats); + } + } + #[test] fn clicking_outside_crop_exits_and_selects_normally_without_changing_geometry() { for target in [Some(0), None] { diff --git a/crates/midra-layout/src/lib.rs b/crates/midra-layout/src/lib.rs index 17f8033..4a72612 100644 --- a/crates/midra-layout/src/lib.rs +++ b/crates/midra-layout/src/lib.rs @@ -296,6 +296,7 @@ pub struct Layout { redo: Vec, drag: Option<([bool; 2], Snapshot, [f64; 2])>, content_drag: Option<(usize, Snapshot, [f64; 2])>, + content_resize: Option, pub gesture_error: Option, resize: Option, } @@ -336,6 +337,7 @@ impl Default for Layout { visible: [true; 2], formats: Formats::default(), content_drag: None, + content_resize: None, gesture_error: None, undo: Vec::new(), redo: Vec::new(), @@ -388,6 +390,26 @@ impl Layout { self.content_drag = Some((i, self.snapshot(), point)); } } + /// Zoom the content from a corner, leaving the visible layer box unchanged. + pub fn start_content_resize(&mut self, index: usize, corner: Corner, point: [f64; 2]) { + self.finish_drag(); + if !self.selectable(index) + || self.selected() != Some(index) + || point.iter().any(|v| !v.is_finite()) + { + return; + } + self.content_resize = Some(Resize { + mode: ResizeMode::Individual, + targets: self.selected, + index, + handle: ResizeHandle::Corner(corner), + before: self.snapshot(), + start: point, + keep_ratio: true, + }); + } + /// Atomic shared-source edit plus visible-box resizing. Explicit acceptance is required for any center adjustment. pub fn configure( &mut self, @@ -834,6 +856,44 @@ impl Layout { if point.iter().any(|v| !v.is_finite()) { return; } + if let Some(r) = &self.content_resize { + let result = (|| { + let i = r.index; + let g = r.before.layers[i]; + let input = r.before.formats.input(i)?; + let m = r.before.formats.mapping(i, g)?; + let crop = r.before.formats.advanced[i]; + 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 desired = resized_geometry( + full, + r.handle, + [point[0] - r.start[0], point[1] - r.start[1]], + true, + ); + let zoom = (m.framing.zoom * desired.width / full.width).clamp(1.0, 100.0); + let (scale, limits) = formats::limits(input, [g.width, g.height], zoom)?; + let resized = anchored_resize(full, r.handle, input[0] * scale, input[1] * scale); + let center = resized.center(); + let layer_center = g.center(); + let offset = std::array::from_fn(|axis| { + (center[axis] - layer_center[axis]).clamp(-limits[axis], limits[axis]) + }); + formats::crop_from_framing(input, [g.width, g.height], Framing { zoom, offset }) + })(); + match result { + Ok(crop) => { + self.formats.advanced[r.index] = crop; + self.gesture_error = None; + } + Err(e) => self.gesture_error = Some(e), + } + return; + } if let Some((i, before, start)) = self.content_drag { if let Ok(m) = before.formats.mapping(i, before.layers[i]) { let offset = std::array::from_fn(|axis| { @@ -926,9 +986,15 @@ impl Layout { } } pub fn dragging(&self) -> bool { - self.drag.is_some() || self.resize.is_some() || self.content_drag.is_some() + self.drag.is_some() + || self.resize.is_some() + || self.content_drag.is_some() + || self.content_resize.is_some() } pub fn finish_drag(&mut self) { + if let Some(r) = self.content_resize.take() { + self.remember(r.before); + } if let Some((_, before, _)) = self.content_drag.take() { self.remember(before); } @@ -940,6 +1006,9 @@ impl Layout { } } pub fn cancel_drag(&mut self) { + if let Some(r) = self.content_resize.take() { + self.restore(r.before); + } self.gesture_error = None; if let Some((_, before, _)) = self.content_drag.take() { self.restore(before); diff --git a/crates/midra-layout/tests/positioning.rs b/crates/midra-layout/tests/positioning.rs index b161fb3..55f6365 100644 --- a/crates/midra-layout/tests/positioning.rs +++ b/crates/midra-layout/tests/positioning.rs @@ -910,3 +910,73 @@ fn selected_layers_are_foreground_for_viewport_and_hit_testing() { 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 corner in [ + Corner::TopLeft, + Corner::TopRight, + Corner::BottomLeft, + Corner::BottomRight, + ] { + let mut l = Layout::default(); + let i = 1; + let before = *l.layers(); + let formats = *l.formats(); + let g = before[i]; + let start = ResizeHandle::positions(g) + .into_iter() + .find(|(h, _)| *h == ResizeHandle::Corner(corner)) + .unwrap() + .1; + let opposite = ResizeHandle::positions(g) + .into_iter() + .find(|(h, _)| *h == ResizeHandle::Corner(corner).opposite()) + .unwrap() + .1; + let end = std::array::from_fn(|axis| opposite[axis] + 2.0 * (start[axis] - opposite[axis])); + l.start_content_resize(i, corner, start); + l.drag_to(end); + l.finish_drag(); + assert_eq!(*l.layers(), before); + let after = *l.formats(); + 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 == ResizeHandle::Corner(corner).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, corner, 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, corner, 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, corner, start); + assert!(!l.dragging()); + } +} diff --git a/docs/midra-layout.md b/docs/midra-layout.md index 662ea8d..860a517 100644 --- a/docs/midra-layout.md +++ b/docs/midra-layout.md @@ -371,3 +371,12 @@ While adjusting a layer crop, click empty canvas or another layer to leave crop mode and select normally. Clicking or dragging the visible image or its faded outside preview keeps crop mode active. Property controls remain usable while editing the crop. + +In visual crop mode, a cyan bounding box surrounds the full usable input image, +including the faded preview. Drag any of its four corners to zoom the content +through cropping; the gold visible layer box stays fixed. Content always keeps +its proportions, independently of the layer resize ratio toggle. The opposite +content corner stays anchored where possible; offsets clamp to keep the visible +box filled when zooming out. Zoom is limited to 100–10000%. Drag the image to pan +its content. Each zoom gesture is one undo step; Escape cancels an active gesture. +Use viewport zoom/pan to reach content handles beyond the current view.