diff --git a/crates/midra-layout/src/gui.rs b/crates/midra-layout/src/gui.rs index d3b71c2..b4f191f 100644 --- a/crates/midra-layout/src/gui.rs +++ b/crates/midra-layout/src/gui.rs @@ -1,5 +1,5 @@ use super::*; -use midra_layout::{Corner, DrawioShape, Geometry, Layout, parse_drawio}; +use midra_layout::{AlignTarget, Alignment, Corner, DrawioShape, Geometry, Layout, parse_drawio}; pub struct Editor { layout: Layout, @@ -10,6 +10,15 @@ pub struct Editor { zoom: f32, pan: Vec2, panning: bool, + marquee: Option, + align_target: AlignTarget, +} +#[derive(Clone, Copy)] +struct Marquee { + start: [f64; 2], + end: [f64; 2], + base: [bool; 2], + previous: [bool; 2], } struct Paste { target: usize, @@ -46,6 +55,8 @@ impl Default for Editor { zoom: 1.0, pan: Vec2::ZERO, panning: false, + marquee: None, + align_target: AlignTarget::Selection, }; this.sync(); this @@ -95,7 +106,7 @@ impl Editor { } self.paste = Some(p); } else { - self.error = "Select a layer before pasting.".into(); + self.error = "Select exactly one layer before pasting.".into(); } } fn apply_fields(&mut self) { @@ -120,17 +131,25 @@ impl Editor { } } fn copy(&self, ctx: &egui::Context) { - if let Some(i) = self.layout.selected() { - let g = self.layout.layers()[i]; - let [h, v] = g.center(); - ctx.copy_text(format!( - "{}\nHorizontal: {} px\nVertical: {} px\nWidth: {} px\nHeight: {} px", - label(i), - number(h), - number(v), - number(g.width), - number(g.height) - )); + let entries: Vec<_> = self + .layout + .selected_indices() + .into_iter() + .map(|i| { + let g = self.layout.layers()[i]; + let [h, v] = g.center(); + format!( + "{}\nHorizontal: {} px\nVertical: {} px\nWidth: {} px\nHeight: {} px", + label(i), + number(h), + number(v), + number(g.width), + number(g.height) + ) + }) + .collect(); + if !entries.is_empty() { + ctx.copy_text(entries.join("\n\n")); } } fn shortcuts(&mut self, ctx: &egui::Context) { @@ -139,6 +158,9 @@ impl Editor { } if ctx.input(|i| i.key_pressed(egui::Key::Escape)) { self.layout.cancel_drag(); + if let Some(m) = self.marquee.take() { + self.layout.set_selection(m.previous); + } self.sync(); ctx.memory_mut(|m| { if let Some(id) = m.focused() { @@ -166,7 +188,7 @@ impl Editor { self.open_paste(text); return; } - if self.layout.dragging() { + if self.layout.dragging() || self.marquee.is_some() || self.panning { return; } let command = ctx.input(|i| i.modifiers.command); @@ -313,7 +335,7 @@ impl Editor { } fn inspector(&mut self, ui: &mut egui::Ui) { let (r, _) = - ui.allocate_exact_size(Vec2::new(ui.available_width(), 920.0), egui::Sense::hover()); + ui.allocate_exact_size(Vec2::new(ui.available_width(), 960.0), egui::Sense::hover()); let ink = Ink::new(ui, r); let w = r.width(); ink.text(0.0, 2.0, "LAYERS", 11.0, MUTED); @@ -326,7 +348,7 @@ impl Editor { w, 38.0, FIELD, - if self.layout.selected() == Some(i) { + if self.layout.selection_mask()[i] { color } else { LINE @@ -334,13 +356,34 @@ impl Editor { ); ink.text(13.0, y + 10.0, label(i), 15.0, color); if click(ui, &ink, [0.0, y, w, 38.0], ("layer", i)) { - self.layout.select(Some(i)); + if click_shift_modifier(ui) { + self.layout.toggle(i); + } else { + self.layout.select(Some(i)); + } self.sync(); } } ink.line([0.0, 130.0], [w, 130.0], LINE); + if self.layout.selected_indices().len() > 1 { + self.alignment_inspector(ui, &ink, w); + return; + } let Some(i) = self.layout.selected() else { - ink.text(0.0, 153.0, "Select a layer to edit or paste.", 17.0, TEXT); + ink.text( + 0.0, + 153.0, + "Select a layer, or drag a selection box.", + 16.0, + TEXT, + ); + ink.text( + 0.0, + 182.0, + "Shift-click to add or remove layers.", + 13.0, + MUTED, + ); return; }; let g = self.layout.layers()[i]; @@ -426,7 +469,7 @@ impl Editor { ink.text( 0.0, 579.0, - "Outside screen · use Fit layer to find it", + "Outside screen · use Fit selected to find it", 12.0, AMBER, ); @@ -459,6 +502,88 @@ impl Editor { MUTED, ); } + fn alignment_inspector(&mut self, ui: &mut egui::Ui, ink: &Ink, w: f32) { + ink.text(0.0, 150.0, "2 layers selected", 25.0, TEXT); + ink.text( + 0.0, + 187.0, + "Drag or nudge to move the selection together.", + 12.0, + MUTED, + ); + ink.text(0.0, 225.0, "ALIGN TO", 11.0, MUTED); + let half = (w - 12.0) / 2.0; + for (index, title, target) in [ + (0, "Selection bounds", AlignTarget::Selection), + (1, "Screen", AlignTarget::Screen), + (2, "Reference: Presenter", AlignTarget::Layer(0)), + (3, "Reference: Slides", AlignTarget::Layer(1)), + ] { + let x = if index % 2 == 0 { 0.0 } else { half + 12.0 }; + let y = 250.0 + (index / 2) as f32 * 42.0; + ink.button(x, y, half, title, self.align_target == target); + if click(ui, ink, [x, y, half, 34.0], title) { + self.align_target = target; + } + } + for (index, title, alignment) in [ + (0, "Align left", Alignment::Left), + (1, "Align top", Alignment::Top), + (2, "Align right", Alignment::Right), + (3, "Align bottom", Alignment::Bottom), + (4, "Center X", Alignment::HorizontalCenter), + (5, "Center Y", Alignment::VerticalCenter), + ] { + let x = if index % 2 == 0 { 0.0 } else { half + 12.0 }; + let y = 350.0 + (index / 2) as f32 * 46.0; + ink.button(x, y, half, title, false); + if click(ui, ink, [x, y, half, 34.0], title) { + match self.layout.align(alignment, self.align_target) { + Ok(()) => self.sync(), + Err(e) => self.error = e, + } + } + } + ink.text( + 0.0, + 503.0, + "Alignment changes position, never size.", + 12.0, + MUTED, + ); + ink.text(0.0, 526.0, "A reference layer stays fixed.", 12.0, MUTED); + ink.line([0.0, 559.0], [w, 559.0], LINE); + ink.text(0.0, 581.0, "WEBRCS / CENTER POSITIONS", 11.0, CYAN); + for (row, i) in self.layout.selected_indices().into_iter().enumerate() { + let y = 615.0 + row as f32 * 80.0; + let [x, cy] = self.layout.layers()[i].center(); + ink.text(0.0, y, label(i), 13.0, MUTED); + ink.text( + 0.0, + y + 25.0, + &format!("H {} V {}", number(x), number(cy)), + 19.0, + TEXT, + ); + } + ink.button(0.0, 792.0, w, "Copy selected positions", true); + if click(ui, ink, [0.0, 792.0, w, 34.0], "copy-selected") { + self.copy(ui.ctx()); + } + ink.text( + 0.0, + 849.0, + "Select one layer to edit its size or paste.", + 12.0, + MUTED, + ); + if !self.error.is_empty() { + ui.put( + Rect::from_min_size(ink.point(0.0, 880.0), Vec2::new(w, 60.0)), + egui::Label::new(egui::RichText::new(&self.error).color(AMBER)).wrap(), + ); + } + } fn workspace(&mut self, ui: &mut egui::Ui) { let r = ui.max_rect(); let ink = Ink::new(ui, r); @@ -466,9 +591,9 @@ impl Editor { ink.text(224.0, 30.0, "1920 × 1080 · fixed for now", 12.0, MUTED); for (x, w, text) in [ (24.0, 103.0, "Fit screen"), - (139.0, 91.0, "Fit layer"), - (242.0, 80.0, "Undo"), - (334.0, 80.0, "Redo"), + (139.0, 103.0, "Fit selected"), + (254.0, 80.0, "Undo"), + (346.0, 80.0, "Redo"), ] { ink.button(x, 67.0, w, text, false); if click(ui, &ink, [x, 67.0, w, 34.0], text) { @@ -477,9 +602,8 @@ impl Editor { self.zoom = 1.0; self.pan = Vec2::ZERO; } - "Fit layer" => { - if let Some(i) = self.layout.selected() { - let g = self.layout.layers()[i]; + "Fit selected" => { + if let Some(g) = self.layout.selection_bounds() { self.zoom = (1920.0 / g.width).min(1080.0 / g.height) as f32 * 0.8; self.zoom = self.zoom.clamp(0.02, 32.0); let c = g.center(); @@ -497,8 +621,8 @@ impl Editor { } } } - ink.button(426.0, 67.0, 154.0, "Paste draw.io…", true); - if click(ui, &ink, [426.0, 67.0, 154.0, 34.0], "toolbar-paste") { + ink.button(438.0, 67.0, 154.0, "Paste draw.io…", true); + if click(ui, &ink, [438.0, 67.0, 154.0, 34.0], "toolbar-paste") { self.open_paste(String::new()); } ink.text(25.0, 132.0, "YOUR SCREEN, PRECISELY PLACED", 12.0, CYAN); @@ -512,7 +636,8 @@ impl Editor { let mut origin = area.center() - Vec2::new(960.0, 540.0) * scale + self.pan * scale; let response = ui.interact(area, egui::Id::new("canvas"), egui::Sense::click_and_drag()); let pointer = ui.input(|i| i.pointer.interact_pos()); - if response.hovered() && !self.layout.dragging() && !self.panning { + if response.hovered() && !self.layout.dragging() && !self.panning && self.marquee.is_none() + { let scroll = ui.input(|i| i.smooth_scroll_delta.y); if scroll != 0.0 && let Some(p) = pointer @@ -524,7 +649,9 @@ impl Editor { origin = area.center() - Vec2::new(960.0, 540.0) * scale + self.pan * scale; } } - if response.drag_started() { + if response.drag_started_by(egui::PointerButton::Primary) + || response.drag_started_by(egui::PointerButton::Middle) + { ui.ctx().memory_mut(|m| { if let Some(id) = m.focused() { m.surrender_focus(id); @@ -537,7 +664,21 @@ impl Editor { && let Some(p) = ui.input(|i| i.pointer.press_origin()) { let p = (p - origin) / scale; - self.layout.start_drag([p.x as f64, p.y as f64]); + 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() { + let previous = self.layout.selection_mask(); + let base = if shift { previous } else { [false; 2] }; + self.marquee = Some(Marquee { + start: point, + end: point, + base, + previous, + }); + self.layout.set_selection(base); + } else { + self.layout.start_drag(point); + } self.sync(); } } @@ -547,27 +688,46 @@ impl Editor { origin += response.drag_delta(); } else if let Some(p) = pointer { let p = (p - origin) / scale; - self.layout.drag_to([p.x as f64, p.y as f64]); + let point = [p.x as f64, p.y as f64]; + if let Some(m) = self.marquee.as_mut() { + m.end = point; + self.layout.select_region(m.start, point, m.base); + } else { + self.layout.drag_to(point); + } self.sync(); } } if response.drag_stopped() { - if self.layout.dragging() + if (self.layout.dragging() || self.marquee.is_some()) && let Some(p) = pointer { let p = (p - origin) / scale; - self.layout.drag_to([p.x as f64, p.y as f64]); + let point = [p.x as f64, p.y as f64]; + if let Some(m) = self.marquee.as_mut() { + m.end = point; + self.layout.select_region(m.start, point, m.base); + } else { + self.layout.drag_to(point); + } self.sync(); } self.layout.finish_drag(); + self.marquee = None; self.panning = false; } if response.clicked() && let Some(p) = pointer { let p = (p - origin) / scale; - self.layout - .select(self.layout.hit([p.x as f64, p.y as f64])); + let hit = 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); + } + } else { + self.layout.select(hit); + } self.sync(); ui.ctx().memory_mut(|m| { if let Some(id) = m.focused() { @@ -614,7 +774,7 @@ impl Editor { ); } } - if self.layout.selected() == Some(i) { + if self.layout.selection_mask()[i] { for corner in [ rect.left_top(), rect.right_top(), @@ -645,6 +805,17 @@ impl Editor { ); } } + if let Some(m) = self.marquee { + let from = origin + Vec2::new(m.start[0] as f32, m.start[1] as f32) * scale; + let to = origin + Vec2::new(m.end[0] as f32, m.end[1] as f32) * scale; + screen.painter.rect( + Rect::from_two_pos(from, to), + 0.0, + Color32::from_rgba_unmultiplied(102, 219, 239, 25), + Stroke::new(1.0_f32, CYAN), + StrokeKind::Inside, + ); + } if let Some(i) = self.layout.selected() { let g = self.layout.layers()[i]; if !g.outside() { @@ -692,7 +863,7 @@ impl Editor { ink.text( 24.0, r.height() - 57.0, - "Drag layer · Arrows 1 px · Shift 10 px · Ctrl/Cmd-V paste", + "Drag to move or box-select · Shift-click toggles selection", 12.0, MUTED, ); @@ -705,6 +876,26 @@ impl Editor { ); } } +// Use the modifiers attached to the click, even if Shift was released later +// in the same input frame. +fn click_shift_modifier(ui: &egui::Ui) -> bool { + ui.input(|input| { + input + .events + .iter() + .rev() + .find_map(|event| match event { + egui::Event::PointerButton { + button: egui::PointerButton::Primary, + pressed: false, + modifiers, + .. + } => Some(modifiers.shift), + _ => None, + }) + .unwrap_or(input.modifiers.shift) + }) +} fn click(ui: &egui::Ui, ink: &Ink, b: [f32; 4], id: impl std::hash::Hash) -> bool { let clicked = ui .interact( @@ -757,8 +948,8 @@ impl Editor { ink.text( 116.0, 10.0, - if self.layout.selected().is_some() { - "draw.io geometry · 1 unit = 1 px" + if !self.layout.selected_indices().is_empty() { + "Shift-click or drag a box to select layers" } else { "Select a layer to move or paste" }, @@ -778,7 +969,9 @@ impl Editor { .resizable(false) .frame(egui::Frame::NONE.fill(PANEL).inner_margin(24.0)) .show(ctx, |ui| { - egui::ScrollArea::vertical().show(ui, |ui| self.inspector(ui)); + egui::ScrollArea::vertical() + .drag_to_scroll(false) + .show(ui, |ui| self.inspector(ui)); }); egui::CentralPanel::default() .frame(egui::Frame::NONE.fill(BG)) @@ -1041,4 +1234,153 @@ mod tests { app.layout.undo(); assert_eq!(*app.layout.layers(), before); } + fn frame_shift( + app: &mut Editor, + ctx: &egui::Context, + events: Vec, + ) -> egui::FullOutput { + ctx.run( + egui::RawInput { + screen_rect: Some(Rect::from_min_size(Pos2::ZERO, Vec2::new(1440.0, 940.0))), + events, + modifiers: egui::Modifiers::SHIFT, + ..Default::default() + }, + |ctx| app.ui(ctx), + ) + } + fn click_shift(app: &mut Editor, ctx: &egui::Context, p: Pos2) { + let event = |pressed| egui::Event::PointerButton { + pos: p, + button: egui::PointerButton::Primary, + pressed, + modifiers: egui::Modifiers::SHIFT, + }; + frame_shift(app, ctx, vec![egui::Event::PointerMoved(p), event(true)]); + frame(app, ctx, vec![event(false)]); // Shift released by the end of this frame. + } + fn layer_rects(output: &egui::FullOutput) -> Vec { + output + .shapes + .iter() + .filter_map(|s| match &s.shape { + egui::epaint::Shape::Rect(r) if r.fill == Color32::from_rgb(23, 59, 80) => { + Some(r.rect) + } + _ => None, + }) + .collect() + } + #[test] + fn shift_click_toggles_canvas_and_list_selection() { + let mut app = Editor::default(); + let ctx = egui::Context::default(); + let output = frame(&mut app, &ctx, vec![]); + let rects = layer_rects(&output); + assert_eq!(rects.len(), 2); + click_shift(&mut app, &ctx, rects[0].center()); + assert_eq!(app.layout.selected_indices(), vec![0, 1]); + click_shift(&mut app, &ctx, rects[1].center()); + assert_eq!(app.layout.selected(), Some(0)); + click_shift(&mut app, &ctx, Pos2::new(1180.0, 180.0)); + assert_eq!(app.layout.selected_indices(), vec![0, 1]); + let row = ctx + .read_response(egui::Id::new(("layer", 0_usize))) + .unwrap() + .rect; + click_shift(&mut app, &ctx, row.center()); + assert_eq!(app.layout.selection_mask(), [false, true]); + } + #[test] + fn marquee_selects_both_at_different_camera_transforms_without_moving_them() { + for zoom in [0.6, 1.0] { + let mut app = Editor { + zoom, + pan: Vec2::new(10.0, -8.0), + ..Default::default() + }; + let ctx = egui::Context::default(); + let output = frame(&mut app, &ctx, vec![]); + let before = *app.layout.layers(); + let rects = layer_rects(&output); + let area = rects[0].union(rects[1]).expand(10.0); + let start = area.left_top(); + let end = area.right_bottom(); + frame( + &mut app, + &ctx, + vec![egui::Event::PointerMoved(start), mouse(start, true)], + ); + frame(&mut app, &ctx, vec![egui::Event::PointerMoved(end)]); + assert!(app.marquee.is_some()); + frame(&mut app, &ctx, vec![mouse(end, false)]); + assert_eq!(app.layout.selected_indices(), vec![0, 1]); + assert!(app.marquee.is_none()); + assert_eq!(*app.layout.layers(), before); + } + } + #[test] + fn escape_cancels_selection_box_and_restores_previous_selection() { + let mut app = Editor::default(); + let ctx = egui::Context::default(); + let output = frame(&mut app, &ctx, vec![]); + let rects = layer_rects(&output); + let area = rects[0].union(rects[1]).expand(10.0); + let start = area.left_top(); + let end = area.right_bottom(); + frame( + &mut app, + &ctx, + vec![egui::Event::PointerMoved(start), mouse(start, true)], + ); + frame(&mut app, &ctx, vec![egui::Event::PointerMoved(end)]); + assert_eq!(app.layout.selected_indices(), vec![0, 1]); + frame(&mut app, &ctx, vec![key(egui::Key::Escape)]); + frame(&mut app, &ctx, vec![mouse(end, false)]); + assert_eq!(app.layout.selected(), Some(1)); + assert!(app.marquee.is_none()); + } + #[test] + fn alignment_button_updates_selected_layers_and_undo_restores() { + let mut app = Editor::default(); + let ctx = egui::Context::default(); + app.layout + .apply( + 0, + Geometry { + x: 90.0, + y: 60.0, + width: 300.0, + height: 200.0, + }, + ) + .unwrap(); + app.layout.set_selection([true; 2]); + let before = *app.layout.layers(); + 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 == "Align top" => { + Some(t.pos + Vec2::new(20.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.layout.layers()[1].y, 60.0); + assert_eq!(app.layout.layers()[1].x, before[1].x); + assert_eq!(app.layout.layers()[0], before[0]); + app.layout.undo(); + assert_eq!(*app.layout.layers(), before); + app.open_paste(include_str!("../tests/fixtures/drawio-rectangle.txt").into()); + assert!(app.paste.is_none()); + assert!(app.error.contains("exactly one")); + } } diff --git a/crates/midra-layout/src/lib.rs b/crates/midra-layout/src/lib.rs index 2673f9e..22539b9 100644 --- a/crates/midra-layout/src/lib.rs +++ b/crates/midra-layout/src/lib.rs @@ -80,13 +80,32 @@ impl Corner { } } +/// Edge or center line to align, without resizing layers. +#[derive(Clone, Copy, Debug, PartialEq)] +pub enum Alignment { + Left, + Right, + Top, + Bottom, + HorizontalCenter, + VerticalCenter, +} +/// Explicit alignment reference, independent of selection order. +#[derive(Clone, Copy, Debug, Default, PartialEq)] +pub enum AlignTarget { + #[default] + Selection, + Screen, + Layer(usize), +} + /// Two-layer document with one undo record per complete gesture/edit. pub struct Layout { layers: [Geometry; 2], - selected: Option, + selected: [bool; 2], undo: Vec<[Geometry; 2]>, redo: Vec<[Geometry; 2]>, - drag: Option<(usize, [Geometry; 2], [f64; 2])>, + drag: Option<([bool; 2], [Geometry; 2], [f64; 2])>, } impl Default for Layout { fn default() -> Self { @@ -105,7 +124,7 @@ impl Default for Layout { height: 360.0, }, ], - selected: Some(1), + selected: [false, true], undo: Vec::new(), redo: Vec::new(), drag: None, @@ -116,12 +135,114 @@ impl Layout { pub fn layers(&self) -> &[Geometry; 2] { &self.layers } + /// A single selected layer, or None for zero/multiple selections. pub fn selected(&self) -> Option { + let indices = self.selected_indices(); + if indices.len() == 1 { + Some(indices[0]) + } else { + None + } + } + pub fn selected_indices(&self) -> Vec { + (0..2).filter(|i| self.selected[*i]).collect() + } + pub fn selection_mask(&self) -> [bool; 2] { self.selected } - pub fn select(&mut self, index: Option) { + pub fn set_selection(&mut self, selected: [bool; 2]) { self.finish_drag(); - self.selected = index.filter(|i| *i < 2); + self.selected = selected; + } + pub fn select(&mut self, index: Option) { + self.set_selection(std::array::from_fn(|i| index == Some(i))); + } + pub fn toggle(&mut self, index: usize) { + self.finish_drag(); + if let Some(selected) = self.selected.get_mut(index) { + *selected = !*selected; + } + } + /// Select rectangles intersecting the marquee; base supplies Shift-additive selection. + pub fn select_region(&mut self, start: [f64; 2], end: [f64; 2], base: [bool; 2]) { + let left = start[0].min(end[0]); + let right = start[0].max(end[0]); + let top = start[1].min(end[1]); + let bottom = start[1].max(end[1]); + self.set_selection(std::array::from_fn(|i| { + let g = self.layers[i]; + base[i] + || (g.x <= right && g.x + g.width >= left && g.y <= bottom && g.y + g.height >= top) + })); + } + pub fn selection_bounds(&self) -> Option { + let mut bounds = None::; + for i in self.selected_indices() { + let g = self.layers[i]; + bounds = Some(match bounds { + None => g, + Some(b) => { + let x = b.x.min(g.x); + let y = b.y.min(g.y); + Geometry { + x, + y, + width: (b.x + b.width).max(g.x + g.width) - x, + height: (b.y + b.height).max(g.y + g.height) - y, + } + } + }); + } + bounds + } + /// Align only selected rectangles; preserve size and the unrelated axis. + pub fn align(&mut self, alignment: Alignment, target: AlignTarget) -> Result<(), String> { + self.finish_drag(); + let bounds = self.selection_bounds().ok_or("Select layers to align.")?; + let reference = match target { + AlignTarget::Selection => bounds, + AlignTarget::Screen => Geometry { + x: 0.0, + y: 0.0, + width: 1920.0, + height: 1080.0, + }, + AlignTarget::Layer(i) => { + if !self.selected.get(i).copied().unwrap_or(false) { + return Err("Select the reference layer too.".into()); + } + self.layers[i] + } + }; + let mut next = self.layers; + for i in self.selected_indices() { + if target == AlignTarget::Layer(i) { + continue; + } + let g = &mut next[i]; + match alignment { + Alignment::Left => g.x = reference.x, + Alignment::Right => g.x = reference.x + reference.width - g.width, + Alignment::Top => g.y = reference.y, + Alignment::Bottom => g.y = reference.y + reference.height - g.height, + Alignment::HorizontalCenter => { + g.x = reference.x + (reference.width - g.width) / 2.0 + } + Alignment::VerticalCenter => { + g.y = reference.y + (reference.height - g.height) / 2.0 + } + } + } + self.commit(next) + } + fn commit(&mut self, next: [Geometry; 2]) -> Result<(), String> { + for g in next { + g.validate()?; + } + let before = self.layers; + self.layers = next; + self.remember(before); + Ok(()) } pub fn hit(&self, point: [f64; 2]) -> Option { (0..2).rev().find(|i| self.layers[*i].contains(point)) @@ -147,36 +268,36 @@ impl Layout { Ok(()) } pub fn nudge(&mut self, dx: f64, dy: f64) -> Result<(), String> { - if let Some(i) = self.selected { - let g = self.layers[i]; - self.apply( - i, - Geometry { - x: g.x + dx, - y: g.y + dy, - ..g - }, - )?; + self.finish_drag(); + let mut next = self.layers; + for i in self.selected_indices() { + next[i].x += dx; + next[i].y += dy; } - Ok(()) + self.commit(next) } pub fn start_drag(&mut self, point: [f64; 2]) { self.finish_drag(); - self.selected = self.hit(point); - if let Some(i) = self.selected { - self.drag = Some((i, self.layers, point)); + if let Some(i) = self.hit(point) { + if !self.selected[i] { + self.select(Some(i)); + } + self.drag = Some((self.selected, self.layers, point)); + } else { + self.select(None); } } pub fn drag_to(&mut self, point: [f64; 2]) { - if let Some((i, before, start)) = self.drag { - let g = before[i]; - let next = Geometry { - x: g.x + (point[0] - start[0]).round(), - y: g.y + (point[1] - start[1]).round(), - ..g - }; - if next.validate().is_ok() { - self.layers[i] = next; + if let Some((selected, before, start)) = self.drag { + let mut next = before; + for i in 0..2 { + if selected[i] { + next[i].x += (point[0] - start[0]).round(); + next[i].y += (point[1] - start[1]).round(); + } + } + if next.iter().all(|g| g.validate().is_ok()) { + self.layers = next; } } } diff --git a/crates/midra-layout/tests/positioning.rs b/crates/midra-layout/tests/positioning.rs index b53bbd5..c231c45 100644 --- a/crates/midra-layout/tests/positioning.rs +++ b/crates/midra-layout/tests/positioning.rs @@ -332,3 +332,178 @@ fn each_pasted_rectangle_keeps_its_own_outline_width() { 38.0 ); } + +#[test] +fn selection_toggle_and_marquee_are_independent_of_geometry_history() { + let mut l = Layout::default(); + let original = *l.layers(); + l.toggle(0); + assert_eq!(l.selected_indices(), vec![0, 1]); + assert_eq!(l.selected(), None); + l.toggle(1); + assert_eq!(l.selected(), Some(0)); + l.toggle(0); + assert!(l.selected_indices().is_empty()); + l.select_region([1800.0, 600.0], [100.0, 100.0], [false; 2]); + assert_eq!(l.selected_indices(), vec![0, 1]); + l.select_region([100.0, 100.0], [125.0, 185.0], [false, true]); + assert_eq!(l.selected_indices(), vec![0, 1]); + assert_eq!(*l.layers(), original); + l.undo(); + assert_eq!(*l.layers(), original); +} +#[test] +fn selected_layers_drag_and_nudge_together_with_atomic_undo() { + let mut l = Layout::default(); + l.set_selection([true; 2]); + let before = *l.layers(); + l.start_drag([130.0, 190.0]); + l.drag_to([155.0, 200.0]); + l.finish_drag(); + for (i, g) in before.iter().enumerate() { + assert_eq!( + l.layers()[i], + Geometry { + x: g.x + 25.0, + y: g.y + 10.0, + ..*g + } + ); + } + l.undo(); + assert_eq!(*l.layers(), before); + l.redo(); + l.nudge(1.0, -10.0).unwrap(); + for (i, g) in before.iter().enumerate() { + assert_eq!( + l.layers()[i], + Geometry { + x: g.x + 26.0, + y: g.y, + ..*g + } + ); + } + l.undo(); + l.undo(); + assert_eq!(*l.layers(), before); + l.start_drag([130.0, 190.0]); + l.drag_to([150.0, 220.0]); + l.cancel_drag(); + assert_eq!(*l.layers(), before); +} +#[test] +fn align_edges_and_centers_to_explicit_targets_without_resizing() { + use midra_layout::{AlignTarget as T, Alignment as A}; + let initial = [ + Geometry { + x: 100.5, + y: 70.25, + width: 300.0, + height: 210.0, + }, + Geometry { + x: 700.25, + y: 350.5, + width: 100.0, + height: 80.0, + }, + ]; + for target in [T::Selection, T::Screen, T::Layer(0), T::Layer(1)] { + for alignment in [ + A::Left, + A::Right, + A::Top, + A::Bottom, + A::HorizontalCenter, + A::VerticalCenter, + ] { + let mut l = Layout::default(); + for (i, g) in initial.iter().enumerate() { + l.apply(i, *g).unwrap(); + } + l.set_selection([true; 2]); + let reference = match target { + T::Screen => Geometry { + x: 0.0, + y: 0.0, + width: 1920.0, + height: 1080.0, + }, + T::Selection => l.selection_bounds().unwrap(), + T::Layer(i) => initial[i], + }; + l.align(alignment, target).unwrap(); + for (i, g) in l.layers().iter().enumerate() { + assert_eq!([g.width, g.height], [initial[i].width, initial[i].height]); + let (actual, wanted) = match alignment { + A::Left => (g.x, reference.x), + A::Right => (g.x + g.width, reference.x + reference.width), + A::Top => (g.y, reference.y), + A::Bottom => (g.y + g.height, reference.y + reference.height), + A::HorizontalCenter => (g.center()[0], reference.center()[0]), + A::VerticalCenter => (g.center()[1], reference.center()[1]), + }; + assert!((actual - wanted).abs() < 1e-9); + if matches!(alignment, A::Left | A::Right | A::HorizontalCenter) { + assert_eq!(g.y, initial[i].y); + } else { + assert_eq!(g.x, initial[i].x); + } + } + if let T::Layer(i) = target { + assert_eq!(l.layers()[i], initial[i]); + } + let aligned = *l.layers(); + l.undo(); + assert_eq!(*l.layers(), initial); + l.redo(); + assert_eq!(*l.layers(), aligned); + } + } +} +#[test] +fn alignment_refuses_invalid_reference_and_failed_group_moves_are_atomic() { + use midra_layout::{AlignTarget as T, Alignment as A}; + let mut l = Layout::default(); + let before = *l.layers(); + assert!(l.align(A::Top, T::Layer(0)).is_err()); + assert_eq!(*l.layers(), before); + l.select(None); + assert!(l.align(A::Left, T::Screen).is_err()); + l.apply( + 1, + Geometry { + x: 1_000_000.0, + ..before[1] + }, + ) + .unwrap(); + l.set_selection([true; 2]); + let before = *l.layers(); + assert!(l.nudge(1.0, 0.0).is_err()); + assert_eq!(*l.layers(), before); + l.start_drag([130.0, 190.0]); + l.drag_to([140.0, 190.0]); + l.finish_drag(); + assert_eq!(*l.layers(), before); +} +#[test] +fn alignment_moves_only_selected_layers_and_is_order_independent() { + use midra_layout::{AlignTarget as T, Alignment as A}; + let mut l = Layout::default(); + let before = *l.layers(); + l.align(A::Left, T::Screen).unwrap(); + assert_eq!(l.layers()[0], before[0]); + assert_eq!(l.layers()[1].x, 0.0); + l.undo(); + l.select(Some(0)); + l.toggle(1); + l.align(A::Left, T::Selection).unwrap(); + let first = *l.layers(); + l.undo(); + l.select(Some(1)); + l.toggle(0); + l.align(A::Left, T::Selection).unwrap(); + assert_eq!(*l.layers(), first); +} diff --git a/docs/midra-layout-plan.md b/docs/midra-layout-plan.md index 53f5bff..0903fdd 100644 --- a/docs/midra-layout-plan.md +++ b/docs/midra-layout-plan.md @@ -1,10 +1,11 @@ # Midra layout helper: plan and visual proposals Status: the [Rust/egui positioning draft](midra-layout.md) supports draw.io -geometry paste with review, two-layer selection and movement, numeric corner -positioning/size, undo/redo and camera zoom/pan. Concept A is user-approved. +geometry paste with review, two-layer multi-selection and group movement, box +selection, explicit-target alignment, numeric corner positioning/size, undo/redo +and camera zoom/pan. Concept A is user-approved. Reference artwork remains illustrative; output is fixed to 1920 × 1080. -Custom resolution, source/input formats, image import, multi-selection alignment, +Custom resolution, source/input formats, image import, cropping, device connection and REST calls are not implemented. Checklist gates that combine implemented and outstanding work remain open. Target: Analog Way Eikos 4K, running the latest firmware according to the user. @@ -179,17 +180,20 @@ Gate: supported data places the selected rectangle correctly; malformed or ambiguous data makes no changes. Ship the basic format first if no external software format has yet been selected; do not claim that completes an adapter. -### 7. Later: explicit multi-layer alignment +### 7. Explicit multi-layer alignment -- [ ] Add Align top and Align left first; show the alignment target explicitly: +- [x] Add Align top and Align left; show the alignment target explicitly: screen, selection bounds or a named reference layer. -- [ ] For a reference layer, keep that layer fixed and move only the others. +- [x] For a reference layer, keep that layer fixed and move only the others. For selection bounds, align to the minimum top/left edge. For the screen, align to coordinate zero on the selected axis. -- [ ] Preserve sizes and the other axis, preview the affected selection, and +- [x] Preserve sizes and the other axis, preview the affected selection, and make each alignment a single undoable operation. -- [ ] Extend to right/bottom/center alignment and more layers only when needed, - within verified device capabilities. No distribution or constraint system yet. +- [x] Add right/bottom/center alignment using the same explicit targets. +- [x] Add Shift-click toggling in the viewport/list, left-drag box selection, + Shift-drag additive selection and Escape cancellation. Group movement/nudging + preserves spacing and uses one undo step per action. +- [ ] Extend beyond two layers under step 11. No distribution or constraint system yet. Gate: two differently sized layers align exactly against the chosen target, regardless of selection order except when explicitly choosing a reference layer. @@ -387,15 +391,15 @@ useful features can be incorporated into A without maintaining two different app ### C. Focus desk -A wider viewport and narrower contextual inspector. This proposal shows the -future multi-selection state: a named reference layer, explicit alignment actions +A wider viewport and narrower contextual inspector. This proposal illustrates the +multi-selection state: a named reference layer, explicit alignment actions and a compact per-layer coordinate table. The layer list remains on the right. ![Concept C: compact workspace with two selected layers](design/midra-layout/c-concept.svg) Best for repeated placement and comparison once the basic workflow is familiar. Less space for numeric explanations makes it weaker as the initial default. -The alignment state belongs to step 7; it does not imply a larger first release. +The alignment state is now available under step 7; the SVG remains a design concept. ### Shared interaction and responsive behavior diff --git a/docs/midra-layout.md b/docs/midra-layout.md index fd2a829..e24f5ab 100644 --- a/docs/midra-layout.md +++ b/docs/midra-layout.md @@ -66,28 +66,54 @@ clipboard testing against a running draw.io instance remains to be done. ## Move and edit layers -- Click a layer or its list entry to select it. In overlaps, the upper layer wins; - the list lets you reach the lower layer. Clicking empty canvas clears selection. -- Drag to move. Movement uses whole-screen-pixel deltas and preserves any fractional - starting position and dimensions. Selection handles currently indicate bounds; - resizing uses the numeric width/height fields. -- Arrow keys move by **1 px**; Shift-arrow moves by **10 px**. +- Click a layer or its list entry to select it alone. **Shift-click** toggles that + layer in the selection. In overlaps, the upper layer wins; the list lets you + reach the lower layer. Clicking empty canvas clears selection; Shift-clicking + empty canvas preserves it. +- **Left-drag on empty canvas** draws a selection box, selecting every rectangle + it intersects, in either drag direction. **Shift-drag** draws an additive box, + including when starting over a layer. Escape cancels the box and restores the + previous selection. +- 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. +- 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 **Apply position / size** or press Enter in a field. Resizing preserves that corner's offsets. Invalid values leave the document unchanged. - **Escape** cancels a drag or restores uncommitted numeric fields. In the paste - dialog it closes the preview without applying it. + dialog it closes the preview without applying it. Group drags cancel atomically. - **Undo/Redo** buttons or Ctrl/Cmd-Z, Ctrl/Cmd-Shift-Z (also Ctrl/Cmd-Y) reverse - edits. Each drag, applied paste or numeric edit is one step; retain 100 undo + edits. Each drag, alignment, applied paste or numeric edit is one step; retain 100 undo records. View changes and selection are not document edits. - Scroll over the viewport to zoom around the pointer. Space-drag or middle-drag - pans. **Fit screen** resets the view; **Fit layer** frames the selected layer. + pans. **Fit screen** resets the view; **Fit selected** frames the entire selection. Camera changes do not modify coordinates. Off-screen layers retain their exact coordinates, display a warning and remain selectable through the layer list. -- **Copy position values** copies labeled plain text with center position and +- **Copy position values** (or **Copy selected positions** for multiple layers) + copies labeled plain text with each selected layer's center position and dimensions. This is not a native WebRCS clipboard payload. +## Align selected layers + +Select both layers to reveal the alignment inspector. Choose an explicit target: + +- **Selection bounds** uses the selected rectangles' combined bounds at the time + of the action. Align left/top uses the minimum left/top; right/bottom uses the + maximum right/bottom. Selection order has no effect. +- **Screen** aligns to the screen edges or center lines. +- **Reference: Presenter / Slides** aligns to that selected layer's edges or + center lines. The named reference remains fixed. + +Use **Align left**, **Align right**, **Align top**, **Align bottom**, **Center X** +(horizontal centers) or **Center Y** (vertical centers). Each action changes only +the relevant position axis, never size, and is one undo step. The inspector lists +each layer's resulting center coordinates. Single-layer numeric fields are +replaced by alignment controls during multi-selection; no mixed values are shown +as if they belonged to one layer. Select exactly one layer to paste or resize. + Text inputs receive normal text paste and arrow navigation while focused; they never interpret these actions as geometry import or layer movement. Paste preview identifies its target explicitly and changes only that layer. @@ -96,7 +122,7 @@ identifies its target explicitly and changes only that layer. The screen is currently fixed to **1920 × 1080**, with two live rectangles. Reference artwork is illustrative, not a loaded image or live video. Source/input -formats, custom output resolution, image import, cropping, alignment and persistent +formats, custom output resolution, image import, cropping and persistent session files are future work. Sessions currently live only in memory. [Layer management and export scope](midra-layout-plan.md#11-later-stretch-goal-layer-management-and-export-scope) @@ -121,7 +147,9 @@ A graphical desktop session is required to launch. The Cargo workspace includes this crate in lint, tests, docs and coverage. Regression tests cover the supplied clipboard, malformed/unsupported input, -corner conversion, drag/undo, selection, and GUI paste/focus behavior. +corner conversion, group drag/undo, selection boxes, alignment targets, and GUI +paste/focus behavior. Layer-list scrolling uses the wheel or scrollbar so dragging +across list entries cannot accidentally scroll while selecting. See the [project plan](midra-layout-plan.md) and [resolution/cropping specification](midra-layout-resolutions.md) for future work.