Add proportional same and mirror resizing for selected layers

This commit is contained in:
Dandaedre 2026-11-13 14:30:59 +01:00
parent d76895c914
commit 833f32a5eb
4 changed files with 483 additions and 90 deletions

View File

@ -3,7 +3,7 @@ use super::*;
mod format_ui;
use format_ui::{FormatDraft, OutputDraft};
use midra_layout::import::{DetectedShape, ImportDocument, parse_svg, parse_values};
use midra_layout::{AlignTarget, Alignment, Corner, Geometry, Layout, ResizeHandle};
use midra_layout::{AlignTarget, Alignment, Corner, Geometry, Layout, ResizeHandle, ResizeMode};
pub struct Editor {
layout: Layout,
@ -18,6 +18,7 @@ pub struct Editor {
marquee: Option<Marquee>,
align_target: AlignTarget,
keep_aspect_ratio: bool,
resize_mode: ResizeMode,
format_draft: Option<FormatDraft>,
output_draft: Option<OutputDraft>,
edit_content: bool,
@ -170,6 +171,7 @@ impl Default for Editor {
marquee: None,
align_target: AlignTarget::Selection,
keep_aspect_ratio: true,
resize_mode: ResizeMode::Individual,
format_draft: None,
output_draft: None,
edit_content: false,
@ -271,6 +273,9 @@ impl Editor {
self.reference_open = open;
}
fn sync(&mut self) {
if self.layout.selected_indices().len() < 2 {
self.resize_mode = ResizeMode::Individual;
}
if let Some(i) = self.layout.selected() {
let g = self.layout.layers()[i];
let [x, y] = self.corner.offsets_on(g, self.layout.formats().output);
@ -432,6 +437,7 @@ impl Editor {
}
if ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
self.edit_content = false;
self.resize_mode = ResizeMode::Individual;
self.layout.cancel_drag();
if let Some(m) = self.marquee.take() {
self.layout.set_selection(m.previous);
@ -980,14 +986,49 @@ impl Editor {
12.0,
MUTED,
);
ink.text(
0.0,
263.0,
"Alignment changes position, never size.",
12.0,
MUTED,
ui.scope_builder(
egui::UiBuilder::new().max_rect(Rect::from_min_size(
ink.point(0.0, 254.0),
Vec2::new(w, 34.0),
)),
|ui| {
egui::ComboBox::from_id_salt("resize-selected-mode")
.width(w - 12.0)
.selected_text(match self.resize_mode {
ResizeMode::Individual => "Resize: individual layer",
ResizeMode::Same => "Same resize",
ResizeMode::Mirror => "Mirror resize",
})
.show_ui(ui, |ui| {
ui.selectable_value(
&mut self.resize_mode,
ResizeMode::Individual,
"Resize: individual layer",
);
ui.selectable_value(&mut self.resize_mode, ResizeMode::Same, "Same resize");
ui.add_enabled_ui(self.layout.selected_indices().len() == 2, |ui| {
ui.selectable_value(
&mut self.resize_mode,
ResizeMode::Mirror,
"Mirror resize (two layers)",
);
});
});
},
);
ink.text(0.0, 286.0, "A reference layer stays fixed.", 12.0, MUTED);
ui.put(Rect::from_min_size(ink.point(0.0, 292.0), Vec2::new(w, 52.0)), egui::Label::new(egui::RichText::new(
match self.resize_mode {
ResizeMode::Individual => "Choose Same or Mirror, then drag a selected layer's handle to resize the selection.",
ResizeMode::Same => "Matching handles, equal proportional scaling. Drag any selected handle. Escape exits.",
ResizeMode::Mirror => "Opposite handles, equal proportional scaling. Exactly two layers. Escape exits.",
}
).size(12.0).color(MUTED)).wrap().halign(egui::Align::Min));
let shifted = Ink {
painter: ink.painter.clone(),
origin: ink.origin + Vec2::new(0.0, 42.0),
scale: ink.scale,
};
let ink = &shifted;
ink.line([0.0, 319.0], [w, 319.0], LINE);
ink.text(0.0, 341.0, "VISIBLE BOX / CENTER POSITIONS", 11.0, CYAN);
for (row, i) in self.layout.selected_indices().into_iter().enumerate() {
@ -1009,7 +1050,7 @@ impl Editor {
ink.text(
0.0,
609.0,
"Select one layer to edit its size; paste accepts the full selection.",
"Numeric edits require one selected layer.",
12.0,
MUTED,
);
@ -1321,8 +1362,15 @@ impl Editor {
self.layout.start_content_drag(i, point);
}
} else if let Some((i, corner)) = handle.filter(|_| !shift) {
self.layout
.start_handle_resize(i, corner, point, self.keep_aspect_ratio);
if let Err(e) = self.layout.start_selected_resize(
i,
corner,
point,
self.keep_aspect_ratio,
self.resize_mode,
) {
self.layout.gesture_error = Some(e);
}
} else if shift || self.layout.hit(point).is_none() {
let previous = self.layout.selection_mask();
let base = if shift { previous } else { [false; 2] };
@ -1387,8 +1435,13 @@ impl Editor {
self.layout.toggle(i);
}
} else {
self.layout.select(hit);
if self.resize_mode == ResizeMode::Individual
|| hit.is_none_or(|i| !self.layout.selection_mask()[i])
{
self.layout.select(hit);
}
if response.double_clicked_by(egui::PointerButton::Primary) && hit.is_some() {
self.layout.select(hit);
self.edit_content = true;
}
}
@ -1593,7 +1646,11 @@ impl Editor {
ink.text(
24.0,
r.height() - 57.0,
"Corners resize · Side handles keep opposite edge fixed · Shift-click selects",
match self.resize_mode {
ResizeMode::Individual => "Corners resize · Side handles keep opposite edge fixed · Shift-click selects",
ResizeMode::Same => "Same resize · Matching handles scale selected layers proportionally · Escape exits",
ResizeMode::Mirror => "Mirror resize · Opposite handles scale both layers proportionally · Escape exits",
},
12.0,
MUTED,
);
@ -2246,6 +2303,61 @@ mod tests {
assert_eq!(app.layout.layers()[1], g);
}
#[test]
fn selected_resize_mode_control_keeps_selection_during_handle_drag() {
for (title, mode) in [
("Same resize", ResizeMode::Same),
("Mirror resize (two layers)", ResizeMode::Mirror),
] {
let mut app = Editor::default();
app.layout.set_selection([true; 2]);
let ctx = egui::Context::default();
frame(&mut app, &ctx, vec![]);
for text in ["Resize: individual layer", title] {
let output = frame(&mut app, &ctx, vec![]);
let pos = output
.shapes
.iter()
.find_map(|s| match &s.shape {
egui::epaint::Shape::Text(t) if t.galley.job.text == text => {
Some(t.pos + Vec2::new(12.0, 6.0))
}
_ => None,
})
.unwrap();
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(pos), mouse(pos, true)],
);
frame(&mut app, &ctx, vec![mouse(pos, false)]);
}
assert_eq!(app.resize_mode, mode);
let before = *app.layout.layers();
let output = frame(&mut app, &ctx, vec![]);
let start = layer_rects(&output)[1].right_center();
let end = start + Vec2::new(20.0, 0.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_eq!(app.layout.selection_mask(), [true; 2]);
assert!(
app.layout
.layers()
.iter()
.zip(before)
.all(|(g, old)| g.width > old.width)
);
app.layout.undo();
assert_eq!(*app.layout.layers(), before);
frame(&mut app, &ctx, vec![key(egui::Key::Escape)]);
assert_eq!(app.resize_mode, ResizeMode::Individual);
}
}
#[test]
fn side_handle_hit_regions_resize_at_multiple_zoom_levels() {
for zoom in [0.6, 1.0] {
for side in 0..4 {

View File

@ -21,7 +21,30 @@ pub enum ResizeHandle {
Left,
Right,
}
/// How a handle drag affects selected layers.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub enum ResizeMode {
#[default]
Individual,
Same,
Mirror,
}
impl ResizeHandle {
pub fn opposite(self) -> Self {
match self {
Self::Top => Self::Bottom,
Self::Bottom => Self::Top,
Self::Left => Self::Right,
Self::Right => Self::Left,
Self::Corner(corner) => Self::Corner(match corner {
Corner::TopLeft => Corner::BottomRight,
Corner::TopRight => Corner::BottomLeft,
Corner::BottomLeft => Corner::TopRight,
Corner::BottomRight => Corner::TopLeft,
}),
}
}
pub fn positions(g: Geometry) -> [(Self, [f64; 2]); 8] {
let [cx, cy] = g.center();
[
@ -39,6 +62,99 @@ impl ResizeHandle {
]
}
}
fn resized_geometry(
original: Geometry,
handle: ResizeHandle,
delta: [f64; 2],
keep_ratio: bool,
) -> Geometry {
let left = matches!(
handle,
ResizeHandle::Corner(Corner::TopLeft | Corner::BottomLeft) | ResizeHandle::Left
);
let top = matches!(
handle,
ResizeHandle::Corner(Corner::TopLeft | Corner::TopRight) | ResizeHandle::Top
);
let dx = delta[0].round() * if left { -1.0 } else { 1.0 };
let dy = delta[1].round() * if top { -1.0 } else { 1.0 };
let side = !matches!(handle, ResizeHandle::Corner(_));
let horizontal = matches!(handle, ResizeHandle::Left | ResizeHandle::Right);
let (width, height) = if side {
if horizontal {
let width = (original.width + dx).max(if keep_ratio {
(original.width / original.height).max(1.0)
} else {
1.0
});
(
width,
if keep_ratio {
width * original.height / original.width
} else {
original.height
},
)
} else {
let height = (original.height + dy).max(if keep_ratio {
(original.height / original.width).max(1.0)
} else {
1.0
});
(
if keep_ratio {
height * original.width / original.height
} else {
original.width
},
height,
)
}
} else if 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),
)
};
anchored_resize(original, handle, width, height)
}
fn anchored_resize(original: Geometry, handle: ResizeHandle, width: f64, height: f64) -> Geometry {
let side = !matches!(handle, ResizeHandle::Corner(_));
let horizontal = matches!(handle, ResizeHandle::Left | ResizeHandle::Right);
let left = matches!(
handle,
ResizeHandle::Left | ResizeHandle::Corner(Corner::TopLeft | Corner::BottomLeft)
);
let top = matches!(
handle,
ResizeHandle::Top | ResizeHandle::Corner(Corner::TopLeft | Corner::TopRight)
);
Geometry {
x: if side && !horizontal {
original.center()[0] - width / 2.0
} else if left {
original.x + original.width - width
} else {
original.x
},
y: if side && horizontal {
original.center()[1] - height / 2.0
} else if top {
original.y + original.height - height
} else {
original.y
},
width,
height,
}
}
/// Visible layer bounds, in output screen pixels. No crop or camera transform.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Geometry {
@ -170,6 +286,8 @@ pub struct Layout {
}
#[derive(Clone)]
struct Resize {
mode: ResizeMode,
targets: [bool; 2],
index: usize,
handle: ResizeHandle,
before: Snapshot,
@ -645,6 +763,8 @@ impl Layout {
}
self.select(Some(index));
self.resize = Some(Resize {
mode: ResizeMode::Individual,
targets: self.selected,
index,
handle,
before: self.snapshot(),
@ -652,6 +772,41 @@ impl Layout {
keep_ratio,
});
}
/// Start proportional resizing from matching or opposite handles, without changing selection.
pub fn start_selected_resize(
&mut self,
index: usize,
handle: ResizeHandle,
point: [f64; 2],
keep_ratio: bool,
mode: ResizeMode,
) -> Result<(), String> {
if mode == ResizeMode::Individual {
self.start_handle_resize(index, handle, point, keep_ratio);
return Ok(());
}
let count = self.selected_indices().len();
if count < 2 || (mode == ResizeMode::Mirror && count != 2) {
return Err(
"Select at least two layers for Same resize, or exactly two for Mirror resize."
.into(),
);
}
if !self.selectable(index) || !self.selected.get(index).copied().unwrap_or(false) {
return Err("Resize from a selected, visible, unlocked layer.".into());
}
self.finish_drag();
self.resize = Some(Resize {
mode,
targets: self.selected,
index,
handle,
before: self.snapshot(),
start: point,
keep_ratio,
});
Ok(())
}
pub fn drag_to(&mut self, point: [f64; 2]) {
if point.iter().any(|v| !v.is_finite()) {
return;
@ -677,85 +832,52 @@ impl Layout {
}
if let Some(r) = &self.resize {
let original = r.before.layers[r.index];
let left = matches!(
let next = resized_geometry(
original,
r.handle,
ResizeHandle::Corner(Corner::TopLeft | Corner::BottomLeft) | ResizeHandle::Left
[point[0] - r.start[0], point[1] - r.start[1]],
r.keep_ratio,
);
let top = matches!(
r.handle,
ResizeHandle::Corner(Corner::TopLeft | Corner::TopRight) | ResizeHandle::Top
);
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 side = !matches!(r.handle, ResizeHandle::Corner(_));
let horizontal = matches!(r.handle, ResizeHandle::Left | ResizeHandle::Right);
let (width, height) = if side {
if horizontal {
let width = (original.width + dx).max(if r.keep_ratio {
(original.width / original.height).max(1.0)
} else {
1.0
});
(
width,
if r.keep_ratio {
width * original.height / original.width
} else {
original.height
},
)
} else {
let height = (original.height + dy).max(if r.keep_ratio {
(original.height / original.width).max(1.0)
} else {
1.0
});
(
if r.keep_ratio {
height * original.width / original.height
} else {
original.width
},
height,
)
let result = (|| {
let mut layers = r.before.layers;
let mut formats = r.before.formats;
let mut sx = next.width / original.width;
let mut sy = next.height / original.height;
if r.mode != ResizeMode::Individual {
for (i, g) in layers.iter().enumerate() {
if r.targets[i] {
sx = sx.max(1.0 / g.width);
sy = sy.max(1.0 / g.height);
}
}
if r.keep_ratio {
sx = sx.max(sy);
sy = sx;
}
}
} else 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 side && !horizontal {
original.center()[0] - width / 2.0
} else if left {
original.x + original.width - width
} else {
original.x
},
y: if side && horizontal {
original.center()[1] - height / 2.0
} else if top {
original.y + original.height - height
} else {
original.y
},
width,
height,
};
let mut formats = r.before.formats;
match next
.validate()
.and_then(|_| formats.resize(r.index, original, next))
{
Ok(()) => {
self.layers[r.index] = next;
for (i, geometry) in layers.iter_mut().enumerate() {
if !r.targets[i] {
continue;
}
let before = *geometry;
let handle = if r.mode == ResizeMode::Mirror && i != r.index {
r.handle.opposite()
} else {
r.handle
};
*geometry = if r.mode == ResizeMode::Individual {
next
} else {
anchored_resize(before, handle, before.width * sx, before.height * sy)
};
geometry.validate()?;
formats.resize(i, before, *geometry)?;
}
Ok::<_, String>((layers, formats))
})();
match result {
Ok((layers, formats)) => {
self.layers = layers;
self.formats = formats;
self.gesture_error = None;
}

View File

@ -719,3 +719,141 @@ fn corner_alignment_to_unselected_reference_is_one_undo_step() {
l.undo();
assert_eq!(*l.layers(), before);
}
#[test]
fn selected_resize_scales_proportionally_with_same_or_opposite_anchors() {
use midra_layout::{ResizeHandle as H, ResizeMode as M};
for mode in [M::Same, M::Mirror] {
for keep_ratio in [false, true] {
for initiator in 0..2 {
for (handle, _) in H::positions(Layout::default().layers()[0]) {
let mut l = Layout::default();
l.apply(
0,
Geometry {
x: 100.0,
y: 80.0,
width: 300.0,
height: 200.0,
},
)
.unwrap();
l.set_selection([true; 2]);
let before = *l.layers();
let formats = *l.formats();
let start = H::positions(before[initiator])
.into_iter()
.find(|(h, _)| *h == handle)
.unwrap()
.1;
let dx = if matches!(
handle,
H::Left | H::Corner(Corner::TopLeft | Corner::BottomLeft)
) {
-30.0
} else {
30.0
};
let dy = if matches!(
handle,
H::Top | H::Corner(Corner::TopLeft | Corner::TopRight)
) {
-20.0
} else {
20.0
};
l.start_selected_resize(initiator, handle, start, keep_ratio, mode)
.unwrap();
l.drag_to([start[0] + dx, start[1] + dy]);
l.finish_drag();
assert_eq!(l.selection_mask(), [true; 2]);
let after = *l.layers();
assert!(
(after[0].width / before[0].width - after[1].width / before[1].width).abs()
< 1e-10
);
assert!(
(after[0].height / before[0].height - after[1].height / before[1].height)
.abs()
< 1e-10
);
for i in 0..2 {
let actual = if mode == M::Mirror && i != initiator {
handle.opposite()
} else {
handle
};
let anchor = |g| {
H::positions(g)
.into_iter()
.find(|(h, _)| *h == actual.opposite())
.unwrap()
.1
};
for (a, b) in anchor(before[i]).into_iter().zip(anchor(after[i])) {
assert!((a - b).abs() < 1e-8);
}
if keep_ratio {
assert!(
(after[i].width / after[i].height
- before[i].width / before[i].height)
.abs()
< 1e-10
);
}
}
l.undo();
assert_eq!(*l.layers(), before);
assert_eq!(*l.formats(), formats);
l.redo();
assert_eq!(*l.layers(), after);
}
}
}
}
}
#[test]
fn selected_resize_limits_cancel_and_protection_are_atomic() {
use midra_layout::{ResizeHandle as H, ResizeMode as M};
let mut l = Layout::default();
assert!(
l.start_selected_resize(1, H::Right, [0.0; 2], false, M::Mirror)
.is_err()
);
l.apply(
0,
Geometry {
x: 100.0,
y: 80.0,
width: 300.0,
height: 200.0,
},
)
.unwrap();
l.set_selection([true; 2]);
let before = *l.layers();
let formats = *l.formats();
l.start_selected_resize(0, H::Right, [0.0; 2], false, M::Same)
.unwrap();
l.drag_to([800_000.0, 0.0]);
assert!(l.gesture_error.is_some());
assert_eq!(*l.layers(), before);
assert_eq!(*l.formats(), formats);
l.drag_to([30.0, 0.0]);
assert_ne!(*l.layers(), before);
l.cancel_drag();
assert_eq!(*l.layers(), before);
assert_eq!(*l.formats(), formats);
l.start_selected_resize(0, H::Right, [0.0; 2], false, M::Mirror)
.unwrap();
l.drag_to([30.0, 0.0]);
l.set_locked(1, true);
assert_eq!(*l.layers(), before);
assert_eq!(*l.formats(), formats);
assert!(!l.dragging());
assert!(
l.start_selected_resize(0, H::Right, [0.0; 2], false, M::Mirror)
.is_err()
);
}

View File

@ -141,6 +141,26 @@ clipboard testing against a running draw.io instance remains to be done.
offsets are not copied. Crop zoom is included separately as a percentage and
can be toggled on paste. This is not a native WebRCS clipboard payload.
## Resize selected layers together
Select multiple layers, then choose **Same resize** or **Mirror resize** in the
right-hand inspector’s resize dropdown. Drag a corner or side handle on any
selected layer to scale the selection together. Both modes use **equal
proportional scaling**, not equal pixel additions: a 10% width increase applies
to every selected layer’s own width.
- **Same resize** uses the matching handle on every layer.
- **Mirror resize** requires exactly two layers. The other layer uses the opposite
handle: right/left, top/bottom, and diagonally opposite corners.
- Each layer keeps the opposite edge or corner fixed. With aspect ratio locked,
both dimensions use the same scale; otherwise width and height scale
independently. Side handles affect only their axis when the ratio is unlocked.
- Minimum sizes constrain the shared scale. Invalid geometry rejects the whole
update. Crops adjust with sizing, and one Undo restores all layers and crops.
- **Escape** cancels an active drag and exits the mode. Choose **Resize: individual
layer** to return to normal handles; reducing the selection below two also
leaves group resize. Locking/hiding during a drag cancels the entire gesture.
## Align selected layers
Open the **Align selected layers** icon menu beside the view/history toolbar.
@ -158,7 +178,8 @@ only their axis; corner buttons change both axes. Hover an icon for its label.
Every action preserves layer sizes and is one undo step, including corner moves.
The menu also works with one selected layer and a different reference layer.
The inspector lists each selected layer's resulting center coordinates; select
exactly one layer to resize. Paste/import accepts the full selection.
one layer for numeric size editing, or use Same/Mirror resize for the selection.
Paste/import accepts the full selection.
Text inputs receive normal text paste and arrow navigation while focused; they
never interpret these actions as geometry import or layer movement. Paste preview