d84914ef1e5a
named_layouts.rs
//! Window > Layouts: panel arrangements saved under a name and switched from the menu.
//!
//! A named layout holds the painting and the baking dock (which panels are shown, where, and
//! how big). Switching to one touches nothing else: not the mode, the zoom, the wireframes, the
//! windows or the shelf. The layouts persist with `UiState`, so they work in the browser too.
use crate::TextureCraftApp;
use crate::i18n::{tr, trf};
pub use crate::layout_dialog::LayoutDialog;
pub use crate::name_error::NameError;
pub use crate::named_layout::NamedLayout;
use crate::state::UiState;
use crate::theme::caption;
use crate::windows::dialog;
impl UiState {
fn named_layout_index(&self, name: &str) -> Option<usize> {
self.named_layouts.iter().position(|layout| layout.name == name)
}
/// Whether a layout of this name (surrounding spaces ignored) is saved
pub fn has_named_layout(&self, name: &str) -> bool {
self.named_layout_index(name.trim()).is_some()
}
/// Save the current panel arrangement under `name`, replacing a layout of that name; false for an empty name
pub fn save_named_layout(&mut self, name: &str) -> bool {
let name = name.trim();
if name.is_empty() {
return false;
}
let (painting, baking) = if self.dock_is_baking { (&self.inactive_mode_dock, &self.dock) } else { (&self.dock, &self.inactive_mode_dock) };
let layout = NamedLayout { name: name.to_string(), painting: painting.clone(), baking: baking.clone() };
match self.named_layout_index(name) {
Some(index) => self.named_layouts[index] = layout,
None => self.named_layouts.push(layout),
}
true
}
/// Switch to the saved layout's panels; the mode and every other setting stay. False when there is none of that name.
pub fn apply_named_layout(&mut self, name: &str) -> bool {
let Some(layout) = self.named_layout_index(name).map(|index| self.named_layouts[index].clone()) else { return false };
let (current, other) = if self.dock_is_baking { (layout.baking, layout.painting) } else { (layout.painting, layout.baking) };
self.dock = current;
self.inactive_mode_dock = other;
// A popup open against the rail shows a panel of the old arrangement
self.rail_panel = None;
true
}
/// Give a saved layout another name
pub fn rename_named_layout(&mut self, from: &str, to: &str) -> Result<(), NameError> {
let to = to.trim();
if to.is_empty() {
return Err(NameError::Empty);
}
if to != from && self.named_layout_index(to).is_some() {
return Err(NameError::Taken);
}
if let Some(index) = self.named_layout_index(from) {
self.named_layouts[index].name = to.to_string();
}
Ok(())
}
pub fn delete_named_layout(&mut self, name: &str) {
self.named_layouts.retain(|layout| layout.name != name);
}
}
/// One entry per saved layout, under the catalog's items of the Layouts submenu
pub(crate) fn entries(app: &mut TextureCraftApp, ui: &mut egui::Ui) {
if app.ui.named_layouts.is_empty() {
return;
}
ui.separator();
for name in app.ui.named_layouts.iter().map(|layout| layout.name.clone()).collect::<Vec<_>>() {
if ui.button(&name).clicked() {
app.ui.apply_named_layout(&name);
ui.close();
}
}
}
/// The save, overwrite and manage dialogs
pub(crate) fn show(app: &mut TextureCraftApp, ctx: &egui::Context) {
forget_finished_focus(app, ctx);
let Some(shown) = app.ui.layout_dialog.clone() else { return };
let mut open = true;
let next = match shown {
LayoutDialog::Save(name) => save_dialog(app, ctx, &mut open, name),
LayoutDialog::Overwrite(name) => overwrite_dialog(app, ctx, &mut open, name),
LayoutDialog::Manage { renaming, deleting } => manage_dialog(app, ctx, &mut open, renaming, deleting),
};
app.ui.layout_dialog = if open { next } else { None };
forget_finished_focus(app, ctx);
}
/// The next Save or rename focuses its field again. Also runs while no dialog is shown, since
/// loading or resetting the layout closes a dialog from outside.
fn forget_finished_focus(app: &TextureCraftApp, ctx: &egui::Context) {
ctx.data_mut(|data| {
if !matches!(app.ui.layout_dialog, Some(LayoutDialog::Save(_))) {
data.remove_temp::<String>(egui::Id::unique(SAVE_FOCUS));
}
if !matches!(app.ui.layout_dialog, Some(LayoutDialog::Manage { renaming: Some(_), .. })) {
data.remove_temp::<String>(egui::Id::unique(RENAME_FOCUS));
}
});
}
/// How much of the window height the list of saved layouts may take
const LIST_SCREEN_FRACTION: f32 = 0.5;
/// Memory keys of the text fields that were already focused for the current edit
const SAVE_FOCUS: &str = "named_layout_save_focused";
const RENAME_FOCUS: &str = "named_layout_rename_focused";
/// Give `edit` the keyboard once per edit (`what` names it), when it starts. Asking every frame
/// would take the focus back from the buttons after Tab.
fn focus_once(ui: &egui::Ui, edit: &egui::Response, key: &'static str, what: String) {
let id = egui::Id::unique(key);
if ui.data(|data| data.get_temp::<String>(id)).as_deref() != Some(what.as_str()) {
edit.request_focus();
ui.data_mut(|data| data.insert_temp(id, what));
}
}
fn save_dialog(app: &mut TextureCraftApp, ctx: &egui::Context, open: &mut bool, mut name: String) -> Option<LayoutDialog> {
let mut done = None;
dialog("save_layout", tr("Save layout"), open).show(ctx, |ui| {
ui.label(tr("Name of the layout"));
let edit = ui.add(egui::TextEdit::singleline(&mut name).desired_width(240.0));
focus_once(ui, &edit, SAVE_FOCUS, String::new());
let enter = edit.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));
ui.add_space(8.0);
ui.horizontal(|ui| {
let valid = !name.trim().is_empty();
if ui.add_enabled(valid, egui::Button::new(tr("Save"))).clicked() || (enter && valid) {
done = Some(true);
}
if ui.button(tr("Cancel")).clicked() {
done = Some(false);
}
});
});
match done {
Some(true) if app.ui.has_named_layout(&name) => Some(LayoutDialog::Overwrite(name.trim().to_string())),
Some(true) => {
app.ui.save_named_layout(&name);
app.toast(trf("Saved layout {name}", &[("name", &name.trim())]), false);
None
}
Some(false) => None,
None => Some(LayoutDialog::Save(name)),
}
}
fn overwrite_dialog(app: &mut TextureCraftApp, ctx: &egui::Context, open: &mut bool, name: String) -> Option<LayoutDialog> {
let mut answer = None;
dialog("overwrite_layout", tr("Replace layout"), open).show(ctx, |ui| {
ui.label(trf("A layout named {name} already exists. Replace it?", &[("name", &name)]));
ui.add_space(8.0);
ui.horizontal(|ui| {
if ui.button(tr("Replace")).clicked() {
answer = Some(true);
}
if ui.button(tr("Cancel")).clicked() {
answer = Some(false);
}
});
});
match answer {
Some(true) => {
app.ui.save_named_layout(&name);
app.toast(trf("Saved layout {name}", &[("name", &name)]), false);
None
}
Some(false) => None,
None => Some(LayoutDialog::Overwrite(name)),
}
}
fn manage_dialog(
app: &mut TextureCraftApp,
ctx: &egui::Context,
open: &mut bool,
mut renaming: Option<(String, String)>,
mut deleting: Option<String>,
) -> Option<LayoutDialog> {
let mut finished = false;
dialog("manage_layouts", tr("Manage layouts"), open).show(ctx, |ui| {
ui.set_min_width(320.0);
if let Some(name) = deleting.clone() {
ui.label(trf("Delete the layout {name}?", &[("name", &name)]));
ui.add_space(8.0);
ui.horizontal(|ui| {
if ui.button(tr("Delete")).clicked() {
app.ui.delete_named_layout(&name);
deleting = None;
}
if ui.button(tr("Cancel")).clicked() {
deleting = None;
}
});
return;
}
if app.ui.named_layouts.is_empty() {
ui.label(caption(tr("No saved layouts")));
}
// Many layouts scroll; Close stays below the list
let list_height = ui.ctx().content_rect().height() * LIST_SCREEN_FRACTION;
egui::ScrollArea::vertical().max_height(list_height).auto_shrink([false, true]).show(ui, |ui| {
for name in app.ui.named_layouts.iter().map(|layout| layout.name.clone()).collect::<Vec<_>>() {
ui.horizontal(|ui| match renaming.clone().filter(|(from, _)| *from == name) {
Some((from, mut to)) => {
let edit = ui.add(egui::TextEdit::singleline(&mut to).desired_width(180.0));
focus_once(ui, &edit, RENAME_FOCUS, from.clone());
let taken = app.ui.named_layouts.iter().any(|layout| layout.name == to.trim() && layout.name != from);
let valid = !to.trim().is_empty() && !taken;
let enter = edit.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));
let mut keep = true;
if ui.add_enabled(valid, egui::Button::new(tr("Rename"))).clicked() || (enter && valid) {
let _ = app.ui.rename_named_layout(&from, &to);
keep = false;
}
if ui.button(tr("Cancel")).clicked() {
keep = false;
}
if taken {
ui.label(caption(tr("That name is taken")));
}
renaming = keep.then_some((from, to));
}
None => {
ui.label(&name);
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if ui.button(tr("Delete")).clicked() {
deleting = Some(name.clone());
}
if ui.button(tr("Rename")).clicked() {
renaming = Some((name.clone(), name.clone()));
}
});
}
});
}
});
ui.add_space(8.0);
if ui.button(tr("Close")).clicked() {
finished = true;
}
});
(!finished).then_some(LayoutDialog::Manage { renaming, deleting })
}
#[cfg(test)]
mod tests {
use super::*;
use crate::docking::Panel;
use crate::state::{Mode, ViewLayout};
fn closed(panel: Panel) -> UiState {
let mut ui = UiState::default();
ui.dock.close(panel);
ui
}
#[test]
fn switching_restores_the_panels_and_keeps_zoom_mode_and_wireframes() {
let mut ui = closed(Panel::Assets);
assert!(ui.save_named_layout("Sparse"));
ui.dock.focus(Panel::Assets);
ui.dock.close(Panel::Layers);
ui.uv_zoom = 3.0;
ui.uv_pan = [0.25, 0.5];
ui.uv_wireframe = false;
ui.wireframe_3d = true;
ui.layout = ViewLayout::Only3D;
ui.split_ratio = 0.2;
ui.shelf_filter = "rust".into();
let before = ui.clone();
assert!(ui.apply_named_layout("Sparse"));
assert!(!ui.dock.is_open(Panel::Assets) && ui.dock.is_open(Panel::Layers));
let expected = UiState { dock: ui.dock.clone(), inactive_mode_dock: ui.inactive_mode_dock.clone(), ..before };
assert_eq!(ui, expected, "only the docks changed");
}
#[test]
fn both_mode_docks_are_saved_and_the_current_mode_stays() {
let mut ui = UiState::default();
ui.dock.close(Panel::Assets);
ui.save_named_layout("Both");
// Saved while painting, applied while baking: each dock lands in its own slot
let mut baking = UiState { mode: Mode::Baking, dock_is_baking: true, ..UiState::default() };
baking.inactive_mode_dock = UiState::default().dock;
baking.named_layouts = ui.named_layouts.clone();
baking.apply_named_layout("Both");
assert_eq!(baking.mode, Mode::Baking);
assert!(baking.dock_is_baking);
assert!(baking.dock.is_open(Panel::MeshMapBakers) && !baking.dock.is_open(Panel::Layers), "the baking dock is the saved baking dock");
assert!(
baking.inactive_mode_dock.is_open(Panel::Layers) && !baking.inactive_mode_dock.is_open(Panel::Assets),
"the painting dock is the saved painting dock"
);
}
#[test]
fn saving_under_a_taken_name_replaces_it_and_an_empty_name_saves_nothing() {
let mut ui = UiState::default();
assert!(!ui.save_named_layout(" "));
ui.save_named_layout(" Mine ");
ui.dock.close(Panel::Assets);
ui.save_named_layout("Mine");
assert_eq!(ui.named_layouts.len(), 1);
assert_eq!(ui.named_layouts[0].name, "Mine");
assert!(!ui.named_layouts[0].painting.is_open(Panel::Assets));
assert!(ui.has_named_layout("Mine ") && !ui.apply_named_layout("Other"));
}
#[test]
fn rename_and_delete() {
let mut ui = UiState::default();
ui.save_named_layout("A");
ui.save_named_layout("B");
assert_eq!(ui.rename_named_layout("A", "B"), Err(NameError::Taken));
assert_eq!(ui.rename_named_layout("A", " "), Err(NameError::Empty));
assert_eq!(ui.rename_named_layout("A", "A"), Ok(()));
assert_eq!(ui.rename_named_layout("A", " C "), Ok(()));
let names: Vec<_> = ui.named_layouts.iter().map(|layout| layout.name.as_str()).collect();
assert_eq!(names, ["C", "B"], "a renamed layout keeps its place");
ui.delete_named_layout("C");
assert_eq!(ui.named_layouts.len(), 1);
assert!(!ui.apply_named_layout("C"));
}
#[test]
fn named_layouts_persist_and_older_saved_state_loads_without_them() {
let mut ui = closed(Panel::Assets);
ui.save_named_layout("Sparse");
let back: UiState = serde_json::from_str(&serde_json::to_string(&ui).unwrap()).unwrap();
assert_eq!(back.named_layouts, ui.named_layouts);
let mut old = serde_json::to_value(UiState::default()).unwrap();
assert!(old.as_object_mut().unwrap().remove("named_layouts").is_some());
let loaded: UiState = serde_json::from_value(old).unwrap();
assert!(loaded.named_layouts.is_empty());
}
#[test]
fn reset_and_loading_a_layout_file_keep_the_named_layouts() {
let mut ui = UiState::default();
ui.save_named_layout("Mine");
ui.adopt_layout(UiState::default());
assert!(ui.has_named_layout("Mine"));
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.