Add content bounding box handles for visual crop zoom

This commit is contained in:
Dandaedre 2026-11-13 14:48:38 +01:00
parent 02956594b2
commit 573c44e8db
4 changed files with 255 additions and 6 deletions

View File

@ -1222,6 +1222,34 @@ impl Editor {
.filter(|bounds| bounds.contains(pointer))
.map(|_| i)
}
fn crop_bounds(&self, origin: Pos2, scale: f32) -> Option<Rect> {
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<Corner> {
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] {

View File

@ -296,6 +296,7 @@ pub struct Layout {
redo: Vec<Snapshot>,
drag: Option<([bool; 2], Snapshot, [f64; 2])>,
content_drag: Option<(usize, Snapshot, [f64; 2])>,
content_resize: Option<Resize>,
pub gesture_error: Option<String>,
resize: Option<Resize>,
}
@ -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);

View File

@ -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());
}
}

View File

@ -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.