Resize layers from corner handles with aspect ratio locking
This commit is contained in:
parent
2f39cd3001
commit
e0fbb04086
|
|
@ -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();
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
Loading…
Reference in New Issue