Resize layers from corner handles with aspect ratio locking

This commit is contained in:
Dandaedre 2026-11-13 12:24:27 +01:00
parent 2f39cd3001
commit e0fbb04086
5 changed files with 283 additions and 5 deletions

View File

@ -12,6 +12,7 @@ pub struct Editor {
panning: bool,
marquee: Option<Marquee>,
align_target: AlignTarget,
keep_aspect_ratio: bool,
reference: Option<super::reference::Reference>,
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::<f64>()
&& 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();

View File

@ -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<Resize>,
}
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;
}

View File

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

View File

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

View File

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