//! Layer geometry, reversible edits and bounded imports. pub mod device; pub mod device_send; use std::collections::HashMap; pub mod formats; pub mod import; pub mod project; pub mod snapping; use formats::{Formats, Framing, Source}; /// Presentation only: retain full precision in the document. pub fn view_pixels(value: f64) -> String { let rounded = (value * 10.0).round() / 10.0; format!("{:.1}", if rounded == 0.0 { 0.0 } else { rounded }) } pub fn export_pixels(value: f64) -> String { let rounded = value.round(); format!("{:.0}", if rounded == 0.0 { 0.0 } else { rounded }) } #[derive(Clone, Copy, Debug, PartialEq)] pub enum ResizeHandle { Corner(Corner), Top, Bottom, Left, Right, } /// How a handle drag affects selected layers. #[derive(Clone, Copy, Debug, Default, PartialEq)] pub enum ResizeMode { #[default] Individual, Same, Mirror, Opposite, } impl ResizeHandle { pub fn mirrored_horizontally(self) -> Self { match self { Self::Left => Self::Right, Self::Right => Self::Left, Self::Top | Self::Bottom => self, Self::Corner(corner) => Self::Corner(match corner { Corner::TopLeft => Corner::TopRight, Corner::TopRight => Corner::TopLeft, Corner::BottomLeft => Corner::BottomRight, Corner::BottomRight => Corner::BottomLeft, }), } } 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(); [ (Self::Corner(Corner::TopLeft), [g.x, g.y]), (Self::Corner(Corner::TopRight), [g.x + g.width, g.y]), (Self::Corner(Corner::BottomLeft), [g.x, g.y + g.height]), ( Self::Corner(Corner::BottomRight), [g.x + g.width, g.y + g.height], ), (Self::Top, [cx, g.y]), (Self::Bottom, [cx, g.y + g.height]), (Self::Left, [g.x, cy]), (Self::Right, [g.x + g.width, cy]), ] } } fn resized_geometry( original: Geometry, handle: ResizeHandle, delta: [f64; 2], keep_ratio: bool, ) -> Geometry { resized_geometry_exact(original, handle, delta.map(f64::round), keep_ratio) } fn resized_geometry_exact( 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] * if left { -1.0 } else { 1.0 }; let dy = delta[1] * 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, serde::Serialize, serde::Deserialize)] #[serde(deny_unknown_fields)] pub struct Geometry { pub x: f64, pub y: f64, pub width: f64, pub height: f64, } impl Geometry { pub fn validate(self) -> Result { if [self.x, self.y, self.width, self.height] .iter() .any(|n| !n.is_finite() || n.abs() > 1_000_000.0) || self.width <= 0.0 || self.height <= 0.0 { return Err("Use finite coordinates within ±1,000,000 px and positive sizes up to 1,000,000 px.".into()); } Ok(self) } pub fn center(self) -> [f64; 2] { [self.x + self.width / 2.0, self.y + self.height / 2.0] } pub fn contains(self, p: [f64; 2]) -> bool { p[0] >= self.x && p[0] <= self.x + self.width && p[1] >= self.y && p[1] <= self.y + self.height } pub fn outside(self) -> bool { self.outside_on([1920, 1080]) } pub fn outside_on(self, output: [u32; 2]) -> bool { self.x < 0.0 || self.y < 0.0 || self.x + self.width > output[0] as f64 || self.y + self.height > output[1] as f64 } } #[derive(Clone, Copy, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)] #[serde(rename_all = "snake_case")] pub enum Corner { #[default] TopLeft, TopRight, BottomLeft, BottomRight, } impl Corner { pub fn offsets(self, g: Geometry) -> [f64; 2] { self.offsets_on(g, [1920, 1080]) } pub fn offsets_on(self, g: Geometry, output: [u32; 2]) -> [f64; 2] { [ if matches!(self, Self::TopRight | Self::BottomRight) { output[0] as f64 - g.x - g.width } else { g.x }, if matches!(self, Self::BottomLeft | Self::BottomRight) { output[1] as f64 - g.y - g.height } else { g.y }, ] } pub fn geometry(self, dx: f64, dy: f64, width: f64, height: f64) -> Result { self.geometry_on(dx, dy, width, height, [1920, 1080]) } pub fn geometry_on( self, dx: f64, dy: f64, width: f64, height: f64, output: [u32; 2], ) -> Result { Geometry { x: if matches!(self, Self::TopRight | Self::BottomRight) { output[0] as f64 - dx - width } else { dx }, y: if matches!(self, Self::BottomLeft | Self::BottomRight) { output[1] as f64 - dy - height } else { dy }, width, height, } .validate() } } /// 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), } /// Persistent identity independent of list order or device layer numbering. #[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)] #[serde(deny_unknown_fields)] pub struct LayerInfo { pub id: usize, pub name: String, pub folder: String, } /// Multi-layer document with one undo record per complete gesture/edit. #[derive(Clone)] pub struct Layout { info: Vec, next_id: usize, layers: Vec, selected: Vec, locked: Vec, visible: Vec, formats: Formats, undo: Vec, redo: Vec, drag: Option<(Vec, Snapshot, [f64; 2])>, content_drag: Option<(usize, Snapshot, [f64; 2])>, content_resize: Option, pub gesture_error: Option, resize: Option, } #[derive(Clone)] struct Resize { mode: ResizeMode, targets: Vec, index: usize, handle: ResizeHandle, before: Snapshot, start: [f64; 2], keep_ratio: bool, } #[derive(Clone, PartialEq)] struct Snapshot { info: Vec, selected: Vec, locked: Vec, visible: Vec, layers: Vec, formats: Formats, } impl Default for Layout { fn default() -> Self { Self { info: vec![ LayerInfo { id: 1, name: "Presenter".into(), folder: String::new(), }, LayerInfo { id: 2, name: "Slides".into(), folder: String::new(), }, ], next_id: 3, layers: vec![ Geometry { x: 120.0, y: 180.0, width: 640.0, height: 360.0, }, Geometry { x: 1160.0, y: 180.0, width: 640.0, height: 360.0, }, ], selected: vec![false, true], locked: vec![false; 2], visible: vec![true; 2], formats: Formats::default(), content_drag: None, content_resize: None, gesture_error: None, undo: Vec::new(), redo: Vec::new(), drag: None, resize: None, } } } impl Layout { fn snapshot(&self) -> Snapshot { Snapshot { info: self.info.clone(), selected: self.selected.clone(), locked: self.locked.clone(), visible: self.visible.clone(), layers: self.layers.clone(), formats: self.formats.clone(), } } fn restore(&mut self, s: Snapshot) { self.gesture_error = None; // Selection remains independent of history for surviving IDs. let mut selected = s.selected; let locked = s.locked; let visible = s.visible; for (i, info) in s.info.iter().enumerate() { if let Some(j) = self.info.iter().position(|old| old.id == info.id) { selected[i] = self.selected[j]; selected[i] &= visible[i] && !locked[i]; } } self.selected = selected; self.locked = locked; self.visible = visible; self.info = s.info; self.layers = s.layers; self.formats = s.formats; } pub fn layer_info(&self, i: usize) -> &LayerInfo { &self.info[i] } pub fn layer_label(&self, i: usize) -> String { format!("{:02} / {}", self.info[i].id, self.info[i].name) } pub fn rename_layer(&mut self, i: usize, name: &str, folder: &str) -> Result<(), String> { if i >= self.layers.len() || name.trim().is_empty() || name.chars().count() > 128 || folder.chars().count() > 128 { return Err( "Use a layer name of 1–128 characters and a folder of at most 128 characters." .into(), ); } self.finish_drag(); let before = self.snapshot(); self.info[i].name = name.trim().into(); self.info[i].folder = folder.trim().into(); self.remember(before); Ok(()) } pub fn rename_layers(&mut self, edits: &[(usize, String, String)]) -> Result<(), String> { if edits.len() != self.layers.len() || edits.iter().enumerate().any(|(i, (id, name, folder))| { *id != self.info[i].id || name.trim().is_empty() || name.chars().count() > 128 || folder.chars().count() > 128 }) { return Err("Layer list changed or names are invalid; use 1–128 characters.".into()); } self.finish_drag(); let before = self.snapshot(); for (info, (_, name, folder)) in self.info.iter_mut().zip(edits) { info.name = name.trim().into(); info.folder = folder.trim().into(); } self.remember(before); Ok(()) } pub fn add_layer(&mut self) -> Result { if self.layers.len() >= 256 || self.formats.sources.len() >= 1024 || self.next_id == usize::MAX { return Err("Layer/source capacity reached.".into()); } self.finish_drag(); let before = self.snapshot(); let i = self.layers.len(); let g = Geometry { x: 0.0, y: 0.0, width: 640.0, height: 360.0, }; self.layers.push(g); self.info.push(LayerInfo { id: self.next_id, name: format!("Layer {}", self.next_id), folder: String::new(), }); self.next_id += 1; self.selected.push(false); self.locked.push(false); self.visible.push(true); self.formats.source_for.push(self.formats.sources.len()); self.formats.sources.push(Source::default()); self.formats.advanced.push(formats::Crop::default()); self.select(Some(i)); self.remember(before); Ok(i) } pub fn remove_selected(&mut self) -> Result<(), String> { let indices = self.selected_indices(); if indices.is_empty() || indices.len() == self.layers.len() { return Err("Select layers to remove, leaving at least one layer.".into()); } self.finish_drag(); let before = self.snapshot(); for i in indices.into_iter().rev() { self.layers.remove(i); self.info.remove(i); self.selected.remove(i); self.locked.remove(i); self.visible.remove(i); self.formats.source_for.remove(i); self.formats.advanced.remove(i); } self.remember(before); Ok(()) } pub fn formats(&self) -> &Formats { &self.formats } pub fn set_output(&mut self, output: [u32; 2]) -> Result<(), String> { formats::validate_resolution(output)?; self.finish_drag(); let before = self.snapshot(); self.formats.output = output; self.remember(before); Ok(()) } pub fn set_framing(&mut self, i: usize, framing: Framing) -> Result<(), String> { if !self.selectable(i) { return Err("Unlock and show this layer first.".into()); } let crop = formats::crop_from_framing( self.formats.input(i)?, [self.layers[i].width, self.layers[i].height], framing, )?; self.finish_drag(); let before = self.snapshot(); self.formats.advanced[i] = crop; self.remember(before); Ok(()) } pub fn start_content_drag(&mut self, i: usize, point: [f64; 2]) { self.finish_drag(); if self.selectable(i) && self.selected() == Some(i) { self.content_drag = Some((i, self.snapshot(), point)); } } /// Zoom content from a corner or side, fixing the opposite anchor and visible layer box. pub fn start_content_resize(&mut self, index: usize, handle: ResizeHandle, point: [f64; 2]) { self.finish_drag(); if !self.selectable(index) || self.selected() != Some(index) || point.iter().any(|v| !v.is_finite()) { return; } self.content_resize = Some(Resize { mode: ResizeMode::Individual, targets: self.selected.clone(), index, handle, before: self.snapshot(), start: point, keep_ratio: true, }); } /// Atomic shared-source edit plus visible-box resizing. Explicit acceptance is required for any center adjustment. pub fn configure( &mut self, i: usize, source_id: usize, source: Source, geometry: Geometry, allow_adjustment: bool, ) -> Result { if !self.selectable(i) || source_id >= self.formats.sources.len() { return Err("Select an editable layer and existing source.".into()); } source.input()?; geometry.validate()?; self.finish_drag(); let before = self.snapshot(); let mut next = before.clone(); next.formats.source_for[i] = source_id; next.formats.sources[source_id] = source; next.layers[i] = geometry; let mut adjustments = Vec::new(); for j in 0..self.layers.len() { let affected = j == i || (next.formats.source_for[j] == source_id && source != before.formats.sources[source_id]); if !affected { continue; } if self.locked(j) { return Err(format!( "Source edit also affects locked layer {}. Unlock it first.", j + 1 )); } let (crop, adjusted) = formats::reframed( before.formats.input(j)?, [before.layers[j].width, before.layers[j].height], before.formats.advanced[j], next.formats.input(j)?, [next.layers[j].width, next.layers[j].height], )?; next.formats.advanced[j] = crop; if adjusted { let m = next.formats.mapping(j, next.layers[j])?; adjustments.push(format!( "Layer {}: content offsets adjusted to {:.1}, {:.1} px", j + 1, m.framing.offset[0], m.framing.offset[1] )); } } let message = adjustments.join("; "); if !allow_adjustment && !adjustments.is_empty() { return Err(format!("Review required: {message}")); } self.restore(next); self.remember(before); Ok(message) } /// Provisional geometry report; deliberately not a verified WebRCS command recipe. pub fn calculation_report(&self, i: usize) -> Result { self.formatted_report(i, false) } pub fn calculation_export(&self, i: usize) -> Result { self.formatted_report(i, true) } fn formatted_report(&self, i: usize, export: bool) -> Result { let p = if export { export_pixels } else { view_pixels }; let f = &self.formats; let g = self.layers[i]; let source = f.sources[f.source_for[i]]; let input = source.input()?; let m = f.mapping(i, g)?; let a = f.advanced[i]; let c = source.input_crop; let projected = Geometry { x: g.x - m.scale * a.left, y: g.y - m.scale * a.top, width: m.scale * input[0], height: m.scale * input[1], }; Ok(format!( "PROVISIONAL GEOMETRY — not a verified device recipe\nSource {} / {} / {} x {}\nInput crop L/R/T/B (native px): {} / {} / {} / {}\nInput resolution: {} x {}\nLayer resolution: {} x {}; visible center: {}, {}\nAdvanced crop L/R/T/B (usable-input px): {} / {} / {} / {}\nCombined native retained region: x {}, y {}, w {}, h {}\nContent zoom: {}%; offsets (output px): {}, {}\nProjected full usable input: {} x {}; center {}, {}\nIntended aspect mode: Centered. Device container, crop units and quantization remain unverified.", f.source_for[i] + 1, source.aspect.label(), source.native[0], source.native[1], p(c.left), p(c.right), p(c.top), p(c.bottom), p(input[0]), p(input[1]), p(g.width), p(g.height), p(g.center()[0]), p(g.center()[1]), p(a.left), p(a.right), p(a.top), p(a.bottom), p(c.left + a.left), p(c.top + a.top), p(m.retained[0]), p(m.retained[1]), view_pixels(m.framing.zoom * 100.0), p(m.framing.offset[0]), p(m.framing.offset[1]), p(projected.width), p(projected.height), p(projected.center()[0]), p(projected.center()[1]) )) } pub fn layers(&self) -> &Vec { &self.layers } pub fn locked(&self, index: usize) -> bool { self.locked.get(index).copied().unwrap_or(false) } pub fn visible(&self, index: usize) -> bool { self.visible.get(index).copied().unwrap_or(false) } fn selectable(&self, index: usize) -> bool { self.visible(index) && !self.locked(index) } /// Protection flags are local, undoable edits; cancel any active gesture first. pub fn set_locked(&mut self, index: usize, locked: bool) { self.cancel_drag(); let before = self.snapshot(); if let Some(value) = self.locked.get_mut(index) { *value = locked; if locked { self.selected[index] = false; } } self.remember(before); } pub fn set_visible(&mut self, index: usize, visible: bool) { self.cancel_drag(); let before = self.snapshot(); if let Some(value) = self.visible.get_mut(index) { *value = visible; if !visible { self.selected[index] = false; } } self.remember(before); } /// 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..self.layers.len()) .filter(|i| self.selected[*i]) .collect() } pub fn selection_mask(&self) -> Vec { self.selected.clone() } pub fn set_selection(&mut self, selected: impl AsRef<[bool]>) { self.finish_drag(); self.selected = (0..self.layers.len()) .map(|i| selected.as_ref().get(i).copied().unwrap_or(false) && self.selectable(i)) .collect(); } pub fn select(&mut self, index: Option) { self.set_selection( (0..self.layers.len()) .map(|i| index == Some(i)) .collect::>(), ); } pub fn toggle(&mut self, index: usize) { self.finish_drag(); if !self.selectable(index) { return; } 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: impl AsRef<[bool]>) { 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( (0..self.layers.len()) .map(|i| { let g = self.layers[i]; base.as_ref().get(i).copied().unwrap_or(false) || (g.x <= right && g.x + g.width >= left && g.y <= bottom && g.y + g.height >= top) }) .collect::>(), ); } 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.align_axes(&[alignment], target) } /// Align one or both axes against one reference, with one undo record. pub fn align_axes( &mut self, alignments: &[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: self.formats.output[0] as f64, height: self.formats.output[1] as f64, }, AlignTarget::Layer(i) => *self.layers.get(i).ok_or("Unknown reference layer.")?, }; let mut next = self.layers.clone(); for i in self.selected_indices() { if target == AlignTarget::Layer(i) { continue; } let g = &mut next[i]; for alignment in alignments { 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: Vec) -> Result<(), String> { for g in &next { g.validate()?; } let before = self.snapshot(); let mut formats = self.formats.clone(); for (i, geometry) in next.iter().enumerate() { formats.resize(i, self.layers[i], *geometry)?; } self.layers = next; self.formats = formats; self.remember(before); Ok(()) } /// Viewport back-to-front order; selected layers are drawn last. /// Layer identities and export order remain unchanged. pub fn viewport_order(&self) -> Vec { let mut order: Vec<_> = (0..self.layers.len()).collect(); order.sort_by_key(|i| self.selected[*i]); order } pub fn hit(&self, point: [f64; 2]) -> Option { self.viewport_order() .into_iter() .rev() .find(|i| self.selectable(*i) && self.layers[*i].contains(point)) } fn remember(&mut self, before: Snapshot) { if before != self.snapshot() { if self.undo.len() == 100 { self.undo.remove(0); } self.undo.push(before); self.redo.clear(); } } pub fn apply(&mut self, index: usize, geometry: Geometry) -> Result<(), String> { let geometry = geometry.validate()?; if index >= self.layers.len() { return Err("Select an existing layer.".into()); } if !self.selectable(index) { return Err("Unlock and show the layer before editing it.".into()); } self.finish_drag(); let mut next = self.layers.clone(); next[index] = geometry; self.commit(next) } /// Apply a one-to-one import to a subset of the selection, with one undo record. pub fn apply_import(&mut self, values: &[(usize, Geometry)]) -> Result<(), String> { let targets = self.selected_indices(); if values.is_empty() || values.len() > targets.len() { return Err(format!( "Layer count mismatch: {} selected, {} imported. Map each imported rectangle to a different selected destination.", targets.len(), values.len() )); } let mut seen = Vec::new(); let mut next = self.layers.clone(); for (i, g) in values { if !targets.contains(i) || seen.contains(i) || !self.selectable(*i) { return Err("Map each imported rectangle to a different selected layer; duplicate or unselected targets are not allowed.".into()); } g.validate()?; seen.push(*i); next[*i] = *g; } self.finish_drag(); self.commit(next) } /// Import optional per-layer source/crop data without changing shared sources. pub fn import_device_layers(&mut self, values: &[DeviceLayerImport]) -> Result<(), String> { let mut draft = self.clone(); draft.import_mapped_layers( &values .iter() .map(|(id, g, _)| (*id, *g)) .collect::>(), )?; let mut next_new = self.layers.len(); for (id, geometry, framing) in values { let i = if let Some(id) = id { draft.info.iter().position(|info| info.id == *id).unwrap() } else { let i = next_new; next_new += 1; i }; if let Some((source, crop)) = framing { formats::mapping(source.input()?, [geometry.width, geometry.height], *crop)?; let current_source = draft.formats.source_for[i]; let source_id = if draft .formats .source_for .iter() .filter(|&&source| source == current_source) .count() == 1 { current_source } else { if draft.formats.sources.len() >= 1024 { return Err("Source capacity reached.".into()); } draft.formats.sources.push(*source); draft.formats.sources.len() - 1 }; draft.formats.sources[source_id] = *source; draft.formats.source_for[i] = source_id; draft.formats.advanced[i] = *crop; } } self.finish_drag(); let before = self.snapshot(); self.restore(draft.snapshot()); self.next_id = draft.next_id; self.remember(before); Ok(()) } /// Import device containers into stable layer IDs, or new layers (`None`). /// Independent of selection; the complete mapping is one atomic undo step. pub fn import_mapped_layers( &mut self, values: &[(Option, Geometry)], ) -> Result<(), String> { if values.is_empty() { return Err("Choose at least one destination layer.".into()); } let mut draft = self.clone(); let mut seen = Vec::new(); for &(id, geometry) in values { geometry.validate()?; let index = if let Some(id) = id { if seen.contains(&id) { return Err("Choose a different destination for each device layer.".into()); } seen.push(id); let index = self .info .iter() .position(|info| info.id == id) .ok_or("A destination layer was removed. Choose its replacement.")?; if !draft.selectable(index) { return Err("Destination layers must be visible and unlocked.".into()); } index } else { draft.add_layer()? }; draft.apply(index, geometry)?; } self.finish_drag(); let before = self.snapshot(); self.restore(draft.snapshot()); self.next_id = draft.next_id; self.remember(before); Ok(()) } /// Apply explicit destination indices without changing the viewport selection. /// Mappings must be unique, visible and unlocked; failures are atomic. pub fn apply_mapped_import_with_zoom( &mut self, values: &[(usize, Geometry)], zooms: &[(usize, f64)], ) -> Result<(), String> { if values.iter().any(|(i, _)| !self.selectable(*i)) { return Err("Choose visible, unlocked destination layers.".into()); } let mut draft = self.clone(); let selection: Vec<_> = (0..self.layers.len()) .map(|i| values.iter().any(|(target, _)| *target == i)) .collect(); draft.set_selection(selection); draft.apply_import_with_zoom(values, zooms)?; self.finish_drag(); let before = self.snapshot(); self.restore(draft.snapshot()); self.remember(before); Ok(()) } /// Import geometry and optional crop zoom together as one atomic edit. pub fn apply_import_with_zoom( &mut self, values: &[(usize, Geometry)], zooms: &[(usize, f64)], ) -> Result<(), String> { let mut draft = self.clone(); draft.apply_import(values)?; let mut seen = Vec::new(); for &(i, zoom) in zooms { if !values.iter().any(|(target, _)| *target == i) || seen.contains(&i) { return Err("Each zoom must map to one imported layer, without duplicates.".into()); } seen.push(i); let g = draft.layers[i]; let mut framing = draft.formats.mapping(i, g)?.framing; let (_, limits) = formats::limits(draft.formats.input(i)?, [g.width, g.height], zoom)?; framing.zoom = zoom; for (offset, limit) in framing.offset.iter_mut().zip(limits) { *offset = offset.clamp(-limit, limit); } draft.set_framing(i, framing)?; } self.finish_drag(); let before = self.snapshot(); self.restore(draft.snapshot()); self.remember(before); Ok(()) } pub fn nudge(&mut self, dx: f64, dy: f64) -> Result<(), String> { self.finish_drag(); let mut next = self.layers.clone(); for i in self.selected_indices() { next[i].x += dx; next[i].y += dy; } self.commit(next) } pub fn start_drag(&mut self, point: [f64; 2]) { self.finish_drag(); if let Some(i) = self.hit(point) { if !self.selected[i] { self.select(Some(i)); } self.drag = Some((self.selected.clone(), self.snapshot(), point)); } else { self.select(None); } } /// Resize one selected layer, keeping its opposite corner fixed. pub fn start_resize( &mut self, index: usize, corner: Corner, point: [f64; 2], keep_ratio: bool, ) { self.start_handle_resize(index, ResizeHandle::Corner(corner), point, keep_ratio); } pub fn start_handle_resize( &mut self, index: usize, handle: ResizeHandle, point: [f64; 2], keep_ratio: bool, ) { self.finish_drag(); if !self.selectable(index) || !self.selected[index] { return; } self.select(Some(index)); self.resize = Some(Resize { mode: ResizeMode::Individual, targets: self.selected.clone(), index, handle, before: self.snapshot(), start: point, 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 || (matches!(mode, ResizeMode::Mirror | ResizeMode::Opposite) && count != 2) { return Err( "Select at least two layers for Same handles, or exactly two for Mirror horizontally / Opposite handles." .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.clone(), index, handle, before: self.snapshot(), start: point, keep_ratio, }); Ok(()) } pub fn drag_to(&mut self, point: [f64; 2]) { self.drag_to_with_precision(point, false); } fn drag_to_with_precision(&mut self, point: [f64; 2], exact: bool) { if point.iter().any(|v| !v.is_finite()) { return; } if let Some(r) = &self.content_resize { let result = (|| { let i = r.index; let g = r.before.layers[i]; let input = r.before.formats.input(i)?; let m = r.before.formats.mapping(i, g)?; let crop = r.before.formats.advanced[i]; let full = Geometry { x: g.x - crop.left * m.scale, y: g.y - crop.top * m.scale, width: input[0] * m.scale, height: input[1] * m.scale, }; let desired = resized_geometry( full, r.handle, [point[0] - r.start[0], point[1] - r.start[1]], true, ); let zoom = (m.framing.zoom * desired.width / full.width).clamp(1.0, 100.0); let (scale, limits) = formats::limits(input, [g.width, g.height], zoom)?; let resized = anchored_resize(full, r.handle, input[0] * scale, input[1] * scale); let center = resized.center(); let layer_center = g.center(); let offset = std::array::from_fn(|axis| { (center[axis] - layer_center[axis]).clamp(-limits[axis], limits[axis]) }); formats::crop_from_framing(input, [g.width, g.height], Framing { zoom, offset }) })(); match result { Ok(crop) => { self.formats.advanced[r.index] = crop; self.gesture_error = None; } Err(e) => self.gesture_error = Some(e), } return; } if let Some((i, before, start)) = self.content_drag.clone() { if let Ok(m) = before.formats.mapping(i, before.layers[i]) { let offset = std::array::from_fn(|axis| { (m.framing.offset[axis] + point[axis] - start[axis]) .clamp(-m.offset_limits[axis], m.offset_limits[axis]) }); if let Ok(crop) = formats::crop_from_framing( before.formats.input(i).unwrap(), [before.layers[i].width, before.layers[i].height], Framing { zoom: m.framing.zoom, offset, }, ) { self.formats.advanced[i] = crop; } } return; } if let Some(r) = &self.resize { let original = r.before.layers[r.index]; let resize = if exact { resized_geometry_exact } else { resized_geometry }; let next = 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(); 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; } } for (i, geometry) in layers.iter_mut().enumerate() { if !r.targets[i] { continue; } let before = *geometry; let handle = if i != r.index { match r.mode { ResizeMode::Mirror => r.handle.mirrored_horizontally(), ResizeMode::Opposite => r.handle.opposite(), ResizeMode::Individual | ResizeMode::Same => r.handle, } } 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; } Err(e) => self.gesture_error = Some(e), } return; } if let Some((selected, before, start)) = self.drag.clone() { let mut next = before.layers; for i in 0..self.layers.len() { 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; } } } pub fn resizing(&self) -> bool { self.resize.is_some() } pub fn dragging(&self) -> bool { self.drag.is_some() || self.resize.is_some() || self.content_drag.is_some() || self.content_resize.is_some() } pub fn finish_drag(&mut self) { if let Some(r) = self.content_resize.take() { self.remember(r.before); } if let Some((_, before, _)) = self.content_drag.take() { self.remember(before); } if let Some(r) = self.resize.take() { self.remember(r.before); } if let Some((_, before, _)) = self.drag.take() { self.remember(before); } } pub fn cancel_drag(&mut self) { if let Some(r) = self.content_resize.take() { self.restore(r.before); } self.gesture_error = None; if let Some((_, before, _)) = self.content_drag.take() { self.restore(before); } if let Some(r) = self.resize.take() { self.restore(r.before); } if let Some((_, before, _)) = self.drag.take() { self.restore(before); } } pub fn undo(&mut self) { self.finish_drag(); if let Some(before) = self.undo.pop() { self.redo.push(self.snapshot()); self.restore(before); } } pub fn redo(&mut self) { self.finish_drag(); if let Some(after) = self.redo.pop() { self.undo.push(self.snapshot()); self.restore(after); } } } #[derive(Clone, Debug)] pub struct DrawioShape { pub id: String, pub geometry: Geometry, /// Effective visible outline thickness, in diagram pixels (default 1). pub stroke_width: f64, } impl DrawioShape { /// Outline expansion applies only when importing size; position-only keeps /// the original draw.io top-left and the destination layer dimensions. pub fn paste_geometry( &self, before: Geometry, include_size: bool, include_outline: bool, ) -> Result { let mut g = self.geometry; if !include_size { g.width = before.width; g.height = before.height; } else if include_outline { g.x -= self.stroke_width / 2.0; g.y -= self.stroke_width / 2.0; g.width += self.stroke_width; g.height += self.stroke_width; } g.validate() } } /// Read raw or once-percent-encoded mxGraphModel XML. Values map 1:1 to pixels. /// Nested, relative, rotated and nonrectangular geometry is intentionally refused. pub fn parse_drawio(input: &str) -> Result, String> { if input.len() > 1_048_576 { return Err("Clipboard text exceeds 1 MiB.".into()); } let input = input.trim(); let decoded; let xml = if input.starts_with('<') { input } else { decoded = decode_percent(input)?; decoded.trim() }; let doc = roxmltree::Document::parse(xml).map_err(|e| format!("Invalid draw.io XML: {e}"))?; let model = doc.root_element(); if !model.has_tag_name("mxGraphModel") { return Err("Paste draw.io mxGraphModel XML, not a compressed file or an image.".into()); } let root = model .children() .find(|n| n.has_tag_name("root")) .ok_or("draw.io root is missing.")?; let mut cells = HashMap::new(); for n in root.children().filter(|n| n.is_element()) { if !n.has_tag_name("mxCell") { return Err("Wrapped objects are not supported yet. Copy plain rectangles.".into()); } let id = n.attribute("id").ok_or("A cell has no ID.")?; if cells.insert(id, n).is_some() { return Err("Duplicate draw.io cell ID.".into()); } } let mut result = Vec::new(); for cell in root.children().filter(|n| n.has_tag_name("mxCell")) { if cell.attribute("edge") == Some("1") { return Err("Connections are not supported. Copy rectangles only.".into()); } if cell.attribute("vertex") != Some("1") { continue; } let id = cell.attribute("id").unwrap(); let parent = cell .attribute("parent") .and_then(|p| cells.get(p)) .ok_or("Missing parent; grouped/partial geometry is unsupported.")?; let is_layer = parent.attribute("vertex").is_none() && parent .attribute("parent") .and_then(|p| cells.get(p)) .is_some_and(|p| { p.attribute("parent").is_none() && p.attribute("vertex").is_none() }); if !is_layer { return Err( "Grouped or nested rectangles are not supported yet. Ungroup before copying." .into(), ); } let mut styles = HashMap::new(); for entry in cell .attribute("style") .unwrap_or("") .split(';') .filter(|s| !s.is_empty()) { let (key, value) = entry .split_once('=') .ok_or("Named/inherited draw.io styles are unsupported.")?; styles.insert(key, value); if (key == "shape" && value != "rectangle") || (matches!(key, "rotation" | "flipH" | "flipV") && value != "0") { return Err("Only unrotated rectangles are supported; remove shape transforms before copying.".into()); } } let style_number = |key, default: f64, max: f64| -> Result { let value = styles.get(key).map_or(Ok(default), |s| { s.parse::().map_err(|_| format!("Invalid {key}.")) })?; if !value.is_finite() || !(0.0..=max).contains(&value) { return Err(format!("Invalid {key}: expected 0–{max}.")); } Ok(value) }; let width = style_number("strokeWidth", 1.0, 1_000_000.0)?; let stroke_opacity = style_number("strokeOpacity", 100.0, 100.0)?; let opacity = style_number("opacity", 100.0, 100.0)?; let hidden = styles .get("strokeColor") .is_some_and(|c| matches!(*c, "none" | "transparent")) || stroke_opacity == 0.0 || opacity == 0.0; let stroke_width = if hidden { 0.0 } else { width }; let geometries: Vec<_> = cell.children().filter(|n| n.is_element()).collect(); if geometries.len() != 1 || !geometries[0].has_tag_name("mxGeometry") { return Err("Expected one plain geometry per rectangle.".into()); } let g = geometries[0]; if g.attribute("relative").is_some_and(|v| v != "0") || g.children().any(|n| n.is_element()) { return Err("Relative, offset or alternate bounds are not supported yet.".into()); } let number = |name, default| -> Result { g.attribute(name) .or(default) .ok_or_else(|| format!("Missing {name}."))? .parse() .map_err(|_| format!("Invalid {name}.")) }; let geometry = Geometry { x: number("x", Some("0"))?, y: number("y", Some("0"))?, width: number("width", None)?, height: number("height", None)?, } .validate()?; result.push(DrawioShape { id: id.to_owned(), geometry, stroke_width, }); } if result.is_empty() { return Err("No rectangles found in the draw.io clipboard.".into()); } Ok(result) } fn decode_percent(input: &str) -> Result { let mut out = Vec::with_capacity(input.len()); let mut bytes = input.bytes(); while let Some(b) = bytes.next() { if b == b'%' { let hex = |c: u8| (c as char).to_digit(16).map(|v| v as u8); let a = bytes .next() .and_then(hex) .ok_or("Invalid percent escape in clipboard.")?; let b = bytes .next() .and_then(hex) .ok_or("Invalid percent escape in clipboard.")?; out.push(a * 16 + b); } else { out.push(b); } // '+' is literal in encodeURIComponent, not a space. } String::from_utf8(out).map_err(|_| "Clipboard is not valid UTF-8.".into()) } /// A device import destination, visible geometry and optional source/crop pair. pub type DeviceLayerImport = ( Option, Geometry, Option<(formats::Source, formats::Crop)>, );