diff --git a/crates/midra-layout/src/folders.rs b/crates/midra-layout/src/folders.rs new file mode 100644 index 0000000..6a45123 --- /dev/null +++ b/crates/midra-layout/src/folders.rs @@ -0,0 +1,167 @@ +//! Local layer folders, with atomic history for operations on their members. +use crate::Layout; + +impl Layout { + /// Folder names in front-to-back display order. Empty means the document root. + pub fn folders(&self) -> Vec { + let mut folders = Vec::new(); + for info in self.info.iter().rev() { + if !info.folder.is_empty() && !folders.contains(&info.folder) { + folders.push(info.folder.clone()); + } + } + folders + } + + pub fn folder_members(&self, folder: &str) -> Vec { + self.info + .iter() + .enumerate() + .filter_map(|(i, info)| (info.folder == folder).then_some(i)) + .collect() + } + + /// Assign stable IDs to a folder (or root), preserving their geometry and links. + pub fn assign_folder(&mut self, ids: &[usize], folder: &str) -> Result<(), String> { + if folder.chars().count() > 128 + || ids.is_empty() + || ids + .iter() + .any(|id| !self.info.iter().any(|info| info.id == *id)) + { + return Err( + "Choose existing layers and a folder name of at most 128 characters.".into(), + ); + } + self.finish_drag(); + let before = self.snapshot(); + for info in &mut self.info { + if ids.contains(&info.id) { + info.folder = folder.trim().into(); + } + } + self.remember(before); + Ok(()) + } + + pub fn rename_folder(&mut self, folder: &str, name: &str) -> Result<(), String> { + if folder.is_empty() + || name.trim().is_empty() + || (folder != name.trim() && self.info.iter().any(|info| info.folder == name.trim())) + { + return Err("Use a nonempty, unique folder name.".into()); + } + let ids = self + .folder_members(folder) + .iter() + .map(|&i| self.info[i].id) + .collect::>(); + self.assign_folder(&ids, name) + } + + pub fn select_folder(&mut self, folder: &str, toggle: bool) { + let members = self.folder_members(folder); + let all = members + .iter() + .filter(|&&i| self.selectable(i)) + .all(|&i| self.selected[i]); + self.set_selection( + (0..self.layers.len()) + .map(|i| { + if members.contains(&i) { + !toggle || !all + } else { + toggle && self.selected[i] + } + }) + .collect::>(), + ); + } + + /// Mixed groups become fully visible/unlocked when the caller requests it. + pub fn set_folder_state(&mut self, folder: &str, visible: Option, locked: Option) { + self.cancel_drag(); + let before = self.snapshot(); + for i in self.folder_members(folder) { + if let Some(value) = visible { + self.visible[i] = value; + } + if let Some(value) = locked { + self.locked[i] = value; + } + self.selected[i] &= self.visible[i] && !self.locked[i]; + } + self.remember(before); + } + + fn order_layers(&mut self, order: &[usize]) { + let before = self.snapshot(); + self.info = order.iter().map(|&i| before.info[i].clone()).collect(); + self.layers = order.iter().map(|&i| before.layers[i]).collect(); + self.selected = order.iter().map(|&i| before.selected[i]).collect(); + self.visible = order.iter().map(|&i| before.visible[i]).collect(); + self.locked = order.iter().map(|&i| before.locked[i]).collect(); + self.formats.source_for = order + .iter() + .map(|&i| before.formats.source_for[i]) + .collect(); + self.formats.advanced = order.iter().map(|&i| before.formats.advanced[i]).collect(); + } + + /// Move a folder as one stacking block, keeping member order and identities. + pub fn move_folder( + &mut self, + folder: &str, + target_id: usize, + above: bool, + ) -> Result<(), String> { + let target = self + .info + .iter() + .position(|info| info.id == target_id) + .ok_or("Target layer no longer exists.")?; + let members = self.folder_members(folder); + if folder.is_empty() || members.is_empty() { + return Err("Folder no longer exists.".into()); + } + if members.contains(&target) { + return Ok(()); + } + self.finish_drag(); + let before = self.snapshot(); + let mut order = (0..self.layers.len()) + .filter(|i| !members.contains(i)) + .collect::>(); + let slot = order.iter().position(|&i| i == target).unwrap() + usize::from(above); + order.splice(slot..slot, members); + self.order_layers(&order); + self.remember(before); + Ok(()) + } + + /// A row drop changes membership and stacking in one undoable operation. + pub fn move_layer_to_folder( + &mut self, + id: usize, + folder: &str, + to: usize, + ) -> Result<(), String> { + let from = self + .info + .iter() + .position(|info| info.id == id) + .ok_or("Layer no longer exists.")?; + if folder.chars().count() > 128 || to >= self.layers.len() { + return Err("Invalid folder or layer position.".into()); + } + self.finish_drag(); + let before = self.snapshot(); + self.info[from].folder = folder.trim().into(); + let mut order = (0..self.layers.len()).collect::>(); + order.remove(from); + order.insert(to, from); + self.order_layers(&order); + self.remember(before); + Ok(()) + } +} diff --git a/crates/midra-layout/src/gui.rs b/crates/midra-layout/src/gui.rs index f5c296f..250d88d 100644 --- a/crates/midra-layout/src/gui.rs +++ b/crates/midra-layout/src/gui.rs @@ -1002,6 +1002,8 @@ impl Editor { } } fn inspector(&mut self, ui: &mut egui::Ui) { + let rows = self.layer_tree_rows(); + let row_count = rows.len(); let palette = theme::palette(ui.ctx()); let (r, _) = ui.allocate_exact_size( Vec2::new( @@ -1012,20 +1014,13 @@ impl Editor { } else { 28.0 } - + (self.layout.layers().len() as f32 - 2.0) * 44.0, + + (row_count as f32 - 2.0) * 44.0, ), egui::Sense::hover(), ); let ink = Ink::new(ui, r); let w = r.width(); ink.text(0.0, 2.0, "LAYERS", 11.0, palette.muted); - ink.text( - 64.0, - 3.0, - "Double-click to edit", - 10.0, - palette.muted.gamma_multiply(0.55), - ); if ui .put( Rect::from_min_size(ink.point(w - 85.0, -5.0), Vec2::new(85.0, 24.0)), @@ -1035,18 +1030,31 @@ impl Editor { { self.manage_layers(); } + self.layer_tree_header(ui, &ink); let mut reorder = None; - for (row_index, i) in (0..self.layout.layers().len()).rev().enumerate() { + for (row_index, tree_row) in rows.into_iter().enumerate() { let y = 28.0 + row_index as f32 * 44.0; + let i = match tree_row { + layers_ui::TreeRow::Layer(i) => i, + layers_ui::TreeRow::Folder(folder) => { + self.folder_tree_row(ui, &ink, y, w, &folder); + continue; + } + }; + let indent = if self.layout.layer_info(i).folder.is_empty() { + 0.0 + } else { + 18.0 + }; let color = if self.layout.selection_mask()[i] { palette.amber } else { palette.muted }; ink.card( - 0.0, + indent, y, - w, + w - indent, 38.0, palette.field, if self.layout.selection_mask()[i] { @@ -1056,7 +1064,7 @@ impl Editor { }, ); ink.text( - 13.0, + indent + 13.0, y + 10.0, &self.layout.layer_label(i), 15.0, @@ -1068,7 +1076,7 @@ impl Editor { ); let row = ui .interact( - Rect::from_min_size(ink.point(0.0, y), Vec2::new(w - 78.0, 38.0)), + Rect::from_min_size(ink.point(indent, y), Vec2::new(w - 78.0 - indent, 38.0)), egui::Id::new(("layer", self.layout.layer_info(i).id)), egui::Sense::click_and_drag(), ) @@ -1104,9 +1112,10 @@ impl Editor { // The UI is top-to-bottom; document indices are back-to-front. let slot = i + usize::from(!after); let to = slot - usize::from(from < slot); - reorder = Some((payload.0, to)); + reorder = Some((payload.0, self.layout.layer_info(i).folder.clone(), to)); } } + self.folder_drop_on_layer(&row, i); if row.double_clicked() { self.layer_ui.rename = Some(( self.layout.layer_info(i).id, @@ -1140,13 +1149,13 @@ impl Editor { } } } - if let Some((id, to)) = reorder { - self.reorder_layer(id, to); + if let Some((id, folder, to)) = reorder { + match self.layout.move_layer_to_folder(id, &folder, to) { + Ok(()) => self.sync(), + Err(error) => self.error = error, + } } - let r = r.translate(Vec2::new( - 0.0, - (self.layout.layers().len() as f32 - 2.0) * 44.0, - )); + let r = r.translate(Vec2::new(0.0, (row_count as f32 - 2.0) * 44.0)); let ink = Ink::new(ui, r); ink.line([0.0, 130.0], [w, 130.0], palette.line); if self.layout.selected_indices().len() > 1 { @@ -3112,7 +3121,8 @@ impl Editor { .as_ref() .is_some_and(|d| d.pending(&self.layout)) || (self.layer_ui.open && self.names_pending()) - || self.layer_ui.rename.is_some(); + || self.layer_ui.rename.is_some() + || self.layer_ui.folder_rename.is_some(); self.poll_reference(); let palette = theme::palette(ctx); let dropped = ctx.input(|i| i.raw.dropped_files.clone()); diff --git a/crates/midra-layout/src/layers_ui.rs b/crates/midra-layout/src/layers_ui.rs index b14dc6c..6c30b6b 100644 --- a/crates/midra-layout/src/layers_ui.rs +++ b/crates/midra-layout/src/layers_ui.rs @@ -3,9 +3,22 @@ use super::*; #[derive(Clone, Copy)] pub(super) struct LayerDrag(pub usize); +#[derive(Clone)] +pub(super) struct FolderDrag(pub String); + +pub(super) enum TreeRow { + Folder(String), + Layer(usize), +} + #[derive(Default)] pub(super) struct LayerUi { pub open: bool, + pub(super) collapsed: std::collections::BTreeSet, + pub(super) folder_rename: Option<(Option, String, Vec)>, + folder_move: Option<(String, usize, bool)>, + last_folder_click: Option, + assign: Option<(Vec, String)>, pub context_layer: Option, delete_requested: Option, pub(super) rename: Option<(usize, String)>, @@ -38,6 +51,23 @@ impl Editor { self.layer_ui.rename_focus = true; ui.close_menu(); } + ui.menu_button("Move to folder", |ui| { + if ui.button("No folder").clicked() { + self.layer_ui.assign = Some((vec![id], String::new())); + ui.close_menu(); + } + for folder in self.layout.folders() { + if ui.button(&folder).clicked() { + self.layer_ui.assign = Some((vec![id], folder)); + ui.close_menu(); + } + } + if ui.button("New folder…").clicked() { + self.layer_ui.folder_rename = Some((None, "New folder".into(), vec![id])); + self.layer_ui.rename_focus = true; + ui.close_menu(); + } + }); let can_delete = self.layout.layers().len() > 1 && self.layout.visible(i) && !self.layout.locked(i); if ui @@ -196,6 +226,7 @@ impl Editor { } } pub(super) fn layers_window(&mut self, ctx: &egui::Context) { + self.folder_commands(ctx); self.delete_context_layer(); self.rename_window(ctx); if !self.layer_ui.open { @@ -323,6 +354,396 @@ impl Editor { } } +impl Editor { + pub(super) fn layer_tree_rows(&self) -> Vec { + let mut rows = Vec::new(); + let mut seen = std::collections::BTreeSet::new(); + for i in (0..self.layout.layers().len()).rev() { + let folder = &self.layout.layer_info(i).folder; + if folder.is_empty() { + rows.push(TreeRow::Layer(i)); + } else if seen.insert(folder.clone()) { + rows.push(TreeRow::Folder(folder.clone())); + if !self.layer_ui.collapsed.contains(folder) { + rows.extend( + self.layout + .folder_members(folder) + .into_iter() + .rev() + .map(TreeRow::Layer), + ); + } + } + } + rows + } + + pub(super) fn layer_tree_header(&mut self, ui: &mut egui::Ui, ink: &Ink) { + let ids = self + .layout + .selected_indices() + .iter() + .map(|&i| self.layout.layer_info(i).id) + .collect::>(); + let response = ui.put( + Rect::from_min_size(ink.point(65.0, -5.0), Vec2::new(100.0, 24.0)), + egui::Button::new("+ Folder…"), + ); + if response + .on_hover_text("Create a folder from the selected layers.") + .clicked() + { + if ids.is_empty() { + self.error = "Select layers to put in a new folder.".into(); + } else { + self.layer_ui.folder_rename = Some((None, "New folder".into(), ids)); + self.layer_ui.rename_focus = true; + } + } + let root = ui.interact( + Rect::from_min_size(ink.point(0.0, -5.0), Vec2::new(60.0, 24.0)), + egui::Id::new("layer-root"), + egui::Sense::hover(), + ); + if root.dnd_hover_payload::().is_some() { + ui.painter().rect_stroke( + root.rect, + 3.0, + Stroke::new(1.0_f32, theme::palette(ui.ctx()).cyan), + StrokeKind::Inside, + ); + } + if let Some(payload) = root.dnd_release_payload::() { + self.layer_ui.assign = Some((vec![payload.0], String::new())); + } + root.on_hover_text("Drop a layer here to move it out of its folder."); + } + + pub(super) fn folder_drop_on_layer(&mut self, row: &egui::Response, i: usize) { + if let Some(payload) = row.dnd_release_payload::() { + let above = row + .ctx + .input(|i| i.pointer.interact_pos()) + .is_none_or(|p| p.y < row.rect.center().y); + self.layer_ui.folder_move = + Some((payload.0.clone(), self.layout.layer_info(i).id, above)); + } + } + + pub(super) fn folder_tree_row( + &mut self, + ui: &mut egui::Ui, + ink: &Ink, + y: f32, + w: f32, + folder: &str, + ) { + let palette = theme::palette(ui.ctx()); + let members = self.layout.folder_members(folder); + let mask = self.layout.selection_mask(); + let selected = members.iter().any(|&i| mask[i]); + let hidden = members.iter().all(|&i| !self.layout.visible(i)); + let locked = members.iter().all(|&i| self.layout.locked(i)); + let color = if selected { + palette.amber + } else { + palette.text + }; + ink.card( + 0.0, + y, + w, + 38.0, + palette.panel, + if selected { + palette.amber + } else { + palette.line + }, + ); + let collapsed = self.layer_ui.collapsed.contains(folder); + let arrow = ui.interact( + Rect::from_min_size(ink.point(0.0, y), Vec2::new(28.0, 38.0)), + egui::Id::new(("folder-expand", folder)), + egui::Sense::click(), + ); + let c = arrow.rect.center(); + let offsets = if collapsed { + [[-3.0, -5.0], [3.0, 0.0], [-3.0, 5.0]] + } else { + [[-5.0, -3.0], [0.0, 3.0], [5.0, -3.0]] + }; + ui.painter().add(egui::Shape::line( + offsets.map(|[x, y]| c + Vec2::new(x, y)).to_vec(), + Stroke::new(1.5_f32, color), + )); + if arrow + .on_hover_text(if collapsed { + "Expand folder" + } else { + "Collapse folder" + }) + .clicked() + { + self.layer_ui.last_folder_click = None; + if collapsed { + self.layer_ui.collapsed.remove(folder); + } else { + self.layer_ui.collapsed.insert(folder.into()); + } + } + let row = ui.interact( + Rect::from_min_size(ink.point(28.0, y), Vec2::new(w - 106.0, 38.0)), + egui::Id::new(("folder", folder)), + egui::Sense::click_and_drag(), + ); + let painter = ui.painter().with_clip_rect(row.rect); + let icon = ink.point(33.0, y + 12.0); + painter.add(egui::Shape::closed_line( + vec![ + icon, + icon + Vec2::new(6.0, 0.0), + icon + Vec2::new(9.0, 3.0), + icon + Vec2::new(17.0, 3.0), + icon + Vec2::new(17.0, 14.0), + icon + Vec2::new(0.0, 14.0), + ], + Stroke::new(1.3_f32, color), + )); + painter.text( + ink.point(57.0, y + 19.0), + Align2::LEFT_CENTER, + format!("{folder} ({})", members.len()), + FontId::proportional(14.0), + color, + ); + if row.double_clicked() && self.layer_ui.last_folder_click.as_deref() == Some(folder) { + self.layer_ui.folder_rename = Some((Some(folder.into()), folder.into(), vec![])); + self.layer_ui.rename_focus = true; + } + if row.clicked() { + self.layer_ui.last_folder_click = Some(folder.into()); + self.layout.select_folder(folder, click_shift_modifier(ui)); + self.sync(); + } + row.dnd_set_drag_payload(FolderDrag(folder.into())); + if row.dnd_hover_payload::().is_some() + || row.dnd_hover_payload::().is_some() + { + ui.painter().rect_stroke( + row.rect, + 3.0, + Stroke::new(2.0_f32, palette.cyan), + StrokeKind::Inside, + ); + } + if row.dnd_hover_payload::().is_some() + && let Some(payload) = row.dnd_release_payload::() + { + self.layer_ui.assign = Some((vec![payload.0], folder.into())); + self.layer_ui.collapsed.remove(folder); + } + if let Some(payload) = row.dnd_release_payload::() { + let above = row + .ctx + .input(|i| i.pointer.interact_pos()) + .is_none_or(|p| p.y < row.rect.center().y); + let index = if above { + *members.last().unwrap() + } else { + members[0] + }; + self.layer_ui.folder_move = + Some((payload.0.clone(), self.layout.layer_info(index).id, above)); + } + row.context_menu(|ui| { + if ui.button("Select folder contents").clicked() { + self.layout.select_folder(folder, false); + self.sync(); + ui.close_menu(); + } + if ui.button("Rename folder…").clicked() { + self.layer_ui.folder_rename = Some((Some(folder.into()), folder.into(), vec![])); + self.layer_ui.rename_focus = true; + ui.close_menu(); + } + for (label, visible, lock) in [ + ( + if hidden { "Show folder" } else { "Hide folder" }, + Some(hidden), + None, + ), + ( + if locked { + "Unlock folder" + } else { + "Lock folder" + }, + None, + Some(!locked), + ), + ] { + if ui.button(label).clicked() { + self.layout.set_folder_state(folder, visible, lock); + self.sync(); + ui.close_menu(); + } + } + let folders = self.layout.folders(); + let position = folders.iter().position(|name| name == folder).unwrap(); + for (label, target, above) in [ + ("Move folder up", position.checked_sub(1), true), + ( + "Move folder down", + (position + 1 < folders.len()).then_some(position + 1), + false, + ), + ] { + if ui + .add_enabled(target.is_some(), egui::Button::new(label)) + .clicked() + { + let target_members = self.layout.folder_members(&folders[target.unwrap()]); + let index = if above { + *target_members.last().unwrap() + } else { + target_members[0] + }; + self.layer_ui.folder_move = + Some((folder.into(), self.layout.layer_info(index).id, above)); + ui.close_menu(); + } + } + if ui + .button("Ungroup folder") + .on_hover_text("Keep all layers and move them to the root.") + .clicked() + { + self.layer_ui.assign = Some(( + members + .iter() + .map(|&i| self.layout.layer_info(i).id) + .collect(), + String::new(), + )); + ui.close_menu(); + } + }); + row.on_hover_text("Click: select contents · Shift-click: toggle selection · double-click: rename · drag: reorder folder"); + for (kind, x, active) in [("lock", w - 72.0, locked), ("visibility", w - 36.0, hidden)] { + let rect = Rect::from_min_size(ink.point(x, y + 5.0), Vec2::splat(28.0)); + if layer_state_icon( + ui, + rect, + egui::Id::new(("folder-state", kind, folder)), + kind == "lock", + active, + ) + .clicked() + { + self.layout.set_folder_state( + folder, + (kind == "visibility").then_some(active), + (kind == "lock").then_some(!active), + ); + self.sync(); + } + } + } + + fn folder_commands(&mut self, ctx: &egui::Context) { + let result = if let Some((folder, id, above)) = self.layer_ui.folder_move.take() { + Some(self.layout.move_folder(&folder, id, above)) + } else if let Some((ids, folder)) = self.layer_ui.assign.take() { + Some(self.layout.assign_folder(&ids, &folder)) + } else { + None + }; + if let Some(result) = result { + match result { + Ok(()) => { + self.sync(); + if self.layer_ui.open { + self.manage_layers(); + } + } + Err(error) => self.error = error, + } + } + let Some((old, mut name, ids)) = self.layer_ui.folder_rename.take() else { + return; + }; + let mut open = true; + let mut apply = false; + let mut cancel = false; + egui::Window::new(if old.is_some() { + "Rename folder" + } else { + "New folder from layers" + }) + .collapsible(false) + .resizable(false) + .open(&mut open) + .show(ctx, |ui| { + let response = ui.add(egui::TextEdit::singleline(&mut name).char_limit(128)); + if std::mem::take(&mut self.layer_ui.rename_focus) { + response.request_focus(); + } + let valid = !name.trim().is_empty() + && (!self + .layout + .folders() + .iter() + .any(|folder| folder == name.trim()) + || old.as_deref() == Some(name.trim())); + if !valid { + ui.weak("Use a nonempty, unique folder name."); + } + apply = valid && ui.input(|i| i.key_pressed(egui::Key::Enter)); + cancel = ui.input(|i| i.key_pressed(egui::Key::Escape)); + ui.horizontal(|ui| { + apply |= ui + .add_enabled( + valid, + egui::Button::new(if old.is_some() { + "Rename" + } else { + "Create folder" + }), + ) + .clicked(); + cancel |= ui.button("Cancel").clicked(); + }); + }); + if apply { + let result = if let Some(old) = &old { + self.layout.rename_folder(old, &name) + } else { + self.layout.assign_folder(&ids, &name) + }; + match result { + Ok(()) => { + if let Some(old) = old + && self.layer_ui.collapsed.remove(&old) + { + self.layer_ui.collapsed.insert(name.trim().into()); + } + self.sync(); + if self.layer_ui.open { + self.manage_layers(); + } + } + Err(error) => { + self.error = error; + self.layer_ui.folder_rename = Some((old, name, ids)); + } + } + } else if open && !cancel { + self.layer_ui.folder_rename = Some((old, name, ids)); + } + } +} + #[cfg(test)] mod tests { use super::*; @@ -590,4 +1011,149 @@ mod tests { app.manage_layers(); assert_eq!(app.layer_ui.drafts[5].1, "Camera"); } + fn click_tree(app: &mut Editor, ctx: &egui::Context, id: egui::Id) { + use super::super::tests::{frame, mouse}; + frame(app, ctx, vec![]); + frame(app, ctx, vec![]); + let pos = ctx.read_response(id).unwrap().rect.center(); + frame( + app, + ctx, + vec![egui::Event::PointerMoved(pos), mouse(pos, true)], + ); + frame(app, ctx, vec![mouse(pos, false)]); + } + + #[test] + fn folder_tree_collapses_selects_and_protects_its_contents() { + use super::super::tests::frame; + let mut app = Editor::default(); + app.layout.assign_folder(&[1, 2], "Video").unwrap(); + app.layout.select(None); + let ctx = egui::Context::default(); + assert_eq!(app.layer_tree_rows().len(), 3); + click_tree(&mut app, &ctx, egui::Id::new(("folder-expand", "Video"))); + assert_eq!(app.layer_tree_rows().len(), 1); + click_tree(&mut app, &ctx, egui::Id::new(("folder", "Video"))); + assert_eq!(app.layout.selected_indices(), vec![0, 1]); + click_tree( + &mut app, + &ctx, + egui::Id::new(("folder-state", "visibility", "Video")), + ); + assert!(!app.layout.visible(0) && !app.layout.visible(1)); + assert!(app.layout.selected_indices().is_empty()); + app.layout.undo(); + assert!(app.layout.visible(0) && app.layout.visible(1)); + click_tree( + &mut app, + &ctx, + egui::Id::new(("folder-state", "lock", "Video")), + ); + assert!(app.layout.locked(0) && app.layout.locked(1)); + app.layout.undo(); + click_tree(&mut app, &ctx, egui::Id::new(("folder-expand", "Video"))); + assert_eq!(app.layer_tree_rows().len(), 3); + frame(&mut app, &ctx, vec![]); + let folder = ctx + .read_response(egui::Id::new(("folder", "Video"))) + .unwrap() + .rect; + let child = ctx + .read_response(egui::Id::new(("layer", 1_usize))) + .unwrap() + .rect; + assert!(child.top() > folder.bottom()); + } + + fn drag_tree( + app: &mut Editor, + ctx: &egui::Context, + source: egui::Id, + target: egui::Id, + below: bool, + ) { + use super::super::tests::{frame, mouse}; + frame(app, ctx, vec![]); + frame(app, ctx, vec![]); + let start = ctx.read_response(source).unwrap().rect.center(); + let end_rect = ctx.read_response(target).unwrap().rect; + let end = end_rect.center() + Vec2::new(0.0, if below { 10.0 } else { -10.0 }); + frame( + app, + ctx, + vec![egui::Event::PointerMoved(start), mouse(start, true)], + ); + frame( + app, + ctx, + vec![egui::Event::PointerMoved(start + Vec2::new(0.0, 12.0))], + ); + frame(app, ctx, vec![egui::Event::PointerMoved(end)]); + frame(app, ctx, vec![mouse(end, false)]); + frame(app, ctx, vec![]); + } + + #[test] + fn drag_layers_into_folders_to_root_and_reorder_folder_blocks() { + let mut app = Editor::default(); + let ctx = egui::Context::default(); + app.layout.assign_folder(&[2], "Video").unwrap(); + drag_tree( + &mut app, + &ctx, + egui::Id::new(("layer", 1_usize)), + egui::Id::new(("folder", "Video")), + false, + ); + assert_eq!(app.layout.folder_members("Video").len(), 2); + drag_tree( + &mut app, + &ctx, + egui::Id::new(("layer", 1_usize)), + egui::Id::new("layer-root"), + false, + ); + assert_eq!(app.layout.folder_members("Video").len(), 1); + app.layout.assign_folder(&[1], "Slides").unwrap(); + drag_tree( + &mut app, + &ctx, + egui::Id::new(("folder", "Slides")), + egui::Id::new(("folder", "Video")), + true, + ); + assert_eq!(app.layout.layer_info(0).id, 1); + assert_eq!(app.layout.folders(), vec!["Video", "Slides"]); + app.layout.undo(); + assert_eq!(app.layout.layer_info(0).id, 2); + } + + #[test] + fn double_click_folder_opens_rename_and_commits_with_undo() { + use super::super::tests::frame; + let mut app = Editor::default(); + let ctx = egui::Context::default(); + app.layout.assign_folder(&[1, 2], "Video").unwrap(); + for _ in 0..2 { + click_tree(&mut app, &ctx, egui::Id::new(("folder", "Video"))); + } + assert!(app.layer_ui.folder_rename.is_some()); + app.layer_ui.folder_rename.as_mut().unwrap().1 = "Sources".into(); + frame( + &mut app, + &ctx, + vec![egui::Event::Key { + key: egui::Key::Enter, + physical_key: None, + pressed: true, + repeat: false, + modifiers: egui::Modifiers::NONE, + }], + ); + assert!(app.layer_ui.folder_rename.is_none()); + assert_eq!(app.layout.folder_members("Sources"), vec![0, 1]); + app.layout.undo(); + assert_eq!(app.layout.folder_members("Video"), vec![0, 1]); + } } diff --git a/crates/midra-layout/src/lib.rs b/crates/midra-layout/src/lib.rs index 5fed4df..149855f 100644 --- a/crates/midra-layout/src/lib.rs +++ b/crates/midra-layout/src/lib.rs @@ -3,6 +3,7 @@ pub mod device; pub mod device_send; use std::collections::HashMap; pub mod exchange; +mod folders; pub mod formats; mod geometry_formats; pub mod import; diff --git a/crates/midra-layout/tests/folders.rs b/crates/midra-layout/tests/folders.rs new file mode 100644 index 0000000..deed95d --- /dev/null +++ b/crates/midra-layout/tests/folders.rs @@ -0,0 +1,95 @@ +use midra_layout::{Layout, project::Project}; + +fn document() -> Layout { + let mut layout = Layout::default(); + for _ in 0..3 { + layout.add_layer().unwrap(); + } + layout.assign_folder(&[2, 3], "Cameras").unwrap(); + layout.assign_folder(&[1, 4], "Graphics").unwrap(); + layout +} + +#[test] +fn folder_edits_are_atomic_and_preserve_saved_members() { + let mut layout = document(); + let before = Project::from_layout(&layout); + layout.rename_folder("Cameras", "Video").unwrap(); + assert_eq!(layout.folder_members("Video"), vec![0, 2]); + assert!(layout.rename_folder("Video", "Graphics").is_err()); + assert!(layout.rename_folder("Video", " ").is_err()); + layout.undo(); + assert_eq!( + Project::from_layout(&layout).to_json().unwrap(), + before.to_json().unwrap() + ); + layout.redo(); + let saved = Project::from_layout(&layout).to_json().unwrap(); + let loaded = Project::from_json(&saved).unwrap().layout().unwrap(); + assert_eq!(loaded.folder_members("Video"), vec![0, 2]); + layout.assign_folder(&[2, 3], "").unwrap(); + assert!(!layout.folders().contains(&"Video".into())); + layout.undo(); + assert_eq!(layout.folder_members("Video"), vec![0, 2]); +} + +#[test] +fn folder_selection_and_state_respect_protected_layers() { + let mut layout = document(); + layout.set_locked(0, true); + layout.select_folder("Cameras", false); + assert_eq!(layout.selected_indices(), vec![2]); + layout.select_folder("Graphics", true); + assert_eq!(layout.selected_indices(), vec![1, 2, 3]); + layout.select_folder("Graphics", true); + assert_eq!(layout.selected_indices(), vec![2]); + layout.set_folder_state("Cameras", Some(false), None); + assert!(!layout.visible(0) && !layout.visible(2)); + assert!(layout.selected_indices().is_empty()); + assert!(layout.visible(1)); + layout.undo(); + assert!(layout.visible(0) && layout.visible(2)); + layout.set_folder_state("Cameras", None, Some(false)); + assert!(!layout.locked(0) && !layout.locked(2)); + layout.undo(); + assert!(layout.locked(0) && !layout.locked(2)); +} + +#[test] +fn moving_folders_and_layer_membership_preserves_complete_layer_records() { + let mut layout = document(); + let before = Project::from_layout(&layout); + layout.move_folder("Cameras", 4, true).unwrap(); + let after = Project::from_layout(&layout); + assert_eq!( + after.layers.iter().map(|l| l.id).collect::>(), + vec![1, 4, 2, 3, 5] + ); + for layer in &after.layers { + assert_eq!( + serde_json::to_value(layer).unwrap(), + serde_json::to_value(before.layers.iter().find(|old| old.id == layer.id).unwrap()) + .unwrap() + ); + } + layout.undo(); + assert_eq!( + Project::from_layout(&layout).to_json().unwrap(), + before.to_json().unwrap() + ); + layout.move_layer_to_folder(5, "Cameras", 1).unwrap(); + assert_eq!(layout.layer_info(1).id, 5); + assert_eq!(layout.layer_info(1).folder, "Cameras"); + layout.undo(); + assert_eq!( + Project::from_layout(&layout).to_json().unwrap(), + before.to_json().unwrap() + ); + assert!(layout.assign_folder(&[999], "Bad").is_err()); + assert!(layout.move_folder("Missing", 1, true).is_err()); + assert!(layout.move_layer_to_folder(1, "Bad", 99).is_err()); + assert_eq!( + Project::from_layout(&layout).to_json().unwrap(), + before.to_json().unwrap() + ); +} diff --git a/docs/interfaces/midra-layout.md b/docs/interfaces/midra-layout.md index c3b7c3d..89f7c2a 100644 --- a/docs/interfaces/midra-layout.md +++ b/docs/interfaces/midra-layout.md @@ -149,7 +149,23 @@ layer 2 in the list saves IDs in `[2, 1]` order and emits `layer-2` before `laye Loading preserves that order; selected-layer exports still follow document order, not selection order. Source slots, `next_layer_id`, names, folders, crop geometry, visibility/locks and Midra links remain attached to their original layer IDs. -The inspector and layer manager display the reverse of document order: top row is topmost. Selection does not raise a layer; canvas drawing and hit testing follow the saved stack. +The layer manager displays reverse document order (top row is topmost). The inspector +collects same-name folder members into one collapsible group, ordered by each group's +frontmost member; children retain reverse stacking order. Legacy interleaved groups +are displayed together without silently rewriting the saved stack. Selection does not +raise a layer; canvas drawing and hit testing follow the saved stack. + +Folders remain single-level names on layer records; no schema change is required. +There are no empty-folder records or implicit path separators. Creating/renaming a +folder updates all member `folder` strings in one history step; renaming to another +existing folder name is rejected (use membership moves to combine groups). +Moving a folder reorders its members as one contiguous block, preserving member order, +IDs, source references, crops and Midra links. A layer row drop changes membership and +stacking together in one history step. Folder eye/lock actions update each member's +`visible`/`locked` flags atomically; Undo restores mixed prior states. Folder selection +respects each member's visibility/lock. Collapse state is session-only and is omitted +from save/export formats; an empty group disappears when its last member leaves. +Geometry exports continue to omit folders. ## Legacy SVG geometry exchange, version 1 diff --git a/docs/midra-layout-plan.md b/docs/midra-layout-plan.md index b78ce63..c6d2e13 100644 --- a/docs/midra-layout-plan.md +++ b/docs/midra-layout-plan.md @@ -26,9 +26,10 @@ are implemented. Project save/load and theme preferences are no longer future wo Remaining work, in priority order: -1. Stable-ID collections, add/remove/rename, folder labels/filtering, selected-layer - SVG export and project v3 migration are implemented. Nested folder trees and - hardware mapping controls remain follow-ups. +1. Stable-ID collections, add/remove/rename, collapsible single-level folders, + folder/member drag organization, bulk folder visibility/locking, selected-layer + SVG export and project migration are implemented. Nested folders and inherited + folder visibility (preserving individual flags across hide/show) remain follow-ups. 2. Reference native-size/offset mapping, outline-only display, adaptive filtering and background picture import are implemented. Embedded-image project loading remains synchronous. High-zoom pixel grids/rulers and resize snapping are implemented. @@ -316,7 +317,8 @@ permits Program changes; actual writes remain explicit reviewed actions. Status: stable-ID collections, add/remove/rename, visibility/locking with undo, folder labels/filtering and all/visible/selected/specific SVG scopes are implemented. -Hardware mapping and nested/reorderable folder trees remain. This local organization can be +Single-level folder expand/collapse and drag reordering are implemented; nested +folder trees remain. This local organization can be implemented independently of step 10 and does not authorize device connectivity. Folders are an optional follow-up, not a prerequisite for adding/hiding layers. @@ -350,11 +352,13 @@ Folders are an optional follow-up, not a prerequisite for adding/hiding layers. mappings are pending. When session save/load is added, preserve stable IDs, names, geometry, visibility and mappings. Extend selection, paste targeting and undo so they no longer depend on array indices. -- [ ] Optional: add named folders with expand/collapse and drag-to-organize. - Folders organize local layers; they do not introduce geometry transforms or - hardware groups. Collapsing a folder changes only the list display. If folder - visibility is added, effective visibility is the layer's own setting AND all - ancestor-folder settings; hiding a folder must preserve child visibility choices. +- [x] Add named single-level folders with expand/collapse, select contents, + rename, and drag-to-organize. Folders do not introduce geometry transforms or + hardware groups. Collapsing a folder changes only the list display. +- [ ] Add nested folders and inherited visibility/locking. Current folder eye/lock + controls are atomic bulk member edits (Undo restores mixed flags). Inherited + visibility should instead combine each layer's own setting with ancestor flags, + preserving child visibility choices across a folder hide/show cycle. - [ ] Test adding layers, hidden-layer selection through the list, stable mappings after reorder, paste/undo targeting, both export scopes, empty scopes, unmapped or conflicting targets, and optional nested-folder visibility. Confirm that @@ -530,8 +534,8 @@ and Centered-crop import round trips passed Eikos 3.3.10 hardware checks. samples; no undocumented Illustrator/Inkscape clipboard compatibility is claimed. - Operator-platform acceptance (Windows/macOS, DPI, GPU presentation) and release packaging remain separate from the Linux native UI and headless timing checks. -- Embedded-reference project loading is still synchronous. Folder labels/filtering - are implemented; nested folder trees and drag reordering remain optional work. +- Embedded-reference project loading is still synchronous. Collapsible single-level folders and drag organization + are implemented; nested folder trees remain optional work. ## Pending stretch goals — specifications to follow diff --git a/docs/midra-layout.md b/docs/midra-layout.md index 954a880..30cae9b 100644 --- a/docs/midra-layout.md +++ b/docs/midra-layout.md @@ -13,6 +13,27 @@ Connection reads and reviewed device sends happen only on request. cargo run --locked -p midra-layout ``` +## Layer folders + +The Layers sidebar groups folder members under collapsible folder rows. +Click the chevron to expand/collapse; click the folder name to select its visible, +unlocked layers. Shift-click adds/removes its contents from the selection. +Double-click a folder or layer name to rename it. Folder eye and lock icons apply +to every member; Undo restores each member's previous state, including mixed states. + +Select layers and choose **+ Folder…** to group them. Drag a layer onto a folder +name to move it inside, or onto **LAYERS** to return it to the root. Dropping on +another layer also changes stacking order and adopts that layer's folder. +Drag folder names above/below another folder to reorder all their layers as one +block. Right-click offers rename, selection, visibility, locking, moving up/down, +and **Ungroup folder** (keeps the layers). A layer's right-click **Move to folder** +menu also offers existing folders, the root, and a new folder. + +Folders are local, single-level groups stored with their layers. Empty folders +are removed automatically; collapse state lasts for this session. The existing +**Manage…** window remains available for bulk name/folder editing. Grouping does +not affect device links or source assignments. All document edits support Undo. + ## Paste layer values and import geometry 1. Choose destinations using **Choose destination layers…** in the Import menu diff --git a/docs/midralayout/changelog.md b/docs/midralayout/changelog.md index 8c17401..7911555 100644 --- a/docs/midralayout/changelog.md +++ b/docs/midralayout/changelog.md @@ -4,6 +4,8 @@ ## Unreleased +- Organize the flat layer sidebar into collapsible folder groups: select contents, double-click rename, group eye/lock controls, drag layers between folders/root, and reorder folders as blocks. Add new-folder and right-click actions, with atomic Undo and existing project compatibility; empty groups disappear and nesting is not introduced. + - Reorder the viewport toolbar into shared bordered groups: Project/Import, Undo/Redo, Select/Move, view controls, Align/Snap/Pivot, and Output/Options. Groups wrap together on narrow windows and preserve optional icon captions. - Snap moving layers, resize handles and pivots to screen center and quarter guides on both axes. Moving layer centers also snap to these interior guides; the existing screen snapping option controls all screen guides.