Add content bounding box handles for visual crop zoom
This commit is contained in:
parent
02956594b2
commit
573c44e8db
|
|
@ -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] {
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
Loading…
Reference in New Issue