beffroi-tools/crates/midra-layout/src/layers_ui.rs

1423 lines
54 KiB
Rust

use super::*;
fn order_button(ui: &mut egui::Ui, layer: usize, up: bool, enabled: bool) -> egui::Response {
ui.add_enabled_ui(enabled, |ui| {
let (_, rect) = ui.allocate_space(Vec2::splat(24.0));
let response = ui.interact(
rect,
egui::Id::new(("layer-order", layer, up)),
egui::Sense::click(),
);
response.widget_info(|| {
egui::WidgetInfo::labeled(
egui::WidgetType::Button,
enabled,
if up { "Move up" } else { "Move down" },
)
});
let visuals = ui.style().interact(&response);
ui.painter().rect(
rect,
visuals.corner_radius,
visuals.weak_bg_fill,
visuals.bg_stroke,
egui::StrokeKind::Inside,
);
let center = rect.center();
let direction = if up { -1.0 } else { 1.0 };
let tip = center + Vec2::new(0.0, 5.0 * direction);
ui.painter().line_segment(
[center - Vec2::new(0.0, 5.0 * direction), tip],
visuals.fg_stroke,
);
ui.painter().add(egui::Shape::line(
vec![
tip + Vec2::new(-4.0, -4.0 * direction),
tip,
tip + Vec2::new(4.0, -4.0 * direction),
],
visuals.fg_stroke,
));
response
})
.inner
}
#[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>,
folder_remove: Option<String>,
pub(super) rename: Option<(usize, String)>,
pub(super) rename_focus: bool,
drafts: Vec<(usize, String, String)>,
error: String,
closing: bool,
rename_closing: bool,
deferred: u8,
folder_filter: Option<String>,
}
impl LayerUi {
pub(super) fn sync_order(&mut self, order: &[usize]) {
if self.drafts.len() == order.len()
&& self.drafts.iter().all(|(id, _, _)| order.contains(id))
{
self.drafts
.sort_by_key(|(id, _, _)| order.iter().position(|current| current == id));
}
}
}
impl Editor {
pub(super) fn layer_actions_menu(&mut self, ui: &mut egui::Ui, id: usize) {
self.layer_organize_menu(ui, id);
self.layer_delete_menu(ui, id);
}
pub(super) fn layer_organize_menu(&mut self, ui: &mut egui::Ui, id: usize) {
let Some(i) = (0..self.layout.layers().len()).find(|&i| self.layout.layer_info(i).id == id)
else {
return;
};
if ui.button("Rename layer…").clicked() {
self.layer_ui.rename = Some((id, self.layout.layer_info(i).name.clone()));
self.layer_ui.rename_focus = true;
ui.close_menu();
}
let ids = if self.layout.selection_mask()[i] {
self.layout
.selected_indices()
.into_iter()
.map(|i| self.layout.layer_info(i).id)
.collect()
} else {
vec![id]
};
ui.menu_button("Move to folder", |ui| {
if ui.button("No folder").clicked() {
self.layer_ui.assign = Some((ids.clone(), String::new()));
ui.close_menu();
}
for folder in self.layout.folders() {
if ui.button(&folder).clicked() {
self.layer_ui.assign = Some((ids.clone(), folder));
ui.close_menu();
}
}
if ui.button("New folder…").clicked() {
self.layer_ui.folder_rename = Some((None, "New folder".into(), ids.clone()));
self.layer_ui.rename_focus = true;
ui.close_menu();
}
});
}
pub(super) fn layer_delete_menu(&mut self, ui: &mut egui::Ui, id: usize) {
let Some(i) = (0..self.layout.layers().len()).find(|&i| self.layout.layer_info(i).id == id)
else {
return;
};
let can_delete =
self.layout.layers().len() > 1 && self.layout.visible(i) && !self.layout.locked(i);
if ui
.add_enabled(can_delete, egui::Button::new("Delete layer"))
.on_hover_text("Delete this layer. Undo restores it.")
.on_disabled_hover_text(
"Keep at least one layer; show and unlock this layer before deleting it.",
)
.clicked()
{
self.layer_ui.delete_requested = Some(id);
ui.close_menu();
}
}
fn delete_context_layer(&mut self) {
let Some(id) = self.layer_ui.delete_requested.take() else {
return;
};
let Some(i) = (0..self.layout.layers().len()).find(|&i| self.layout.layer_info(i).id == id)
else {
return;
};
if !self.layout.visible(i) || self.layout.locked(i) || self.layout.layers().len() <= 1 {
return;
}
self.layout.select(Some(i));
match self.layout.remove_selected() {
Ok(()) => {
self.align_target = AlignTarget::Selection;
self.edit_content = false;
self.format_draft = None;
self.paste = None;
self.layer_ui.context_layer = None;
self.sync();
}
Err(error) => self.error = error,
}
}
pub(super) fn reorder_layer(&mut self, id: usize, to: usize) {
match self.layout.move_layer(id, to) {
Ok(()) => {
self.sync();
}
Err(e) => self.error = e,
}
}
pub(super) fn names_pending(&self) -> bool {
self.layer_ui
.drafts
.iter()
.enumerate()
.any(|(i, (id, name, folder))| {
i >= self.layout.layers().len()
|| self.layout.layer_info(i).id != *id
|| self.layout.layer_info(i).name != name.trim()
|| self.layout.layer_info(i).folder != folder.trim()
})
}
pub(super) fn manage_layers(&mut self) {
self.layer_ui.open = true;
self.layer_ui.drafts = (0..self.layout.layers().len())
.map(|i| {
let info = self.layout.layer_info(i);
(info.id, info.name.clone(), info.folder.clone())
})
.collect();
self.layer_ui.error.clear();
}
pub(super) fn add_layer(&mut self) {
match self.layout.add_layer() {
Ok(_) => {
self.sync();
self.manage_layers();
}
Err(error) => self.error = error,
}
}
pub(super) fn remove_layers(&mut self) {
match self.layout.remove_selected() {
Ok(()) => {
self.align_target = AlignTarget::Selection;
self.edit_content = false;
self.format_draft = None;
self.paste = None;
self.sync();
self.manage_layers();
}
Err(error) => self.error = error,
}
}
fn rename_window(&mut self, ctx: &egui::Context) {
let Some((id, mut name)) = self.layer_ui.rename.take() else {
return;
};
let Some(i) = (0..self.layout.layers().len()).find(|&i| self.layout.layer_info(i).id == id)
else {
return;
};
let mut open = true;
let mut apply = false;
let mut cancel = false;
egui::Window::new("Rename layer")
.open(&mut open)
.collapsible(false)
.resizable(false)
.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();
}
cancel = ui.input(|input| input.key_pressed(egui::Key::Escape));
let valid = !name.trim().is_empty();
apply = valid && ui.input(|input| input.key_pressed(egui::Key::Enter));
ui.horizontal(|ui| {
apply |= apply_button(
ui,
"Rename",
valid && name.trim() != self.layout.layer_info(i).name,
)
.clicked();
cancel |= ui.button("Cancel").clicked();
});
});
if !open && name.trim() != self.layout.layer_info(i).name {
self.layer_ui.rename_closing = true;
}
if self.layer_ui.rename_closing {
match pending_close(ctx, "rename-close", &self.error) {
Some(true) => {
apply = true;
self.layer_ui.rename_closing = false;
}
Some(false) => {
cancel = true;
self.layer_ui.rename_closing = false;
}
None => {}
}
}
if apply {
let folder = self.layout.layer_info(i).folder.clone();
match self.layout.rename_layer(i, &name, &folder) {
Ok(()) => {
self.sync();
if self.layer_ui.open {
self.manage_layers();
}
}
Err(error) => {
self.error = error;
self.layer_ui.rename = Some((id, name));
}
}
} else if (open || self.layer_ui.rename_closing) && !cancel {
self.layer_ui.rename = Some((id, name));
}
}
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 {
return;
}
let mut open = true;
let mut add = false;
let mut remove = false;
let mut refresh = false;
let mut sync = false;
let mut reorder = None;
let mut commit_names = false;
egui::Window::new("Layers & folders").enabled(!self.format_draft.as_ref().is_some_and(|d| d.pending(&self.layout))).open(&mut open).default_width(740.0).show(ctx, |ui| {
ui.horizontal(|ui| {
add = ui.add_enabled(self.layout.layers().len() < 256, egui::Button::new("Add layer")).clicked();
let count = self.layout.selected_indices().len();
remove = ui.add_enabled(count > 0 && count < self.layout.layers().len(), egui::Button::new("Remove selected")).clicked();
ui.weak("Add, remove, rename and reorder support Undo.");
});
let stale = self.layer_ui.drafts.len() != self.layout.layers().len() || self.layer_ui.drafts.iter().enumerate().any(|(i, d)| self.layout.layer_info(i).id != d.0);
if stale {
ui.label("The layer list changed. Reload this editor before applying names.");
refresh = ui.button("Reload layer list").clicked();
return;
}
let folders: std::collections::BTreeSet<_> = (0..self.layout.layers().len()).map(|i| self.layout.layer_info(i).folder.clone()).collect();
egui::ComboBox::from_id_salt("layer-folder-filter").selected_text(self.layer_ui.folder_filter.as_deref().filter(|s| !s.is_empty()).unwrap_or(if self.layer_ui.folder_filter.is_some() { "No folder" } else { "All folders" })).show_ui(ui, |ui| {
ui.selectable_value(&mut self.layer_ui.folder_filter, None, "All folders");
for folder in folders { let label = if folder.is_empty() { "No folder" } else { &folder }; ui.selectable_value(&mut self.layer_ui.folder_filter, Some(folder.clone()), label); }
});
egui::ScrollArea::vertical().max_height(400.0).show(ui, |ui| {
egui::Grid::new("layer-management").striped(true).show(ui, |ui| {
ui.label("Order"); ui.label("Select / ID"); ui.label("Name"); ui.label("Folder (optional)"); ui.label("Visibility"); ui.label("Protection"); ui.end_row();
for (i, (id, name, folder)) in self.layer_ui.drafts.iter_mut().enumerate().rev() {
if self.layer_ui.folder_filter.as_ref().is_some_and(|folder| *folder != self.layout.layer_info(i).folder) { continue; }
ui.horizontal(|ui| {
let unfiltered = self.layer_ui.folder_filter.is_none();
if order_button(ui, *id, true, unfiltered && i + 1 < self.layout.layers().len()).on_hover_text("Move up / bring forward").on_disabled_hover_text("Show all folders to reorder; the top layer cannot move up.").clicked() { reorder = Some((*id, i + 1)); }
if order_button(ui, *id, false, unfiltered && i > 0).on_hover_text("Move down / send backward").on_disabled_hover_text("Show all folders to reorder; the bottom layer cannot move down.").clicked() { reorder = Some((*id, i - 1)); }
});
let selected = self.layout.selection_mask()[i];
if ui.selectable_label(selected, format!("{id:02}")).clicked() { self.layout.toggle(i); sync = true; }
let name_response = ui.add_sized([170.0,24.0], egui::TextEdit::singleline(name).id(egui::Id::new(("layer-name", *id))).char_limit(128));
let folder_response = ui.add_sized([140.0,24.0], egui::TextEdit::singleline(folder).id(egui::Id::new(("layer-folder", *id))).char_limit(128));
commit_names |= name_response.lost_focus() || folder_response.lost_focus()
|| ((name_response.has_focus() || folder_response.has_focus()) && ui.input(|i| i.key_pressed(egui::Key::Enter)));
let (_, rect) = ui.allocate_space(Vec2::splat(28.0));
if layer_state_icon(ui, rect, ui.id().with(("show", *id)), false, !self.layout.visible(i)).clicked() { self.layout.set_visible(i, !self.layout.visible(i)); sync = true; }
let (_, rect) = ui.allocate_space(Vec2::splat(28.0));
if layer_state_icon(ui, rect, ui.id().with(("lock", *id)), true, self.layout.locked(i)).clicked() { self.layout.set_locked(i, !self.layout.locked(i)); sync = true; }
ui.end_row();
}
});
});
ui.weak("Folder names organize the layer list locally; they do not create hardware layers. IDs remain stable when layers are removed.");
ui.small("Names and folders save on Enter or when leaving the field. Undo restores previous values.");
if !self.layer_ui.error.is_empty() { ui.colored_label(ui.visuals().error_fg_color, &self.layer_ui.error); }
});
if (commit_names || !open || add || remove || refresh || reorder.is_some())
&& self.names_pending()
{
match self.layout.rename_layers(&self.layer_ui.drafts) {
Ok(()) => {
self.layer_ui.error.clear();
self.sync();
}
Err(error) => self.layer_ui.error = error,
}
}
if (!open || add || remove || refresh) && self.names_pending() {
self.layer_ui.closing = true;
self.layer_ui.deferred = if add {
1
} else if remove {
2
} else if refresh {
3
} else {
0
};
}
if self.layer_ui.closing {
add = false;
remove = false;
refresh = false;
open = true;
let choice = pending_close(ctx, "names-close", &self.layer_ui.error);
if let Some(apply) = choice {
let result = if apply {
self.layout.rename_layers(&self.layer_ui.drafts)
} else {
Ok(())
};
match result {
Ok(()) => {
self.layer_ui.closing = false;
open = self.layer_ui.deferred != 0;
add = self.layer_ui.deferred == 1;
remove = self.layer_ui.deferred == 2;
refresh = self.layer_ui.deferred == 3;
self.layer_ui.error.clear();
self.sync();
}
Err(e) => {
self.layer_ui.error = e;
self.layer_ui.closing = false;
}
}
}
}
self.layer_ui.open = open;
if let Some((id, to)) = reorder {
self.reorder_layer(id, to);
}
if sync {
self.sync();
}
if add {
self.add_layer();
} else if remove {
self.remove_layers();
} else if refresh {
self.manage_layers();
}
}
}
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),
);
}
}
}
for folder in self.layout.folders() {
if seen.insert(folder.clone()) {
rows.push(TreeRow::Folder(folder));
}
}
rows
}
pub(super) fn layer_tree_header(&mut self, ui: &mut egui::Ui, ink: &Ink, width: f32) {
if toolbar_icon(
ui,
Rect::from_min_size(ink.point(width - 92.0, -5.0), Vec2::new(28.0, 24.0)),
"Create folder",
ToolbarIcon::AddFolder,
)
.clicked()
{
self.layer_ui.folder_rename = Some((None, "New folder".into(), Vec::new()));
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.is_empty() && members.iter().all(|&i| !self.layout.visible(i));
let locked = !members.is_empty() && 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.device.follow_folder(folder);
self.layout.select_folder(folder, click_shift_modifier(ui));
self.sync();
}
if !members.is_empty() {
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>()
&& !members.is_empty()
{
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.device.follow_folder(folder);
self.layout.select_folder(folder, false);
self.sync();
ui.close_menu();
}
if ui.button("Use folder for Midra transfers").clicked() {
self.device
.set_scope(device_ui::TransferScope::Folder(folder.into()));
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(
!members.is_empty()
&& target.is_some_and(|i| {
!self.layout.folder_members(&folders[i]).is_empty()
}),
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(if members.is_empty() {
"Delete empty folder"
} else {
"Ungroup folder"
})
.on_hover_text("Keep all layers and move them to the root.")
.clicked()
{
self.layer_ui.folder_remove = Some(folder.into());
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) = self.layer_ui.folder_remove.take() {
self.layer_ui.collapsed.remove(&folder);
Some(self.layout.ungroup_folder(&folder))
} else 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"
})
.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.create_folder_with_layers(&name, &ids)
};
match result {
Ok(()) => {
if old.as_ref().is_some_and(|old| {
self.device.scope == device_ui::TransferScope::Folder(old.clone())
}) {
self.device.follow_folder(name.trim());
}
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::*;
#[test]
fn empty_layer_list_space_clears_selection() {
use super::super::tests::{frame, mouse};
let ctx = egui::Context::default();
let mut app = Editor::default();
app.layout.assign_folder(&[1, 2], "Video").unwrap();
for gap in [false, true] {
click_tree(&mut app, &ctx, egui::Id::new(("folder", "Video")));
assert_eq!(app.layout.selected_indices(), [0, 1]);
let rect = ctx
.read_response(egui::Id::new(("layer", 2_usize)))
.unwrap()
.rect;
let pos = if gap {
Pos2::new(rect.center().x, rect.bottom() + 3.0)
} else {
Pos2::new(rect.left() - 9.0, rect.center().y)
};
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(pos), mouse(pos, true)],
);
frame(&mut app, &ctx, vec![mouse(pos, false)]);
assert!(app.layout.selected_indices().is_empty());
}
click_tree(&mut app, &ctx, egui::Id::new(("layer", 2_usize)));
assert_eq!(app.layout.selected_indices().len(), 1);
assert_eq!(app.layout.layer_info(app.layout.selected().unwrap()).id, 2);
}
#[test]
fn empty_folder_dialog_preserves_selection_and_restores_its_tree_row() {
let ctx = egui::Context::default();
let mut app = Editor::default();
app.layout.set_selection([true, true]);
let before = app.layout.layers().to_vec();
app.layer_ui.folder_rename = Some((None, "Empty".into(), vec![]));
super::super::tests::click_text(&mut app, &ctx, "Create folder");
assert_eq!(app.layout.layers(), &before);
assert_eq!(app.layout.selected_indices(), [0, 1]);
assert!(app.layout.folder_members("Empty").is_empty());
assert!(
app.layer_tree_rows()
.iter()
.any(|r| matches!(r, TreeRow::Folder(f) if f == "Empty"))
);
app.layer_ui.collapsed.insert("Empty".into());
let saved = app.project();
app.install_project(&ctx, saved.clone()).unwrap();
super::super::tests::frame(&mut app, &ctx, vec![]);
assert_eq!(app.project(), saved);
assert!(
ctx.read_response(egui::Id::new(("folder", "Empty")))
.is_some()
);
app.layer_ui.folder_remove = Some("Empty".into());
super::super::tests::frame(&mut app, &ctx, vec![]);
assert!(app.layout.folders().is_empty());
app.layout.undo();
assert_eq!(app.layout.folders(), ["Empty"]);
}
#[test]
fn both_context_menus_move_the_selection_or_only_an_unselected_target() {
fn menu_frame(
app: &mut Editor,
ctx: &egui::Context,
viewport: bool,
id: usize,
events: Vec<egui::Event>,
) -> egui::FullOutput {
ctx.run(
egui::RawInput {
screen_rect: Some(Rect::from_min_size(Pos2::ZERO, Vec2::new(1000.0, 900.0))),
events,
..Default::default()
},
|ctx| {
egui::CentralPanel::default().show(ctx, |ui| {
if viewport {
app.layer_ui.context_layer = Some(id);
app.layer_context_menu(ui);
} else {
app.layer_actions_menu(ui, id);
}
});
},
)
}
fn click(app: &mut Editor, ctx: &egui::Context, viewport: bool, id: usize, label: &str) {
menu_frame(app, ctx, viewport, id, vec![]);
let output = menu_frame(app, ctx, viewport, id, vec![]);
let point = output
.shapes
.iter()
.find_map(|s| match &s.shape {
egui::Shape::Text(t) if t.galley.text() == label => {
Some(t.pos + t.galley.size() * 0.5)
}
_ => None,
})
.unwrap_or_else(|| panic!("Missing {label}"));
menu_frame(
app,
ctx,
viewport,
id,
vec![
egui::Event::PointerMoved(point),
super::super::tests::mouse(point, true),
],
);
menu_frame(
app,
ctx,
viewport,
id,
vec![super::super::tests::mouse(point, false)],
);
}
for viewport in [false, true] {
for selected_target in [false, true] {
let ctx = egui::Context::default();
let mut app = Editor::default();
app.layout.add_layer().unwrap();
app.layout.set_selection([true, true, false]);
app.layout.create_folder("Destination").unwrap();
let id = app
.layout
.layer_info(if selected_target { 0 } else { 2 })
.id;
click(&mut app, &ctx, viewport, id, "Move to folder");
click(&mut app, &ctx, viewport, id, "Destination");
let (ids, folder) = app.layer_ui.assign.take().unwrap();
app.layout.assign_folder(&ids, &folder).unwrap();
assert_eq!(
app.layout.folder_members("Destination"),
if selected_target { vec![0, 1] } else { vec![2] }
);
app.layout.undo();
assert!(app.layout.folder_members("Destination").is_empty());
}
}
}
#[test]
fn dragging_top_row_below_bottom_row_sends_it_to_the_back() {
use super::super::tests::{frame, mouse};
let ctx = egui::Context::default();
let mut app = Editor::default();
app.layout.add_layer().unwrap();
app.sync();
let before = midra_layout::project::Project::from_layout(&app.layout);
frame(&mut app, &ctx, vec![]);
let start = ctx
.read_response(egui::Id::new(("layer", 3_usize)))
.unwrap()
.rect
.center();
let end = ctx
.read_response(egui::Id::new(("layer", 2_usize)))
.unwrap()
.rect
.center_bottom()
- Vec2::new(0.0, 3.0);
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(start), mouse(start, true)],
);
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(start + Vec2::new(0.0, 12.0))],
);
frame(&mut app, &ctx, vec![egui::Event::PointerMoved(end)]);
frame(&mut app, &ctx, vec![mouse(end, false)]);
assert_eq!(
(0..3)
.map(|i| app.layout.layer_info(i).id)
.collect::<Vec<_>>(),
[3, 2, 1]
);
app.layout.undo();
assert_eq!(
midra_layout::project::Project::from_layout(&app.layout),
before
);
}
#[test]
fn manager_commits_names_before_reordering_and_undo_keeps_alignment_identity() {
use super::super::tests::{frame, mouse};
let ctx = egui::Context::default();
let mut app = Editor {
align_target: AlignTarget::Layer(0),
..Default::default()
};
app.manage_layers();
app.layer_ui.drafts[0].1 = "Camera".into();
frame(&mut app, &ctx, vec![]);
frame(&mut app, &ctx, vec![]);
let pos = ctx
.read_response(egui::Id::new(("layer-order", 1_usize, false)))
.unwrap()
.rect
.center();
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(pos), mouse(pos, true)],
);
frame(&mut app, &ctx, vec![mouse(pos, false)]);
assert_eq!(app.layout.layer_info(1).id, 2);
assert_eq!(app.layout.layer_info(1).name, "Camera");
assert_eq!(app.layer_ui.drafts[1].1, "Camera");
assert_eq!(app.align_target, AlignTarget::Layer(1));
assert!(!app.names_pending());
assert!(!app.layer_ui.closing);
assert_eq!(app.layout.layer_info(1).name, "Camera");
app.layout.undo();
app.layout.undo();
app.sync();
assert_eq!(app.layout.layer_info(0).id, 2);
assert_eq!(app.layer_ui.drafts[0].0, 2);
assert_eq!(app.align_target, AlignTarget::Layer(0));
}
#[test]
fn inspector_drag_reorders_once_preserves_selection_and_can_cancel() {
use super::super::tests::{frame, mouse};
let ctx = egui::Context::default();
let mut app = Editor::default();
app.layout.add_layer().unwrap();
app.layout.select(Some(1));
app.sync();
let before = midra_layout::project::Project::from_layout(&app.layout);
frame(&mut app, &ctx, vec![]);
let row = |id| {
ctx.read_response(egui::Id::new(("layer", id)))
.unwrap()
.rect
};
let start = row(2_usize).center();
assert!(row(3_usize).top() < row(1_usize).top());
assert!(row(1_usize).top() < row(2_usize).top());
let end = row(3_usize).center_top() + Vec2::new(0.0, 3.0);
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(start), mouse(start, true)],
);
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(start + Vec2::new(0.0, 12.0))],
);
frame(&mut app, &ctx, vec![egui::Event::PointerMoved(end)]);
assert_eq!(
midra_layout::project::Project::from_layout(&app.layout),
before
);
frame(&mut app, &ctx, vec![mouse(end, false)]);
assert_eq!(
(0..3)
.map(|i| app.layout.layer_info(i).id)
.collect::<Vec<_>>(),
[1, 3, 2]
);
assert_eq!(app.layout.layer_info(app.layout.selected().unwrap()).id, 1);
app.layout.undo();
app.sync();
assert_eq!(
midra_layout::project::Project::from_layout(&app.layout),
before
);
frame(&mut app, &ctx, vec![]);
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(start), mouse(start, true)],
);
frame(&mut app, &ctx, vec![egui::Event::PointerMoved(end)]);
frame(
&mut app,
&ctx,
vec![egui::Event::Key {
key: egui::Key::Escape,
physical_key: None,
pressed: true,
repeat: false,
modifiers: egui::Modifiers::NONE,
}],
);
frame(&mut app, &ctx, vec![mouse(end, false)]);
assert_eq!(
midra_layout::project::Project::from_layout(&app.layout),
before
);
// Releasing outside the list also cancels the reorder.
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(start), mouse(start, true)],
);
let outside = Pos2::new(500.0, 500.0);
frame(&mut app, &ctx, vec![egui::Event::PointerMoved(outside)]);
frame(&mut app, &ctx, vec![mouse(outside, false)]);
assert_eq!(
midra_layout::project::Project::from_layout(&app.layout),
before
);
}
#[test]
fn names_and_folders_commit_on_enter_or_focus_loss_and_undo() {
use super::super::tests::{frame, mouse};
for enter in [false, true] {
let ctx = egui::Context::default();
let mut app = Editor::default();
app.manage_layers();
frame(&mut app, &ctx, vec![]);
let before = app.layout.layer_info(1).clone();
let field_id =
egui::Id::new((if enter { "layer-name" } else { "layer-folder" }, before.id));
ctx.memory_mut(|m| m.request_focus(field_id));
frame(&mut app, &ctx, vec![]);
if enter {
app.layer_ui.drafts[1].1 = "Camera".into();
} else {
app.layer_ui.drafts[1].2 = "Cameras".into();
}
frame(&mut app, &ctx, vec![]);
assert_eq!(app.layout.layer_info(1), &before);
let events = if enter {
vec![egui::Event::Key {
key: egui::Key::Enter,
physical_key: None,
pressed: true,
repeat: false,
modifiers: egui::Modifiers::NONE,
}]
} else {
let pos = Pos2::new(20.0, 15.0);
vec![egui::Event::PointerMoved(pos), mouse(pos, true)]
};
let output = frame(&mut app, &ctx, events);
assert!(!output.shapes.iter().any(|shape| matches!(&shape.shape, egui::Shape::Text(t) if t.galley.text() == "Apply names & folders")));
if enter {
assert_eq!(app.layout.layer_info(1).name, "Camera");
} else {
assert_eq!(app.layout.layer_info(1).folder, "Cameras");
}
assert!(!app.names_pending());
app.layout.undo();
assert_eq!(app.layout.layer_info(1), &before);
}
}
#[test]
fn closing_batch_names_applies_or_discards_without_losing_identity() {
let ctx = egui::Context::default();
let mut app = Editor::default();
app.manage_layers();
let id = app.layout.layer_info(1).id;
app.layer_ui.drafts[1].1 = "Camera".into();
app.layer_ui.closing = true;
super::super::tests::click_text(&mut app, &ctx, "Apply");
assert!(!app.layer_ui.open);
assert_eq!(app.layout.layer_info(1).name, "Camera");
assert_eq!(app.layout.layer_info(1).id, id);
app.layout.undo();
assert_eq!(app.layout.layer_info(1).name, "Presenter");
app.manage_layers();
app.layer_ui.drafts[1].1 = "Discarded".into();
app.layer_ui.closing = true;
super::super::tests::click_text(&mut app, &ctx, "Discard");
assert!(!app.layer_ui.open);
assert_eq!(app.layout.layer_info(1).name, "Presenter");
}
#[test]
fn inspector_sections_follow_the_variable_layer_list() {
let ctx = egui::Context::default();
let mut app = Editor::default();
for _ in 0..3 {
app.layout.add_layer().unwrap();
}
app.sync();
super::super::tests::frame(&mut app, &ctx, vec![]);
let frame = super::super::tests::frame(&mut app, &ctx, vec![]);
let y = |label: &str| {
frame
.shapes
.iter()
.find_map(|s| match &s.shape {
egui::Shape::Text(t) if t.galley.text() == label => Some(t.pos.y),
_ => None,
})
.unwrap()
};
assert!(y("MEASURE POSITION FROM") > y("Adjust layer crop") + 60.0);
}
#[test]
fn many_layer_inspector_and_manager_render_after_history_changes() {
let ctx = egui::Context::default();
let mut app = Editor::default();
for _ in 0..4 {
app.add_layer();
}
let id = app.layout.layer_info(5).id;
app.layout.rename_layer(5, "Camera", "Video").unwrap();
app.manage_layers();
super::super::tests::frame(&mut app, &ctx, vec![]);
app.remove_layers();
app.layout.undo();
app.sync();
super::super::tests::frame(&mut app, &ctx, vec![]);
assert_eq!(app.layout.layer_info(5).id, id);
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]);
}
#[test]
fn folder_selection_changes_midra_scope_only_in_folder_mode() {
for scope in [
device_ui::TransferScope::All,
device_ui::TransferScope::Selected,
device_ui::TransferScope::Folder("Previous".into()),
] {
let mut app = Editor::default();
let ctx = egui::Context::default();
app.layout.assign_folder(&[1, 2], "Talk").unwrap();
app.device.scope = scope.clone();
click_tree(&mut app, &ctx, egui::Id::new(("folder", "Talk")));
assert_eq!(
app.device.scope,
if matches!(scope, device_ui::TransferScope::Folder(_)) {
device_ui::TransferScope::Folder("Talk".into())
} else {
scope
}
);
assert_eq!(app.layout.selected_indices(), vec![0, 1]);
assert!(!app.device.sending);
}
}
}