Add proportional same and mirror resizing for selected layers
This commit is contained in:
parent
d76895c914
commit
833f32a5eb
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Reference in New Issue