Add movable Ctrl resize pivots with linked selection modes

This commit is contained in:
Dandaedre 2026-11-14 12:10:12 +01:00
parent dcc0c4bc12
commit a9b82c89ff
Signed by: Dandaedre
GPG Key ID: 440C6592E8A26D99
9 changed files with 564 additions and 19 deletions

View File

@ -46,6 +46,9 @@ pub struct Editor {
layer_order: Vec<usize>,
keep_aspect_ratio: bool,
resize_mode: ResizeMode,
pivot_relative: [f64; 2],
pivot_selection: Vec<usize>,
pivot_drag: Option<(usize, [f64; 2])>,
format_draft: Option<FormatDraft>,
property_tab: PropertyTab,
output_draft: Option<OutputDraft>,
@ -246,6 +249,9 @@ impl Default for Editor {
layer_order: Vec::new(),
keep_aspect_ratio: true,
resize_mode: ResizeMode::Individual,
pivot_relative: [0.5; 2],
pivot_selection: Vec::new(),
pivot_drag: None,
format_draft: None,
property_tab: PropertyTab::default(),
output_draft: None,
@ -461,6 +467,19 @@ impl Editor {
self.reference_open = open;
}
fn sync(&mut self) {
let selection: Vec<_> = self
.layout
.selected_indices()
.iter()
.map(|&i| self.layout.layer_info(i).id)
.collect();
if selection != self.pivot_selection {
if !self.layout.dragging() {
self.pivot_relative = [0.5; 2];
}
self.pivot_drag = None;
self.pivot_selection = selection;
}
let order: Vec<_> = (0..self.layout.layers().len())
.map(|i| self.layout.layer_info(i).id)
.collect();
@ -666,6 +685,9 @@ impl Editor {
if ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
self.edit_content = false;
self.layout.cancel_drag();
if let Some((_, before)) = self.pivot_drag.take() {
self.pivot_relative = before;
}
if let Some(m) = self.marquee.take() {
self.layout.set_selection(m.previous);
}
@ -1655,6 +1677,51 @@ impl Editor {
.map(|(handle, _)| handle)
}
fn pivot_for(&self, i: usize) -> [f64; 2] {
let mut relative = self.pivot_relative;
if self.layout.selected_indices().first().copied() != Some(i) {
if matches!(
self.active_resize_mode(),
ResizeMode::Mirror | ResizeMode::Opposite
) {
relative[0] = 1.0 - relative[0];
}
if self.active_resize_mode() == ResizeMode::Opposite {
relative[1] = 1.0 - relative[1];
}
}
relative
}
fn pivot_hit(&self, pointer: Pos2, origin: Pos2, scale: f32) -> Option<usize> {
self.layout.selected_indices().into_iter().rev().find(|&i| {
let g = self.layout.layers()[i];
let relative = self.pivot_for(i);
let point = origin
+ Vec2::new(
(g.x + relative[0] * g.width) as f32,
(g.y + relative[1] * g.height) as f32,
) * scale;
pointer.distance(point) <= 9.0
})
}
fn move_pivot(&mut self, i: usize, point: [f64; 2]) {
let g = self.layout.layers()[i];
let mut relative = [(point[0] - g.x) / g.width, (point[1] - g.y) / g.height];
if self.layout.selected_indices().first().copied() != Some(i) {
if matches!(
self.active_resize_mode(),
ResizeMode::Mirror | ResizeMode::Opposite
) {
relative[0] = 1.0 - relative[0];
}
if self.active_resize_mode() == ResizeMode::Opposite {
relative[1] = 1.0 - relative[1];
}
}
if relative.iter().all(|v| v.is_finite() && v.abs() <= 1e6) {
self.pivot_relative = relative;
}
}
fn resize_handle(
&self,
pointer: Pos2,
@ -1678,6 +1745,8 @@ impl Editor {
modifiers: egui::Modifiers,
scale: f32,
) -> [Option<f64>; 2] {
self.layout
.use_resize_pivot(modifiers.ctrl && !modifiers.shift);
if modifiers.shift && !modifiers.alt {
self.layout
.drag_to_grid(point, if modifiers.ctrl { 100.0 } else { 10.0 })
@ -2026,6 +2095,16 @@ impl Editor {
ResizeHandle::Top | ResizeHandle::Bottom => egui::CursorIcon::ResizeVertical,
});
}
let pivot_visible =
ui.input(|i| i.modifiers.ctrl && !i.modifiers.shift) && !self.edit_content;
let pivot_hover = if pivot_visible {
pointer.and_then(|p| self.pivot_hit(p, origin, scale))
} else {
None
};
if response.hovered() && pivot_hover.is_some() {
ui.ctx().set_cursor_icon(egui::CursorIcon::Move);
}
if response.drag_started_by(egui::PointerButton::Primary)
|| response.drag_started_by(egui::PointerButton::Middle)
{
@ -2040,13 +2119,20 @@ impl Editor {
if !self.panning
&& let Some(p) = ui.input(|i| i.pointer.press_origin())
{
let pivot = if pivot_visible {
self.pivot_hit(p, origin, scale)
} else {
None
};
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) = pivot {
self.pivot_drag = Some((i, self.pivot_relative));
} else if self.edit_content {
if let Some(corner) = crop_handle {
if let Some(i) = self.layout.selected() {
self.layout.start_content_resize(i, corner, point);
@ -2064,6 +2150,7 @@ impl Editor {
) {
self.layout.gesture_error = Some(e);
}
self.layout.set_resize_pivot(self.pivot_for(i));
} else if self.layout.hit(point).is_none() {
let previous = self.layout.selection_mask();
let base = if shift {
@ -2093,7 +2180,9 @@ impl Editor {
} else if let Some(p) = pointer {
let p = (p - origin) / scale;
let point = [p.x as f64, p.y as f64];
if let Some(m) = self.marquee.as_mut() {
if let Some((i, _)) = self.pivot_drag {
self.move_pivot(i, point);
} else if let Some(m) = self.marquee.as_mut() {
m.end = point;
self.layout.select_region(m.start, point, &m.base);
} else {
@ -2103,12 +2192,14 @@ impl Editor {
}
}
if response.drag_stopped() {
if (self.layout.dragging() || self.marquee.is_some())
if (self.layout.dragging() || self.marquee.is_some() || self.pivot_drag.is_some())
&& let Some(p) = pointer
{
let p = (p - origin) / scale;
let point = [p.x as f64, p.y as f64];
if let Some(m) = self.marquee.as_mut() {
if let Some((i, _)) = self.pivot_drag {
self.move_pivot(i, point);
} else if let Some(m) = self.marquee.as_mut() {
m.end = point;
self.layout.select_region(m.start, point, &m.base);
} else {
@ -2117,6 +2208,7 @@ impl Editor {
self.sync();
}
self.layout.finish_drag();
self.pivot_drag = None;
self.marquee = None;
self.panning = false;
}
@ -2129,7 +2221,11 @@ impl Editor {
{
self.edit_content = false;
}
if response.double_clicked() && pivot_hover.is_some() {
self.pivot_relative = [0.5; 2];
}
if response.clicked()
&& pivot_hover.is_none()
&& !self.edit_content
&& let Some(p) = pointer
{
@ -2340,6 +2436,25 @@ impl Editor {
);
}
}
if pivot_visible || self.pivot_drag.is_some() {
for i in self.layout.selected_indices() {
let g = self.layout.layers()[i];
let relative = self.pivot_for(i);
let p = origin
+ Vec2::new(
(g.x + relative[0] * g.width) as f32,
(g.y + relative[1] * g.height) as f32,
) * scale;
let stroke = Stroke::new(1.5_f32, palette.cyan);
screen.painter.circle(p, 6.0, palette.panel, stroke);
screen
.painter
.line_segment([p - Vec2::new(10.0, 0.0), p + Vec2::new(10.0, 0.0)], stroke);
screen
.painter
.line_segment([p - Vec2::new(0.0, 10.0), p + Vec2::new(0.0, 10.0)], stroke);
}
}
for (axis, guide) in self.snap_guides.iter().enumerate() {
if let Some(value) = guide {
let position = if axis == 0 { origin.x } else { origin.y } + *value as f32 * scale;
@ -2431,7 +2546,7 @@ impl Editor {
ink.text(
24.0,
r.height() - 40.0,
if self.edit_content { "Crop mode · Drag crop handles to zoom content · Drag image to reposition · Click outside to finish" } else { match self.active_resize_mode() {
if pivot_visible { "Ctrl: drag pivot · Resize around pivot · Double-click pivot to center · Ctrl+Shift: 100 px grid" } else if self.edit_content { "Crop mode · Drag crop handles to zoom content · Drag image to reposition · Click outside to finish" } else { match self.active_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 cancels drag",
ResizeMode::Mirror => "Mirror horizontally · Left/right mirrored handles · Escape cancels drag",
@ -3110,6 +3225,103 @@ mod tests {
);
frame(app, ctx, vec![mouse(pos, false)]);
}
#[test]
fn linked_pivot_markers_reflect_and_can_be_moved_from_either_layer() {
for mode in [ResizeMode::Same, ResizeMode::Mirror, ResizeMode::Opposite] {
let mut app = Editor {
resize_mode: mode,
..Default::default()
};
app.layout.set_selection([true; 2]);
app.sync();
let before = app.layout.layers().clone();
app.pivot_relative = [0.2, 0.7];
let other = app.pivot_for(1);
assert_eq!(
other,
[
if mode == ResizeMode::Same { 0.2 } else { 0.8 },
if mode == ResizeMode::Opposite {
1.0 - 0.7
} else {
0.7
}
]
);
let g = before[1];
app.move_pivot(1, [g.x + g.width * 0.25, g.y + g.height * 0.75]);
assert_eq!(app.pivot_for(1), [0.25, 0.75]);
assert_eq!(app.layout.layers(), &before);
app.layout.select(Some(0));
app.sync();
assert_eq!(app.pivot_relative, [0.5; 2]);
}
}
#[test]
fn ctrl_drags_pivot_then_resizes_around_it_without_editing_geometry_during_placement() {
let ctx = egui::Context::default();
let mut app = Editor::default();
let ctrl = egui::Modifiers {
ctrl: true,
..Default::default()
};
let before = app.layout.layers().clone();
let output = frame(&mut app, &ctx, vec![]);
let rect = layer_rects(&output)[1];
let start = rect.center();
let end = rect.min + rect.size() * 0.25;
frame_modifiers(
&mut app,
&ctx,
ctrl,
vec![egui::Event::PointerMoved(start), mouse(start, true)],
);
frame_modifiers(&mut app, &ctx, ctrl, vec![egui::Event::PointerMoved(end)]);
frame_modifiers(&mut app, &ctx, ctrl, vec![mouse(end, false)]);
assert_eq!(app.layout.layers(), &before);
assert!((app.pivot_relative[0] - 0.25).abs() < 1e-6);
assert!((app.pivot_relative[1] - 0.25).abs() < 1e-6);
let relative = app.pivot_relative;
// Escape restores placement without adding a document history entry.
let moved = end + Vec2::new(18.0, 12.0);
frame_modifiers(
&mut app,
&ctx,
ctrl,
vec![egui::Event::PointerMoved(end), mouse(end, true)],
);
frame_modifiers(&mut app, &ctx, ctrl, vec![egui::Event::PointerMoved(moved)]);
assert_ne!(app.pivot_relative, relative);
frame_modifiers(&mut app, &ctx, ctrl, vec![key(egui::Key::Escape)]);
frame_modifiers(&mut app, &ctx, ctrl, vec![mouse(moved, false)]);
assert_eq!(app.pivot_relative, relative);
assert_eq!(app.layout.layers(), &before);
let fixed = [
before[1].x + relative[0] * before[1].width,
before[1].y + relative[1] * before[1].height,
];
let start = rect.right_center();
let end = start + Vec2::new(30.0, 0.0);
frame_modifiers(
&mut app,
&ctx,
ctrl,
vec![egui::Event::PointerMoved(start), mouse(start, true)],
);
frame_modifiers(&mut app, &ctx, ctrl, vec![egui::Event::PointerMoved(end)]);
frame_modifiers(&mut app, &ctx, ctrl, vec![mouse(end, false)]);
let after = app.layout.layers()[1];
assert!(after.width > before[1].width);
assert!((after.x + relative[0] * after.width - fixed[0]).abs() < 1e-6);
assert!((after.y + relative[1] * after.height - fixed[1]).abs() < 1e-6);
app.layout.undo();
assert_eq!(app.layout.layers(), &before);
// Pivot placement is session UI state, not a document history step.
assert_eq!(app.pivot_relative, relative);
}
#[test]
fn alt_temporarily_inverts_move_and_resize_snapping_and_overrides_grids() {
for enabled in [false, true] {

View File

@ -400,6 +400,8 @@ pub struct Layout {
}
#[derive(Clone)]
struct Resize {
pivot: [f64; 2],
use_pivot: bool,
mode: ResizeMode,
targets: Vec<bool>,
index: usize,
@ -408,6 +410,39 @@ struct Resize {
start: [f64; 2],
keep_ratio: bool,
}
impl Resize {
fn handle_for(&self, i: usize) -> ResizeHandle {
if i == self.index {
return self.handle;
}
match self.mode {
ResizeMode::Mirror => self.handle.mirrored_horizontally(),
ResizeMode::Opposite => self.handle.opposite(),
_ => self.handle,
}
}
fn anchor(&self, i: usize) -> [f64; 2] {
let g = self.before.layers[i];
if self.use_pivot {
let mut relative = self.pivot;
if i != self.index {
if matches!(self.mode, ResizeMode::Mirror | ResizeMode::Opposite) {
relative[0] = 1.0 - relative[0];
}
if self.mode == ResizeMode::Opposite {
relative[1] = 1.0 - relative[1];
}
}
[g.x + relative[0] * g.width, g.y + relative[1] * g.height]
} else {
ResizeHandle::positions(g)
.into_iter()
.find(|(h, _)| *h == self.handle_for(i).opposite())
.unwrap()
.1
}
}
}
#[derive(Clone, PartialEq)]
struct Snapshot {
info: Vec<LayerInfo>,
@ -700,6 +735,8 @@ impl Layout {
return;
}
self.content_resize = Some(Resize {
pivot: [0.5; 2],
use_pivot: false,
mode: ResizeMode::Individual,
targets: self.selected.clone(),
index,
@ -1237,6 +1274,8 @@ impl Layout {
}
self.select(Some(index));
self.resize = Some(Resize {
pivot: [0.5; 2],
use_pivot: false,
mode: ResizeMode::Individual,
targets: self.selected.clone(),
index,
@ -1271,6 +1310,8 @@ impl Layout {
}
self.finish_drag();
self.resize = Some(Resize {
pivot: [0.5; 2],
use_pivot: false,
mode,
targets: self.selected.clone(),
index,
@ -1281,6 +1322,20 @@ impl Layout {
});
Ok(())
}
/// Set a gesture's pivot relative to the initiating layer; partners mirror it by resize mode.
pub fn set_resize_pivot(&mut self, relative: [f64; 2]) {
if relative.iter().all(|v| v.is_finite() && v.abs() <= 1e6)
&& let Some(resize) = &mut self.resize
{
resize.pivot = relative;
}
}
/// Toggle pivot anchoring during a gesture, always recomputing from its initial geometry.
pub fn use_resize_pivot(&mut self, active: bool) {
if let Some(resize) = &mut self.resize {
resize.use_pivot = active;
}
}
pub fn drag_to(&mut self, point: [f64; 2]) {
self.drag_to_with_precision(point, false);
}
@ -1352,12 +1407,58 @@ impl Layout {
} else {
resized_geometry
};
let next = resize(
original,
r.handle,
[point[0] - r.start[0], point[1] - r.start[1]],
r.keep_ratio,
);
let next = if r.use_pivot {
let pivot = r.anchor(r.index);
let handle = ResizeHandle::positions(original)
.into_iter()
.find(|(h, _)| *h == r.handle)
.unwrap()
.1;
let delta = std::array::from_fn::<_, 2, _>(|axis| {
let d = point[axis] - r.start[axis];
if exact { d } else { d.round() }
});
let vector = [handle[0] - pivot[0], handle[1] - pivot[1]];
let axes = [
!matches!(r.handle, ResizeHandle::Top | ResizeHandle::Bottom),
!matches!(r.handle, ResizeHandle::Left | ResizeHandle::Right),
];
let mut factors = [1.0; 2];
for axis in 0..2 {
if axes[axis] && vector[axis].abs() > 1e-9 {
factors[axis] += delta[axis] / vector[axis];
}
}
if r.keep_ratio {
let denominator: f64 = (0..2)
.filter(|&a| axes[a])
.map(|a| vector[a] * vector[a])
.sum();
let factor = if denominator > 1e-18 {
1.0 + (0..2)
.filter(|&a| axes[a])
.map(|a| delta[a] * vector[a])
.sum::<f64>()
/ denominator
} else {
1.0
};
factors = [factor.max((1.0 / original.width).max(1.0 / original.height)); 2];
}
Geometry {
x: original.x,
y: original.y,
width: (original.width * factors[0]).max(1.0),
height: (original.height * factors[1]).max(1.0),
}
} else {
resize(
original,
r.handle,
[point[0] - r.start[0], point[1] - r.start[1]],
r.keep_ratio,
)
};
let result = (|| {
let mut layers = r.before.layers.clone();
let mut formats = r.before.formats.clone();
@ -1389,7 +1490,15 @@ impl Layout {
} else {
r.handle
};
*geometry = if r.mode == ResizeMode::Individual {
*geometry = if r.use_pivot {
let pivot = r.anchor(i);
Geometry {
x: pivot[0] + (before.x - pivot[0]) * sx,
y: pivot[1] + (before.y - pivot[1]) * sy,
width: before.width * sx,
height: before.height * sy,
}
} else if r.mode == ResizeMode::Individual {
next
} else {
anchored_resize(before, handle, before.width * sx, before.height * sy)

View File

@ -65,6 +65,8 @@ impl Editor {
self.snapping_options(ui);
ui.weak("Applies to layer movement/resize, not numeric entry or crop-content handles.");
ui.separator();
ui.label("Ctrl: show/move resize pivot · Ctrl-resize: keep pivot fixed");
ui.label("Double-click pivot: reset to center · Ctrl+Shift: 100 px grid");
ui.label("Arrow keys: move 1 pixel · Shift-arrow: move 10 pixels");
ui.label("Shift-click: add/remove a layer from selection");
ui.label("Space-drag or middle button: pan · Scroll: zoom");

View File

@ -229,7 +229,7 @@ impl Layout {
if options.layer_edges && matches!(r.mode, ResizeMode::Mirror | ResizeMode::Opposite) {
let original = r.before.layers[r.index];
let moving = handle_point(original)[axis];
let anchor = 2.0 * original.center()[axis] - moving;
let anchor = r.anchor(r.index)[axis];
for (i, other) in r.before.layers.iter().enumerate() {
if i == r.index || !r.targets[i] || !self.visible(i) {
continue;
@ -244,7 +244,7 @@ impl Layout {
.find(|(h, _)| *h == other_handle)
.unwrap()
.1[axis];
let other_anchor = 2.0 * other.center()[axis] - other_moving;
let other_anchor = r.anchor(i)[axis];
let span = moving - anchor;
let other_span = other_moving - other_anchor;
// Both edges move with the same scale factor, in opposite
@ -278,10 +278,11 @@ impl Layout {
if r.keep_ratio && matches!(r.handle, ResizeHandle::Corner(_)) {
let original = r.before.layers[r.index];
let original_handle = handle_point(original);
let anchor = [
2.0 * original.center()[0] - original_handle[0],
2.0 * original.center()[1] - original_handle[1],
];
let anchor = r.anchor(r.index);
if (original_handle[axis] - anchor[axis]).abs() < 1e-9 {
self.restore(base.clone());
continue;
}
let factor = (target - anchor[axis]) / (original_handle[axis] - anchor[axis]);
for j in 0..2 {
adjusted[j] = r.start[j] + (original_handle[j] - anchor[j]) * (factor - 1.0);

View File

@ -0,0 +1,189 @@
use midra_layout::{Geometry, Layout, ResizeHandle, ResizeMode, snapping::Snapping};
fn near(a: f64, b: f64) {
assert!((a - b).abs() < 1e-7, "{a} != {b}");
}
fn pivot(g: Geometry, relative: [f64; 2]) -> [f64; 2] {
[g.x + g.width * relative[0], g.y + g.height * relative[1]]
}
#[test]
fn all_handles_keep_custom_pivots_fixed_in_each_resize_mode() {
for mode in [
ResizeMode::Individual,
ResizeMode::Same,
ResizeMode::Mirror,
ResizeMode::Opposite,
] {
for ratio in [false, true] {
for relative in [[0.5, 0.5], [0.2, 0.7], [-0.25, 1.25]] {
for index in [0, 1] {
let mut layout = Layout::default();
layout
.apply(
1,
Geometry {
width: 320.0,
height: 240.0,
..layout.layers()[1]
},
)
.unwrap();
let before = layout.layers().clone();
for (handle, start) in ResizeHandle::positions(before[index]) {
layout.set_selection([true; 2]);
let formats = layout.formats().clone();
layout
.start_selected_resize(index, handle, start, ratio, mode)
.unwrap();
layout.set_resize_pivot(relative);
layout.use_resize_pivot(true);
layout.drag_to([start[0] + 17.0, start[1] + 11.0]);
for (i, original) in before.iter().enumerate() {
if mode == ResizeMode::Individual && i != index {
assert_eq!(layout.layers()[i], *original);
continue;
}
let mut rp = relative;
if i != index {
if matches!(mode, ResizeMode::Mirror | ResizeMode::Opposite) {
rp[0] = 1.0 - rp[0];
}
if mode == ResizeMode::Opposite {
rp[1] = 1.0 - rp[1];
}
}
let old = pivot(*original, rp);
let new = pivot(layout.layers()[i], rp);
near(old[0], new[0]);
near(old[1], new[1]);
if ratio {
near(
layout.layers()[i].width / layout.layers()[i].height,
original.width / original.height,
);
}
}
let resized = layout.layers().clone();
layout.finish_drag();
layout.undo();
assert_eq!(layout.layers(), &before);
assert_eq!(layout.formats(), &formats);
layout.redo();
assert_eq!(layout.layers(), &resized);
layout.undo();
}
}
}
}
}
}
#[test]
fn pivot_toggle_recomputes_without_drift_and_degenerate_handles_stay_valid() {
let mut layout = Layout::default();
let before = layout.layers().clone();
layout.start_handle_resize(1, ResizeHandle::Right, [1800.0, 360.0], false);
for _ in 0..3 {
layout.use_resize_pivot(true);
layout.drag_to([1900.0, 360.0]);
near(layout.layers()[1].center()[0], before[1].center()[0]);
near(layout.layers()[1].width, 840.0);
layout.use_resize_pivot(false);
layout.drag_to([1900.0, 360.0]);
near(layout.layers()[1].x, before[1].x);
near(layout.layers()[1].width, 740.0);
}
layout.set_resize_pivot([1.0, 0.5]);
layout.use_resize_pivot(true);
layout.drag_to([1900.0, 360.0]);
assert_eq!(layout.layers(), &before);
layout.cancel_drag();
assert_eq!(layout.layers(), &before);
}
#[test]
fn pivot_resizing_preserves_screen_and_mirror_contact_snaps() {
for ratio in [false, true] {
let mut layout = Layout::default();
let before = layout.layers().clone();
layout.set_selection([true; 2]);
layout
.start_selected_resize(
0,
ResizeHandle::Right,
[760.0, 360.0],
ratio,
ResizeMode::Mirror,
)
.unwrap();
layout.set_resize_pivot([0.25, 0.6]);
layout.use_resize_pivot(true);
let guides = layout.drag_to_snapped(
[958.0, 360.0],
Snapping {
enabled: true,
..Default::default()
},
6.0,
);
assert_eq!(guides[0], Some(960.0));
near(
layout.layers()[0].x + layout.layers()[0].width,
layout.layers()[1].x,
);
near(
pivot(layout.layers()[0], [0.25, 0.6])[0],
pivot(before[0], [0.25, 0.6])[0],
);
layout.cancel_drag();
layout.start_handle_resize(1, ResizeHandle::Right, [1800.0, 360.0], ratio);
layout.use_resize_pivot(true);
let guides = layout.drag_to_snapped(
[1918.0, 360.0],
Snapping {
enabled: true,
..Default::default()
},
6.0,
);
assert_eq!(guides[0], Some(1920.0));
near(layout.layers()[1].center()[0], before[1].center()[0]);
}
}
#[test]
fn ratio_locked_corner_snaps_without_shifting_pivot() {
use midra_layout::Corner;
let mut layout = Layout::default();
let g = layout.layers()[1];
let relative = [0.2, 0.7];
let fixed = pivot(g, relative);
layout.start_handle_resize(
1,
ResizeHandle::Corner(Corner::BottomRight),
[1800.0, 540.0],
true,
);
layout.set_resize_pivot(relative);
layout.use_resize_pivot(true);
let point = [
1918.0,
540.0 + 118.0 * (540.0 - fixed[1]) / (1800.0 - fixed[0]),
];
let guides = layout.drag_to_snapped(
point,
Snapping {
enabled: true,
..Default::default()
},
6.0,
);
assert_eq!(guides[0], Some(1920.0));
near(pivot(layout.layers()[1], relative)[0], fixed[0]);
near(pivot(layout.layers()[1], relative)[1], fixed[1]);
near(
layout.layers()[1].width / layout.layers()[1].height,
g.width / g.height,
);
}

View File

@ -110,3 +110,7 @@ Shift temporarily overrides snapping with a 10-screen-pixel grid for layer movem
**Settings → Midra integration → Allow sending to Program** saves immediately. Restore default settings disables it. Projects do not override this application preference; the Preview/Program destination itself remains session-only.
**Try autoconnecting at startup** is in Settings → Midra integration. It saves immediately but applies on the next launch; toggling it does not initiate a connection. One background attempt uses the regular connection timeout and error handling, with no automatic retry loop. Failures leave the app offline and are reported in Midra connection. Project loading does not trigger an attempt.
Ctrl without Shift shows temporary per-selection resize pivots and activates pivot
anchoring during layer handle resizing. Pivot positions are not application settings
and are not persisted. Ctrl+Shift retains its 100 px grid and normal resize anchors.

View File

@ -111,7 +111,7 @@ missing fields and non-finite values are rejected before replacing the document.
Projects larger than 96 MiB are rejected.
Save includes **applied values only**. Pending text/format/import drafts, open
dialogs, undo/redo history, crop-edit mode, resize mode, and provisional device
dialogs, undo/redo history, crop-edit mode, resize mode, temporary resize pivots, and provisional device
export calculations are not persisted. The current resize mode stays selected
when opening another project in the same session; a fresh launch starts with
Individual mode. Names and folder labels are stored. Removing layers does not renumber surviving

View File

@ -284,6 +284,32 @@ 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.
### Ctrl resize pivot
Hold **Ctrl** to show a draggable crosshair pivot on selected layers (center by
default). Drag the marker to place it, including outside the layer; this does not
change the document. Double-click it while holding Ctrl to reset to center.
**Ctrl-drag a layer resize handle** to resize around the fixed pivot. Ctrl can be
pressed/released during the gesture; the result is recalculated from the starting
geometry. Release Ctrl for the normal opposite-edge anchor. Escape cancels a
resize or restores the previous pivot placement.
| Resize mode | Pivot behavior |
| --- | --- |
| Individual | Only the dragged layer resizes around its pivot |
| Same handles | Each layer uses the same relative pivot position and scale factors |
| Mirror horizontally | The partner's pivot is reflected left/right |
| Opposite handles | The partner's pivot is reflected on both axes |
Moving any marker updates the related markers. Each layer's pivot stays fixed
while resizing; unequal sizes retain proportional scaling. Aspect-ratio lock,
snapping (including edge contact), Alt inversion and Undo still apply. A handle
on the pivot's axis cannot resize that axis; move the pivot or use another handle.
Layers do not flip when dragged through the pivot; minimum sizes still apply.
**Ctrl+Shift remains the 100 px grid**, using normal anchors. Pivots are temporary,
reset on selection changes/project loads, and follow layers when moved. They are
not saved and do not affect numeric sizing or Adjust layer crop mode.
### Resizing with corner handles
Drag a selected layer's gold corner handles to resize it; the opposite corner

View File

@ -4,6 +4,8 @@
## Unreleased
- Ctrl shows a movable resize pivot; Ctrl-resize keeps it fixed. Same/Mirror/Opposite modes share or reflect relative pivots. Double-click resets; Ctrl+Shift keeps the 100 px grid. Session-only, with snapping and Undo.
- Hold Alt to temporarily invert movement/resize snapping (on ↔ off), overriding Shift grids without changing saved settings.
- Add Snapping controls to viewport right-click and quick Options menus; share and automatically save the same editing settings.