aleleba/lightcraft
1
0
Fork 0
mirror of https://github.com/storytold/lightcraft.git synced 2026-11-01 05:57:09 -06:00
Code Issues Packages Projects Releases Wiki Activity
Files
052d95cd661a656529fe2389b9c7a24bca9df026
lightcraft/crates/ui-egui/src/docking.rs
T

824 lines
38 KiB
Rust
Raw Blame History

//! Application panel identities and persistence around the shared docking renderer.
//! Document contents remain owned by their existing view implementations.
use craft_ui::docking::{
Action, Column, ColumnLocation, DockArea, DockCommand, DockError, DockOperation, DockStyle, FloatSpace, Group, GroupLocation, Layout, Location,
Node, PanelLimits, PanelState, Permissions, Placement, Side, UiDock, Zone,
};
use craft_ui::layout::{SplitAxis, SplitSize};
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum Panel {
Canvas,
Library,
Tools,
Presets,
}
impl Panel {
pub const ALL: &[Self] = &[Self::Canvas, Self::Library, Self::Tools, Self::Presets];
pub fn id(self) -> &'static str {
match self {
Self::Canvas => "canvas",
Self::Library => "library",
Self::Tools => "tools",
Self::Presets => "presets",
}
}
fn label(self) -> &'static str {
match self {
Self::Canvas => "Photos",
Self::Library => "Library",
Self::Tools => "Tools",
Self::Presets => "Presets",
}
}
/// The dock the panel opens in when it has no recorded place.
fn home_side(self) -> Side {
if self == Self::Library { Side::Start } else { Side::End }
}
/// The width of the panel's own column in the default workspace.
fn home_width(self) -> f32 {
match self {
Self::Canvas => crate::state::MIN_PHOTO_WIDTH,
Self::Library => crate::state::LEFT_WIDTH.default,
Self::Tools => crate::state::RIGHT_WIDTH.default,
Self::Presets => PRESETS_WIDTH,
}
}
}
const PRESETS_WIDTH: f32 = 300.0;
/// The arrangement generation saved as `UiState::docking_version`. Settings without it hold the
/// side panels in split frames; they start again from [`default_workspace`].
pub const DOCKING_VERSION: u32 = 1;
/// Drops saved settings' arrangement from before [`DOCKING_VERSION`], with the places of its
/// closed panels, so the app starts from the default workspace; every other setting stays.
/// Returns true when an arrangement was dropped.
pub fn drop_outdated(settings: &mut serde_json::Map<String, Value>) -> bool {
if settings.get("dockingVersion").and_then(Value::as_u64).is_some_and(|version| version >= u64::from(DOCKING_VERSION)) {
return false;
}
settings.insert("dockingVersion".into(), json!(DOCKING_VERSION));
settings.remove("docking").is_some_and(|docking| !docking.is_null())
}
fn permissions(panel: &Panel) -> Permissions {
// Panels open and split beside the photo view, but never join it as tabs.
if *panel == Panel::Canvas { Permissions { accepts_splits: true, ..Permissions::PROTECTED } } else { Permissions::default() }
}
fn tabs(panel: Panel) -> Node<Panel> {
Node::Tabs { panels: vec![panel], active: 0 }
}
fn split(axis: SplitAxis, size: SplitSize, first: Node<Panel>, second: Node<Panel>) -> Node<Panel> {
Node::Split { axis, size, first: Box::new(first), second: Box::new(second) }
}
/// The saved arrangement. Closed panels keep their last group, side, size or floating rect.
pub type Workspace = craft_ui::docking::Workspace<Panel>;
fn column(panel: Panel, width: f32) -> Column<Panel> {
Column::new(vec![Group::new(vec![panel], 0)], width)
}
/// Library in a start dock and Tools in an end dock beside the photo. Presets has a column of
/// its own on Tools' photo side rather than a group under Tools: both are tall lists that are
/// read side by side while trying presets, and stacking them would halve both.
fn docked(left: f32, right: f32) -> Workspace {
let start = Node::Dock { side: Side::Start, columns: vec![column(Panel::Library, left)] };
let end = Node::Dock { side: Side::End, columns: vec![column(Panel::Tools, right), column(Panel::Presets, PRESETS_WIDTH)] };
Workspace::new(Layout {
root: Some(split(
SplitAxis::Horizontal,
SplitSize::FixedFirst(left),
start,
split(SplitAxis::Horizontal, SplitSize::FixedSecond(right + PRESETS_WIDTH), tabs(Panel::Canvas), end),
)),
floating: Vec::new(),
})
}
pub fn default_workspace() -> Workspace {
docked(crate::state::LEFT_WIDTH.default, crate::state::RIGHT_WIDTH.default)
}
/// Where a panel without a usable recorded place opens: its own column at its dock's window
/// edge, or Presets on the photo side of Tools while Tools is in the end dock.
fn home(workspace: &Workspace, panel: Panel) -> Location<Panel> {
let column = ColumnLocation { side: panel.home_side(), width: panel.home_width(), iconic: false, iconic_width: None };
let docked_at =
|other: Panel| workspace.layout.location(&other).ok().and_then(|location| location.group).and_then(|group| group.column).map(|c| c.side);
let beside = (panel == Panel::Presets && docked_at(Panel::Tools) == Some(Side::End)).then_some(Panel::Tools);
Location {
floating: None,
anchor: beside,
placement: if beside.is_some() { Placement::Column { after: true } } else { Placement::Tab { before: None } },
size: None,
stack: None,
sibling: Vec::new(),
group: Some(GroupLocation { minimized: false, height: None, column: Some(column) }),
}
}
fn error(error: DockError) -> String {
error.to_string()
}
/// The shared checks plus LightCraft's own: saved settings cannot float, hide, share or
/// collapse the photo view, nor send a hidden panel back onto it.
pub fn validate(workspace: &Workspace) -> Result<(), String> {
workspace.validate().map_err(error)?;
let mut nodes: Vec<_> = workspace.layout.root.iter().collect();
let mut alone = false;
while let Some(node) = nodes.pop() {
match node {
Node::Split { first, second, .. } => {
nodes.push(first);
nodes.push(second);
}
Node::Tabs { panels, .. } => alone |= panels.as_slice() == [Panel::Canvas],
_ => {}
}
}
if !alone {
return Err("The document view must stay docked in a group of its own".into());
}
if workspace.hidden.iter().any(|(_, location)| {
location.anchor == Some(Panel::Canvas) && matches!(location.placement, Placement::Tab { .. } | Placement::Split(Zone::Center))
}) {
return Err("A hidden panel cannot restore over the document view".into());
}
Ok(())
}
fn apply(workspace: &mut Workspace, action: Action<Panel>) -> Result<(), String> {
let mut next = workspace.clone();
next.apply(action, permissions).map_err(error)?;
validate(&next)?;
*workspace = next;
Ok(())
}
/// Shows a panel at its recorded place, else in its dock column ([`home`]). A panel that
/// already has the asked visibility keeps its tab selection.
fn set_visible(workspace: &mut Workspace, panel: Panel, visible: bool) -> Result<(), String> {
if workspace.layout.contains(&panel) == visible {
return Ok(());
}
if !visible {
return apply(workspace, Action::Close { panel });
}
validate(workspace)?;
// A recorded place that can't be rebuilt falls back to joining the fallback's tabs. The
// photo view takes no tabs, so that is refused and the panel goes to its home column below.
if workspace.hidden.iter().any(|(hidden, _)| *hidden == panel) {
let mut next = workspace.clone();
if next.set_visible(panel, true, Some(Panel::Canvas), permissions).is_ok() && validate(&next).is_ok() {
*workspace = next;
return Ok(());
}
}
let mut next = workspace.clone();
next.hidden.retain(|(hidden, _)| *hidden != panel);
let location = home(&next, panel);
next.hidden.push((panel, location));
next.set_visible(panel, true, Some(Panel::Canvas), permissions).map_err(error)?;
validate(&next)?;
*workspace = next;
Ok(())
}
/// Membership is passive state; an explicit command also exposes the panel's body.
fn reveal(workspace: &mut Workspace, panel: Panel) -> Result<(), String> {
set_visible(workspace, panel, true)?;
apply(workspace, Action::Activate { panel })?;
if workspace.layout.panel_state(&panel) != PanelState::Front {
// A minimized window or group opens again; where nothing is minimized the action is
// refused and the layout stays as it is.
let _ = apply(workspace, Action::SetMinimized { panel, minimized: false });
}
Ok(())
}
pub fn exposed_in(workspace: &Workspace, panel: Panel) -> bool {
workspace.layout.panel_state(&panel) == PanelState::Front
}
/// `ui.dock` params, parsed by the shared command vocabulary.
fn run(workspace: &mut Workspace, params: &Value) -> Result<(), String> {
validate(workspace)?;
let mut tagged = params.clone();
let fields = tagged.as_object_mut().ok_or("ui.dock params must be an object")?;
fields.insert("command".into(), json!("ui.dock"));
let command: DockCommand<Panel> = serde_json::from_value(tagged).map_err(|error| error.to_string())?;
if let DockCommand::UiDock(UiDock::Operation(DockOperation::Open { panel })) = command {
return reveal(workspace, panel);
}
let mut next = workspace.clone();
// `ui.dock` operations carry their own rects; only `window.panel.float` reads the space.
command.apply(&mut next, false, &FloatSpace::new(egui::Rect::ZERO), permissions).map_err(error)?;
validate(&next)?;
*workspace = next;
Ok(())
}
fn from_ui(app: &crate::LightcraftApp) -> Workspace {
docked(crate::state::LEFT_WIDTH.clamp(app.ui.left_width), crate::state::RIGHT_WIDTH.clamp(app.ui.right_width))
}
fn sync(workspace: &mut Workspace, app: &crate::LightcraftApp) -> Result<(), String> {
set_visible(workspace, Panel::Library, app.ui.left_panel)?;
set_visible(workspace, Panel::Tools, app.ui.right != crate::state::RightPanel::None)?;
set_visible(workspace, Panel::Presets, app.ui.presets)
}
fn publish_visibility(app: &mut crate::LightcraftApp, workspace: &Workspace) {
app.ui.left_panel = workspace.layout.contains(&Panel::Library);
app.ui.presets = workspace.layout.contains(&Panel::Presets);
if !workspace.layout.contains(&Panel::Tools) {
app.ui.right = crate::state::RightPanel::None;
} else if app.ui.right == crate::state::RightPanel::None {
app.ui.right = crate::state::RightPanel::Edit;
}
for (panel, width, limits) in
[(Panel::Library, &mut app.ui.left_width, crate::state::LEFT_WIDTH), (Panel::Tools, &mut app.ui.right_width, crate::state::RIGHT_WIDTH)]
{
let Ok(location) = workspace.layout.location(&panel) else {
continue;
};
let column = location.group.and_then(|group| group.column);
let value = match (location.floating, column, location.placement, location.size) {
(Some([_, _, width, _]), ..) => Some(width),
(None, Some(column), ..) => Some(column.width),
(None, None, Placement::Split(Zone::Left), Some(SplitSize::FixedFirst(width)))
| (None, None, Placement::Split(Zone::Right), Some(SplitSize::FixedSecond(width))) => Some(width),
// A vertical split stores height, and the opposite fixed side sizes a sibling.
_ => None,
};
if let Some(value) = value {
*width = limits.clamp(value);
}
}
}
pub(crate) fn exposed(app: &crate::LightcraftApp, panel: Panel) -> bool {
app.ui.docking.as_ref().is_none_or(|workspace| exposed_in(workspace, panel))
}
pub(crate) fn reveal_command(app: &mut crate::LightcraftApp, id: &str) -> Result<(), String> {
let panel = if id == "panel.presets" && app.ui.presets {
Some(Panel::Presets)
} else if id == "app.showInFolders" {
// the sidebar it scrolls, also when it is a tab behind another panel
Some(Panel::Library)
} else if (id.starts_with("panel.") && id != "panel.close" && id != "panel.presets"
|| id == "view.rightPanel"
|| id.starts_with("section.")
|| id.starts_with("tool.") && id != "tool.none")
&& app.ui.right != crate::state::RightPanel::None
{
Some(Panel::Tools)
} else {
None
};
if let Some(panel) = panel {
let mut workspace = app.ui.docking.clone().unwrap_or_else(|| from_ui(app));
sync(&mut workspace, app)?;
reveal(&mut workspace, panel)?;
cancel_replaced_gesture(app, Some(&workspace));
app.ui.docking = Some(workspace);
}
Ok(())
}
/// Check the target's actual egui layer even while a different widget owns the drag.
pub(crate) fn drop_target(ui: &egui::Ui, rect: egui::Rect, pointer: Option<egui::Pos2>) -> bool {
pointer.is_some_and(|pos| rect.intersect(ui.clip_rect()).contains(pos) && ui.ctx().layer_id_at(pos) == Some(ui.layer_id()))
}
/// Explicit host commands replace the snapshot before rendering. Cancel only their old
/// gestures; actions returned by the renderer must keep continuous resizing alive.
pub(crate) fn cancel_replaced_gesture(app: &crate::LightcraftApp, workspace: Option<&Workspace>) {
let replaced = match (app.ui.docking.as_ref(), workspace) {
(Some(old), Some(next)) => old.layout != next.layout || old.hidden != next.hidden,
(None, None) => false,
_ => true,
};
if replaced && let Some(ctx) = &app.tasks.repaint {
craft_ui::docking::cancel_drag::<Panel>(ctx, egui::Id::unique("lightcraft-docking"));
}
}
pub fn command(app: &mut crate::LightcraftApp, reset: bool, params: &Value) -> Result<Value, String> {
command_impl(app, reset, params, false)
}
fn command_impl(app: &mut crate::LightcraftApp, reset: bool, params: &Value, renderer_action: bool) -> Result<Value, String> {
let mut workspace = app.ui.docking.clone().unwrap_or_else(|| from_ui(app));
if reset {
workspace = default_workspace();
// The usual LightCraft starting workspace shows its current tool beside the photo.
set_visible(&mut workspace, Panel::Library, false)?;
set_visible(&mut workspace, Panel::Presets, false)?;
} else {
sync(&mut workspace, app)?;
run(&mut workspace, params)?;
}
if !renderer_action {
cancel_replaced_gesture(app, Some(&workspace));
}
publish_visibility(app, &workspace);
app.ui.docking = Some(workspace);
Ok(json!({"docking": app.ui.docking}))
}
/// Draw the docked workspace: restore or fall back from an invalid layout, sync panel
/// visibility, render the panels and the current view in the canvas, then apply the docking
/// actions. If the layout changed during the pass, any in-flight dock drag is cancelled and the
/// docking actions it produced are not applied.
pub fn show(app: &mut crate::LightcraftApp, ui: &mut egui::Ui) {
let t = crate::theme::Tokens::get(ui.ctx());
let mut workspace = app.ui.docking.clone().unwrap_or_else(|| from_ui(app));
if let Err(error) = validate(&workspace).and_then(|()| sync(&mut workspace, app)) {
app.ui.toast = Some((format!("Panel layout could not be restored: {error}"), app.tick_now() + 8.0, None));
workspace = from_ui(app);
let _ = sync(&mut workspace, app);
}
// Legacy visibility commands may replace the layout before this render starts.
cancel_replaced_gesture(app, Some(&workspace));
// Tool/Canvas callbacks dispatch app commands and must see the real workspace.
app.ui.docking = Some(workspace.clone());
let mut style = DockStyle::from_ui(ui);
style.min_pane = 96.0;
// Free docking: a panel dropped at an empty window edge makes a dock, and the photo takes
// drops on all four sides.
style.new_dock_zones = true;
style.side_edge_zones = false;
style.float_label = crate::i18n::tr("Float panel").into();
style.close_label = crate::i18n::tr("Close panel").into();
style.move_panel_to_label = crate::i18n::tr("Move to group").into();
style.panels_label = crate::i18n::tr("Panels").into();
style.resize_label = crate::i18n::tr("Resize panels").into();
style.resize_window_label = crate::i18n::tr("Resize panel window").into();
style.move_group_label = crate::i18n::tr("Move tab group").into();
style.move_group_to_label = crate::i18n::tr("Move group to").into();
style.float_group_label = crate::i18n::tr("Float tab group").into();
style.close_group_label = crate::i18n::tr("Close tab group").into();
style.close_others_label = crate::i18n::tr("Close other panels in group").into();
style.minimize_label = crate::i18n::tr("Minimize").into();
style.expand_label = crate::i18n::tr("Expand").into();
style.move_column_label = crate::i18n::tr("Move panel column").into();
style.collapse_to_icons_label = crate::i18n::tr("Collapse to Icons").into();
style.expand_panels_label = crate::i18n::tr("Expand Panels").into();
style.collapse_column_label = crate::i18n::tr("Collapse column").into();
style.expand_column_label = crate::i18n::tr("Expand column").into();
style.auto_collapse_label = crate::i18n::tr("Auto-Collapse Iconic Panels").into();
style.move_window_label = crate::i18n::tr("Move panel window").into();
style.close_window_label = crate::i18n::tr("Close panel window").into();
style.float_hint_label = crate::i18n::tr("Hold {key} to undock").into();
style.background = t.chrome;
style.tab_background = t.chrome;
style.active_background = t.canvas;
style.text = t.text;
style.inactive_text = t.text_dim;
style.border = egui::Stroke::new(1.0, t.divider);
style.accent = t.accent;
style.font = t.font(12.0);
// Tool and preset panels publish hover previews before the photo consumes them.
let mut canvas = None;
let output = DockArea::new(egui::Id::unique("lightcraft-docking")).locked(workspace.locked).show_with_limits(
ui,
&workspace.layout,
&style,
|panel| crate::i18n::tr(panel.label()).into(),
permissions,
panel_limits,
|ui, panel| match panel {
Panel::Canvas => {
canvas = Some(ui.new_child(egui::UiBuilder::new().id_salt("photo-view").max_rect(ui.max_rect())));
}
Panel::Library => {
crate::widgets::register(ui, "panel:left_panel", ui.max_rect());
crate::panels::left::show(app, ui);
}
Panel::Tools => {
crate::widgets::register(ui, "panel:right_panel", ui.max_rect());
crate::panels::right::show(app, ui);
}
Panel::Presets => crate::panels::presets::show(app, ui),
},
);
if let Some(mut canvas) = canvas {
let ui = &mut canvas;
crate::panels::bottombar::show(app, ui);
let bg = if matches!(
app.ui.view,
crate::state::ViewMode::Detail | crate::state::ViewMode::Compare | crate::state::ViewMode::Survey | crate::state::ViewMode::Reference
) {
t.canvas
} else {
t.grid_bg
};
crate::panels::compare::prepare(app);
egui::CentralPanel::default().frame(egui::Frame::NONE.fill(bg)).show(ui, |ui| match app.ui.view {
crate::state::ViewMode::PhotoGrid | crate::state::ViewMode::SquareGrid => crate::panels::grid::show(app, ui),
crate::state::ViewMode::Detail => crate::panels::detail::show(app, ui),
crate::state::ViewMode::Compare => crate::panels::compare::show_compare(app, ui),
crate::state::ViewMode::Survey => crate::panels::compare::show_survey(app, ui),
crate::state::ViewMode::Reference => crate::panels::compare::show_reference(app, ui),
crate::state::ViewMode::People => crate::panels::people::show(app, ui),
});
}
let rendered = workspace;
let mut workspace = app.ui.docking.clone().unwrap_or_else(|| from_ui(app));
let _ = sync(&mut workspace, app);
let stale = workspace.layout != rendered.layout || workspace.hidden != rendered.hidden;
if stale {
craft_ui::docking::cancel_drag::<Panel>(ui.ctx(), egui::Id::unique("lightcraft-docking"));
}
publish_visibility(app, &workspace);
app.ui.docking = Some(workspace);
if stale {
return;
}
for action in output.actions {
if let Err(error) = serde_json::to_value(action)
.map_err(|error| error.to_string())
.and_then(|action| command_impl(app, false, &json!({"action": action}), true))
{
app.ui.toast = Some((format!("Panel move was not applied: {error}"), app.tick_now() + 8.0, None));
}
}
}
/// Keep the established ui.set width controls connected to the panel's dock column, floating
/// window or parent split.
pub(crate) fn set_widths(state: &mut crate::UiState, params: &Value) -> Result<(), String> {
state.left_width = crate::state::LEFT_WIDTH.clamp(state.left_width);
state.right_width = crate::state::RIGHT_WIDTH.clamp(state.right_width);
let Some(workspace) = state.docking.as_mut() else {
return Ok(());
};
validate(workspace)?;
for (key, panel, width) in [("leftWidth", Panel::Library, state.left_width), ("rightWidth", Panel::Tools, state.right_width)] {
if params.get(key).is_none() {
continue;
}
if let Some((_, location)) = workspace.hidden.iter_mut().find(|(id, _)| *id == panel) {
if let Some(rect) = &mut location.floating {
rect[2] = width;
}
if let Some(column) = location.group.as_mut().and_then(|group| group.column.as_mut()) {
column.width = width;
continue;
}
match location.placement {
Placement::Split(Zone::Left) => location.size = Some(SplitSize::FixedFirst(width)),
Placement::Split(Zone::Right) => location.size = Some(SplitSize::FixedSecond(width)),
_ => {} // Width controls do not rewrite a saved vertical split's height.
}
continue;
}
if let Some(group) = workspace.layout.floating.iter().find(|group| group.contains(&panel)) {
let mut rect = group.rect;
rect[2] = width;
apply(workspace, Action::MoveFloating { panel, rect })?;
continue;
}
if workspace.layout.location(&panel).is_ok_and(|location| location.group.is_some_and(|group| group.column.is_some())) {
apply(workspace, Action::ResizeColumn { panel, width })?;
continue;
}
let mut nodes = workspace.layout.root.as_ref().map(|node| vec![(node, Vec::new())]).unwrap_or_default();
let mut change = None;
while let Some((node, path)) = nodes.pop() {
if let Node::Split { axis, first, second, .. } = node {
let contains = |node: &Node<Panel>| match node {
Node::Tabs { panels, .. } => panels.contains(&panel),
Node::Stack { entries } => entries.iter().any(|entry| entry.panel == panel),
_ => false,
};
if *axis == SplitAxis::Horizontal {
if contains(first) {
change = Some(Action::ResizeSplit { path: path.clone(), size: SplitSize::FixedFirst(width) });
}
if contains(second) {
change = Some(Action::ResizeSplit { path: path.clone(), size: SplitSize::FixedSecond(width) });
}
}
let mut second_path = path.clone();
second_path.push(true);
let mut first_path = path;
first_path.push(false);
nodes.push((second, second_path));
nodes.push((first, first_path));
}
}
if let Some(action) = change {
apply(workspace, action)?;
}
}
Ok(())
}
fn panel_limits(panel: &Panel) -> PanelLimits {
let (min, max_width) = match panel {
Panel::Canvas => (egui::vec2(crate::state::MIN_PHOTO_WIDTH, 160.0), 1_000_000.0),
Panel::Library => (egui::vec2(crate::state::LEFT_WIDTH.min, 120.0), crate::state::LEFT_WIDTH.max),
Panel::Tools => (egui::vec2(crate::state::RIGHT_WIDTH.min, 120.0), crate::state::RIGHT_WIDTH.max),
Panel::Presets => (egui::vec2(250.0, 120.0), 520.0),
};
PanelLimits { min, max: egui::vec2(max_width, 1_000_000.0) }
}
/// The columns of the dock on `side`, from the window edge inwards: width and the panels of
/// each group.
#[cfg(test)]
pub(crate) fn columns(workspace: &Workspace, side: Side) -> Vec<(f32, Vec<Vec<Panel>>)> {
let mut nodes: Vec<_> = workspace.layout.root.iter().collect();
while let Some(node) = nodes.pop() {
match node {
Node::Split { first, second, .. } => nodes.extend([&**first, &**second]),
Node::Dock { side: dock, columns } if *dock == side => {
return columns.iter().map(|column| (column.width, column.groups.iter().map(|group| group.panels.clone()).collect())).collect();
}
_ => {}
}
}
Vec::new()
}
#[cfg(test)]
mod tests {
use super::*;
fn app_with_widths() -> crate::LightcraftApp {
let mut app = crate::LightcraftApp::new(lightcraft_engine::Session::new(), crate::Services::default());
app.ui.left_width = 333.0;
app.ui.right_width = 410.0;
app
}
fn tools_split(axis: SplitAxis, size: SplitSize, first: bool) -> Workspace {
let rest = split(
SplitAxis::Horizontal,
SplitSize::FixedFirst(333.0),
tabs(Panel::Library),
split(SplitAxis::Horizontal, SplitSize::FixedSecond(300.0), tabs(Panel::Canvas), tabs(Panel::Presets)),
);
let root = if first { split(axis, size, tabs(Panel::Tools), rest) } else { split(axis, size, rest, tabs(Panel::Tools)) };
Workspace::new(Layout { root: Some(root), floating: Vec::new() })
}
#[test]
fn explicit_reveal_opens_collapsed_tools_and_survives_reload() {
let mut app = app_with_widths();
app.ui.right = crate::state::RightPanel::Crop;
let entries = [Panel::Tools, Panel::Library, Panel::Presets]
.into_iter()
.map(|panel| craft_ui::docking::StackEntry { panel, open: panel != Panel::Tools, height: Some(180.0) })
.collect();
app.ui.docking = Some(Workspace::new(Layout {
root: Some(split(SplitAxis::Horizontal, SplitSize::FixedSecond(350.0), tabs(Panel::Canvas), Node::Stack { entries })),
floating: Vec::new(),
}));
let undo = app.session.undo.len();
app.run("panel.crop", json!({})).unwrap();
assert_eq!(app.ui.right, crate::state::RightPanel::Crop);
let workspace = app.ui.docking.as_ref().unwrap();
assert!(exposed_in(workspace, Panel::Tools));
assert_eq!(app.session.undo.len(), undo);
let saved = serde_json::to_string(workspace).unwrap();
let reloaded: Workspace = serde_json::from_str(&saved).unwrap();
validate(&reloaded).unwrap();
assert!(exposed_in(&reloaded, Panel::Tools));
}
#[test]
fn legacy_width_publication_ignores_heights_and_sibling_widths() {
for (axis, size, first) in [
(SplitAxis::Vertical, SplitSize::FixedFirst(180.0), true),
(SplitAxis::Vertical, SplitSize::FixedSecond(180.0), false),
(SplitAxis::Horizontal, SplitSize::FixedSecond(180.0), true),
(SplitAxis::Horizontal, SplitSize::FixedFirst(180.0), false),
] {
let workspace = tools_split(axis, size, first);
validate(&workspace).unwrap();
let mut app = app_with_widths();
publish_visibility(&mut app, &workspace);
assert_eq!((app.ui.left_width, app.ui.right_width), (333.0, 410.0), "{axis:?} {size:?}, first={first}");
}
}
#[test]
fn legacy_width_publication_reads_own_split_and_floating_widths() {
for (size, first) in [(SplitSize::FixedFirst(310.0), true), (SplitSize::FixedSecond(310.0), false)] {
let workspace = tools_split(SplitAxis::Horizontal, size, first);
let mut app = app_with_widths();
publish_visibility(&mut app, &workspace);
assert_eq!((app.ui.left_width, app.ui.right_width), (333.0, 310.0));
}
let mut workspace = default_workspace();
apply(&mut workspace, Action::Float { panel: Panel::Tools, rect: [12.0, 34.0, 390.0, 450.0] }).unwrap();
let mut app = app_with_widths();
publish_visibility(&mut app, &workspace);
assert_eq!(app.ui.right_width, 390.0);
}
#[test]
fn legacy_width_update_preserves_hidden_top_panel_height() {
let mut workspace = default_workspace();
apply(&mut workspace, Action::Move { panel: Panel::Tools, anchor: Panel::Canvas, placement: Placement::Split(Zone::Top) }).unwrap();
set_visible(&mut workspace, Panel::Tools, false).unwrap();
let height = workspace.hidden.iter().find(|(panel, _)| *panel == Panel::Tools).unwrap().1.size;
let mut state = crate::UiState { docking: Some(workspace), right_width: 410.0, ..Default::default() };
set_widths(&mut state, &json!({"rightWidth":410.0})).unwrap();
assert_eq!(state.docking.as_ref().unwrap().hidden.iter().find(|(panel, _)| *panel == Panel::Tools).unwrap().1.size, height);
}
/// Settings written before workspaces had a version: `{layout, hidden}`, a floating
/// window as one group, hidden locations without dock state.
#[test]
fn version_one_workspace_file_loads_and_reopens_its_hidden_panel() {
let v1 = json!({
"layout": {
"root": {"Split": {
"axis": "Horizontal",
"size": {"FixedFirst": 300.0},
"first": {"Tabs": {"panels": ["library"], "active": 0}},
"second": {"Tabs": {"panels": ["canvas"], "active": 0}}
}},
"floating": [{"panels": ["tools"], "active": 0, "rect": [120.0, 90.0, 320.0, 600.0]}]
},
"hidden": [["presets", {
"floating": null,
"anchor": "canvas",
"placement": {"Split": "Right"},
"size": {"FixedSecond": 280.0},
"stack": null,
"sibling": ["canvas"]
}]]
});
let mut workspace: Workspace = serde_json::from_value(v1).unwrap();
validate(&workspace).unwrap();
assert_eq!(workspace.version, 1);
let window = workspace.layout.floating.first().unwrap();
assert!(window.contains(&Panel::Tools));
assert_eq!(window.rect, [120.0, 90.0, 320.0, 600.0]);
assert!(exposed_in(&workspace, Panel::Library));
set_visible(&mut workspace, Panel::Presets, true).unwrap();
let location = workspace.layout.location(&Panel::Presets).unwrap();
assert_eq!((location.anchor, location.size), (Some(Panel::Canvas), Some(SplitSize::FixedSecond(280.0))));
let saved = serde_json::to_value(&workspace).unwrap();
assert_eq!(saved["version"], 2);
assert_eq!(saved["layout"]["floating"][0]["panels"], json!(["tools"]), "a one-group window keeps the v1 shape");
}
#[test]
fn default_workspace_docks_library_at_the_start_and_tools_and_presets_at_the_end() {
let workspace = default_workspace();
validate(&workspace).unwrap();
assert_eq!(columns(&workspace, Side::Start), [(crate::state::LEFT_WIDTH.default, vec![vec![Panel::Library]])]);
assert_eq!(
columns(&workspace, Side::End),
[(crate::state::RIGHT_WIDTH.default, vec![vec![Panel::Tools]]), (PRESETS_WIDTH, vec![vec![Panel::Presets]])],
"Presets has its own column on Tools' photo side"
);
let Some(Node::Split { second, .. }) = &workspace.layout.root else { panic!("{:?}", workspace.layout.root) };
let Node::Split { first, .. } = &**second else { panic!("{second:?}") };
assert_eq!(**first, tabs(Panel::Canvas), "the photo sits between the docks");
assert!(workspace.layout.floating.is_empty());
let app = app_with_widths();
let workspace = from_ui(&app);
assert_eq!(columns(&workspace, Side::Start).first().map(|column| column.0), Some(333.0));
assert_eq!(columns(&workspace, Side::End).first().map(|column| column.0), Some(410.0));
}
#[test]
fn dock_column_widths_publish_and_follow_width_controls() {
let mut app = app_with_widths();
let workspace = docked(300.0, 310.0);
publish_visibility(&mut app, &workspace);
assert_eq!((app.ui.left_width, app.ui.right_width), (300.0, 310.0));
let mut state = crate::UiState { docking: Some(workspace), left_width: 350.0, right_width: 400.0, ..Default::default() };
set_visible(state.docking.as_mut().unwrap(), Panel::Library, false).unwrap();
set_widths(&mut state, &json!({"leftWidth":350.0, "rightWidth":400.0})).unwrap();
let workspace = state.docking.as_mut().unwrap();
assert_eq!(columns(workspace, Side::End).first().map(|column| column.0), Some(400.0), "Tools' column");
set_visible(workspace, Panel::Library, true).unwrap();
assert_eq!(columns(workspace, Side::Start), [(350.0, vec![vec![Panel::Library]])], "the closed Library's column");
}
#[test]
fn a_panel_without_a_recorded_place_opens_in_its_dock() {
let root = split(
SplitAxis::Horizontal,
SplitSize::FixedSecond(300.0),
tabs(Panel::Canvas),
Node::Dock { side: Side::End, columns: vec![column(Panel::Tools, 300.0)] },
);
let mut workspace = Workspace::new(Layout { root: Some(root), floating: Vec::new() });
set_visible(&mut workspace, Panel::Presets, true).unwrap();
set_visible(&mut workspace, Panel::Library, true).unwrap();
validate(&workspace).unwrap();
assert_eq!(columns(&workspace, Side::Start), [(crate::state::LEFT_WIDTH.default, vec![vec![Panel::Library]])]);
assert_eq!(columns(&workspace, Side::End), [(300.0, vec![vec![Panel::Tools]]), (PRESETS_WIDTH, vec![vec![Panel::Presets]])]);
// Without Tools in the end dock, Presets takes the dock's window edge.
let mut workspace = default_workspace();
set_visible(&mut workspace, Panel::Presets, false).unwrap();
workspace.hidden.clear();
apply(&mut workspace, Action::Float { panel: Panel::Tools, rect: [12.0, 34.0, 390.0, 450.0] }).unwrap();
set_visible(&mut workspace, Panel::Presets, true).unwrap();
assert_eq!(columns(&workspace, Side::End), [(PRESETS_WIDTH, vec![vec![Panel::Presets]])]);
}
fn saved_settings(docking: Value, version: Option<u32>) -> serde_json::Map<String, Value> {
let ui = crate::UiState { thumb_size: 210.0, filmstrip: false, presets: true, ..Default::default() };
let mut saved = serde_json::to_value(&ui).unwrap();
let fields = saved.as_object_mut().unwrap();
fields.insert("docking".into(), docking);
match version {
Some(version) => fields.insert("dockingVersion".into(), json!(version)),
None => fields.remove("dockingVersion"),
};
fields.clone()
}
#[test]
fn a_saved_split_frame_layout_without_a_docking_version_loads_as_the_default_docks() {
let frames = split(
SplitAxis::Horizontal,
SplitSize::FixedFirst(333.0),
tabs(Panel::Library),
split(SplitAxis::Horizontal, SplitSize::FixedSecond(410.0), tabs(Panel::Canvas), tabs(Panel::Tools)),
);
let frames = Workspace::new(Layout { root: Some(frames), floating: Vec::new() });
validate(&frames).unwrap();
for version in [None, Some(0)] {
let mut fields = saved_settings(serde_json::to_value(&frames).unwrap(), version);
assert!(drop_outdated(&mut fields));
let ui: crate::UiState = serde_json::from_value(Value::Object(fields)).unwrap();
assert!(ui.docking.is_none());
assert_eq!(ui.docking_version, DOCKING_VERSION);
assert_eq!((ui.thumb_size, ui.filmstrip, ui.presets), (210.0, false, true), "other settings stay");
let mut app = app_with_widths();
app.ui = ui;
command(&mut app, false, &json!({"operation":"activate","panel":"tools"})).unwrap();
let workspace = app.ui.docking.as_ref().unwrap();
assert!(!workspace.layout.contains(&Panel::Library), "the Library panel stays closed");
assert_eq!(
columns(workspace, Side::End),
[(crate::state::RIGHT_WIDTH.default, vec![vec![Panel::Tools]]), (PRESETS_WIDTH, vec![vec![Panel::Presets]])]
);
}
}
#[test]
fn a_saved_dock_layout_round_trips() {
let mut workspace = default_workspace();
apply(&mut workspace, Action::ResizeColumn { panel: Panel::Tools, width: 333.0 }).unwrap();
apply(
&mut workspace,
Action::Move { panel: Panel::Presets, anchor: Panel::Library, placement: Placement::Group { below: true, height: None } },
)
.unwrap();
set_visible(&mut workspace, Panel::Library, false).unwrap();
let mut fields = saved_settings(serde_json::to_value(&workspace).unwrap(), Some(DOCKING_VERSION));
assert!(!drop_outdated(&mut fields));
let ui: crate::UiState = serde_json::from_value(Value::Object(fields)).unwrap();
let loaded = ui.docking.unwrap();
validate(&loaded).unwrap();
assert_eq!(loaded, workspace);
assert_eq!(serde_json::to_value(crate::UiState::default()).unwrap()["dockingVersion"], DOCKING_VERSION, "saves write the version");
}
#[test]
fn a_panel_whose_saved_place_is_gone_opens_in_its_dock() {
let root = split(SplitAxis::Horizontal, SplitSize::FixedSecond(300.0), tabs(Panel::Canvas), tabs(Panel::Tools));
let mut workspace = Workspace::new(Layout { root: Some(root), floating: Vec::new() });
// Presets, the panel Library went back beside, is neither shown nor hidden.
let location: craft_ui::docking::Location<Panel> = serde_json::from_value(json!({
"floating": null,
"anchor": "presets",
"placement": {"Split": "Left"},
"size": {"FixedFirst": 280.0},
"stack": null,
"sibling": ["presets"]
}))
.unwrap();
workspace.hidden.push((Panel::Library, location));
validate(&workspace).unwrap();
set_visible(&mut workspace, Panel::Library, true).unwrap();
validate(&workspace).unwrap();
assert_eq!(columns(&workspace, Side::Start), [(crate::state::LEFT_WIDTH.default, vec![vec![Panel::Library]])]);
}
}
Reference in New Issue View Git Blame Copy Permalink