Add collapsible layer folders and drag organization
Beffroi/beffroi-tools/pipeline/head This commit looks good Details

This commit is contained in:
Dandaedre 2026-11-14 15:47:33 +01:00
parent 4ec925d1fa
commit f5ac790a6d
9 changed files with 915 additions and 33 deletions

View File

@ -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<String> {
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<usize> {
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::<Vec<_>>();
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::<Vec<_>>(),
);
}
/// Mixed groups become fully visible/unlocked when the caller requests it.
pub fn set_folder_state(&mut self, folder: &str, visible: Option<bool>, locked: Option<bool>) {
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::<Vec<_>>();
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::<Vec<_>>();
order.remove(from);
order.insert(to, from);
self.order_layers(&order);
self.remember(before);
Ok(())
}
}

View File

@ -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());

View File

@ -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<String>,
pub(super) folder_rename: Option<(Option<String>, String, Vec<usize>)>,
folder_move: Option<(String, usize, bool)>,
last_folder_click: Option<String>,
assign: Option<(Vec<usize>, String)>,
pub context_layer: Option<usize>,
delete_requested: Option<usize>,
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<TreeRow> {
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::<Vec<_>>();
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::<LayerDrag>().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::<LayerDrag>() {
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::<FolderDrag>() {
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::<LayerDrag>().is_some()
|| row.dnd_hover_payload::<FolderDrag>().is_some()
{
ui.painter().rect_stroke(
row.rect,
3.0,
Stroke::new(2.0_f32, palette.cyan),
StrokeKind::Inside,
);
}
if row.dnd_hover_payload::<LayerDrag>().is_some()
&& let Some(payload) = row.dnd_release_payload::<LayerDrag>()
{
self.layer_ui.assign = Some((vec![payload.0], folder.into()));
self.layer_ui.collapsed.remove(folder);
}
if let Some(payload) = row.dnd_release_payload::<FolderDrag>() {
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]);
}
}

View File

@ -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;

View File

@ -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<_>>(),
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()
);
}

View File

@ -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

View File

@ -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

View File

@ -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

View File

@ -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.