Add collapsible layer folders and drag organization
Beffroi/beffroi-tools/pipeline/head This commit looks good
Details
Beffroi/beffroi-tools/pipeline/head This commit looks good
Details
This commit is contained in:
parent
4ec925d1fa
commit
f5ac790a6d
|
|
@ -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(())
|
||||
}
|
||||
}
|
||||
|
|
@ -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());
|
||||
|
|
|
|||
|
|
@ -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]);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
);
|
||||
}
|
||||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
Loading…
Reference in New Issue