a770fa5a5e5f
docking.rs
//! 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, DockArea, DockCommand, DockContent, DockHeights, DockOperation, DockStyle, FloatSpace, Group, Layout, Location, Node,
PanelLimits, Permissions, Placement, Side, Sides, Target, 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,
ToolSets,
QuickCalc,
Layers,
Properties,
#[serde(rename = "externalReferences")]
ExternalRefs,
Blocks,
}
impl Panel {
pub const ALL: &[Self] = &[Self::Canvas, Self::ToolSets, Self::Layers, Self::Properties, Self::ExternalRefs];
pub fn id(self) -> &'static str {
match self {
Self::Canvas => "canvas",
Self::ToolSets => "toolSets",
Self::QuickCalc => "quickCalc",
Self::Layers => "layers",
Self::Properties => "properties",
Self::ExternalRefs => "externalReferences",
Self::Blocks => "blocks",
}
}
fn label(self) -> &'static str {
match self {
Self::Canvas => "Drawing",
Self::ToolSets => "Tool Sets",
Self::QuickCalc => "QuickCalc",
Self::Layers => "Layers",
Self::Properties => "Properties",
Self::ExternalRefs => "External References",
Self::Blocks => "Blocks",
}
}
/// The icon a palette shows in a column collapsed to icons.
pub fn icon(self) -> Option<crate::icons::Icon> {
use crate::icons::Icon;
match self {
Self::Canvas => None,
Self::ToolSets => Some(Icon::Switcher),
Self::QuickCalc => Some(Icon::Table),
Self::Layers => Some(Icon::Layers),
Self::Properties => Some(Icon::Properties),
Self::ExternalRefs => Some(Icon::Attach),
Self::Blocks => Some(Icon::Blocks),
}
}
/// Palettes outside the default arrangement, opened on request (QUICKCALC).
pub const ON_DEMAND: &[Self] = &[Self::QuickCalc, Self::Blocks];
}
/// The drawing view never moves, floats, closes or takes tabs; palettes dock beside it.
pub fn permissions(panel: &Panel) -> Permissions {
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 panel arrangement: craft-ui's workspace over CADCraft's panels.
pub type Workspace = craft_ui::docking::Workspace<Panel>;
/// The panel layout's shape version, saved beside it. Layouts saved without it, or with an
/// older one, are the split frames from before the dock columns and give way to the default.
pub const LAYOUT_VERSION: u32 = 2;
/// Width of the left dock's Tool Sets column.
pub const TOOL_SETS_WIDTH: f32 = 220.0;
/// Width of the right dock's palettes column.
pub const PALETTES_WIDTH: f32 = 300.0;
/// Layers' body height above Properties in a dock column.
const LAYERS_HEIGHT: f32 = 280.0;
fn dock(side: Side, width: f32, groups: &[Panel]) -> Node<Panel> {
let groups = groups.iter().map(|panel| Group::new(vec![*panel], 0)).collect();
Node::Dock { side, columns: vec![Column::new(groups, width)] }
}
/// Tool Sets in the left dock, the drawing, and Layers above Properties in the right dock.
pub fn default_workspace() -> Workspace {
Workspace::new(Layout {
root: Some(split(
SplitAxis::Horizontal,
SplitSize::FixedFirst(TOOL_SETS_WIDTH),
dock(Side::Start, TOOL_SETS_WIDTH, &[Panel::ToolSets]),
split(
SplitAxis::Horizontal,
SplitSize::FixedSecond(PALETTES_WIDTH),
tabs(Panel::Canvas),
dock(Side::End, PALETTES_WIDTH, &[Panel::Layers, Panel::Properties]),
),
)),
floating: Vec::new(),
})
}
/// The dock a panel belongs in: Tool Sets on the left, the palettes on the right.
fn home_side(panel: Panel) -> (Side, f32) {
if panel == Panel::ToolSets { (Side::Start, TOOL_SETS_WIDTH) } else { (Side::End, PALETTES_WIDTH) }
}
/// The panels of every dock group on `side`: columns from the window edge inwards, groups from
/// top to bottom.
fn dock_groups(layout: &Layout<Panel>, side: Side) -> Vec<Vec<Vec<Panel>>> {
let mut nodes: Vec<&Node<Panel>> = layout.root.iter().collect();
let mut seen = 0usize;
while let Some(node) = nodes.pop() {
seen = seen.saturating_add(1);
if seen > 4 * craft_ui::docking::MAX_PANELS {
break;
}
match node {
Node::Split { first, second, .. } => nodes.extend([&**first, &**second]),
Node::Dock { side: s, columns } if *s == side => {
return columns.iter().map(|column| column.groups.iter().map(|group| group.panels.clone()).collect()).collect();
}
_ => {}
}
}
Vec::new()
}
fn docked(layout: &Layout<Panel>, panel: Panel) -> bool {
[Side::Start, Side::End].into_iter().any(|side| dock_groups(layout, side).iter().flatten().flatten().any(|p| *p == panel))
}
/// The docked neighbour a panel with no recorded place opens beside, as a new group above
/// (`false`) or below (`true`) it: Layers above Properties, External References and QuickCalc
/// below them, Tool Sets at the top of the left dock.
fn home_anchor(layout: &Layout<Panel>, panel: Panel) -> Option<(Panel, bool)> {
let neighbours: &[(Panel, bool)] = match panel {
Panel::Canvas | Panel::ToolSets => &[],
Panel::Layers => &[(Panel::Properties, false), (Panel::ExternalRefs, false)],
Panel::Properties => &[(Panel::Layers, true), (Panel::ExternalRefs, false)],
Panel::ExternalRefs => &[(Panel::Properties, true), (Panel::Layers, true)],
Panel::QuickCalc => &[(Panel::ExternalRefs, true), (Panel::Properties, true), (Panel::Layers, true)],
Panel::Blocks => &[(Panel::QuickCalc, true), (Panel::ExternalRefs, true), (Panel::Properties, true), (Panel::Layers, true)],
};
if let Some(found) = neighbours.iter().copied().find(|(neighbour, _)| docked(layout, *neighbour)) {
return Some(found);
}
let (side, _) = home_side(panel);
let columns = dock_groups(layout, side);
let column = columns.first()?;
if panel == Panel::ToolSets {
column.first().and_then(|group| group.first()).map(|anchor| (*anchor, false))
} else {
column.last().and_then(|group| group.first()).map(|anchor| (*anchor, true))
}
}
/// The actions that open a panel with no recorded place in its dock: a new group beside its
/// docked neighbour, else a new dock on its side at its default width.
fn home(layout: &Layout<Panel>, panel: Panel) -> Vec<Action<Panel>> {
if let Some((anchor, below)) = home_anchor(layout, panel) {
return vec![Action::OpenAt { panel, anchor, placement: Placement::Group { below, height: None } }];
}
let (side, width) = home_side(panel);
vec![Action::Open { panel, anchor: None }, Action::MovePanel { panel, to: Target::NewDock { side } }, Action::ResizeColumn { panel, width }]
}
/// craft-ui's checks plus the drawing view's: a saved or hand-edited file cannot hide, float,
/// group, collapse or dock it, or restore a palette over it.
pub fn validate(workspace: &Workspace) -> Result<(), String> {
workspace.validate().map_err(|error| error.to_string())?;
if !workspace.layout.contains(&Panel::Canvas) {
return Err("The panel layout must contain its document view".into());
}
if workspace.layout.floating.iter().any(|window| window.contains(&Panel::Canvas)) {
return Err("The document view cannot float".into());
}
let mut nodes: Vec<_> = workspace.layout.root.iter().collect();
while let Some(node) = nodes.pop() {
match node {
Node::Split { first, second, .. } => {
nodes.push(first);
nodes.push(second);
}
Node::Tabs { panels, .. } if panels.contains(&Panel::Canvas) && panels.len() != 1 => {
return Err("The document view cannot share a tab group".into());
}
Node::Stack { entries } if entries.iter().any(|entry| entry.panel == Panel::Canvas) => {
return Err("The document view cannot be collapsed".into());
}
Node::Dock { columns, .. } if columns.iter().flat_map(|column| &column.groups).any(|group| group.panels.contains(&Panel::Canvas)) => {
return Err("The document view cannot be in a dock".into());
}
_ => {}
}
}
let over_canvas = |location: &Location<Panel>| {
location.anchor == Some(Panel::Canvas) && matches!(location.placement, Placement::Tab { .. } | Placement::Split(Zone::Center))
};
if workspace.hidden.iter().any(|(_, location)| over_canvas(location)) {
return Err("A hidden panel cannot restore over the document view".into());
}
Ok(())
}
/// Show a panel and select it at its recorded place, keeping the drawing view's rules. A panel
/// with no recorded place opens in its dock ([`home`]); one whose recorded place is gone joins
/// its docked neighbour's group.
pub fn reveal_panel(workspace: &mut Workspace, panel: Panel) -> Result<(), String> {
let mut next = workspace.clone();
if next.layout.contains(&panel) || next.hidden.iter().any(|(id, _)| *id == panel) {
let fallback = home_anchor(&next.layout, panel).map(|(anchor, _)| anchor);
next.set_visible(panel, true, fallback, permissions).map_err(|error| error.to_string())?;
} else {
next.apply_all(home(&next.layout, panel).into_iter().chain([Action::Activate { panel }]), permissions).map_err(|error| error.to_string())?;
}
validate(&next)?;
*workspace = next;
Ok(())
}
/// Show or hide a panel for the Tool Sets and palette switches. Showing a panel whose recorded
/// anchor is shown restores it there without changing which tab is selected or which accordion
/// entries are open. Otherwise it goes through [`reveal_panel`], which regroups it with hidden
/// panels it was beside, and selects it.
fn set_visible(workspace: &mut Workspace, panel: Panel, visible: bool) -> Result<(), String> {
if workspace.layout.contains(&panel) == visible {
return Ok(());
}
if !visible {
return workspace.set_visible(panel, false, None, permissions).map_err(|error| error.to_string());
}
let mut next = workspace.clone();
let location = next.hidden.iter().find(|(id, _)| *id == panel).map(|(_, location)| location.clone());
// A direct restore against a hidden anchor would open a window of its own.
let direct = location.filter(|location| location.anchor.is_none_or(|anchor| next.layout.contains(&anchor)));
if direct.is_some_and(|location| next.layout.restore(panel, &location).is_ok()) {
next.hidden.retain(|(id, _)| *id != panel);
validate(&next)?;
*workspace = next;
return Ok(());
}
reveal_panel(workspace, panel)
}
/// `ui.dock` params: `{action}` or `{operation, …}` in craft-ui's shared grammar.
fn apply_command(workspace: &mut Workspace, params: &Value) -> Result<(), String> {
validate(workspace)?;
let operation = if let Some(action) = params.get("action") {
UiDock::Action { action: serde_json::from_value(action.clone()).map_err(|error| error.to_string())? }
} else {
UiDock::Operation(serde_json::from_value(params.clone()).map_err(|error| error.to_string())?)
};
let mut next = workspace.clone();
match operation {
UiDock::Operation(DockOperation::Open { panel } | DockOperation::Activate { panel }) if !next.layout.contains(&panel) => {
reveal_panel(&mut next, panel)?;
}
operation => {
// Every ui.dock operation carries its own rect, so the float space is never consulted.
let space = FloatSpace::new(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1280.0, 800.0)));
DockCommand::UiDock(operation).apply(&mut next, false, &space, permissions).map_err(|error| error.to_string())?;
}
}
validate(&next)?;
*workspace = next;
Ok(())
}
fn sync(workspace: &mut Workspace, app: &crate::CadApp) -> Result<(), String> {
set_visible(workspace, Panel::ToolSets, app.ui.show_toolsets)?;
if !app.ui.show_palettes {
set_visible(workspace, Panel::Layers, false)?;
set_visible(workspace, Panel::Properties, false)?;
} else if !workspace.layout.contains(&Panel::Layers) && !workspace.layout.contains(&Panel::Properties) {
// Reopen the palette that closed last before the one recorded beside it.
set_visible(workspace, Panel::Properties, true)?;
set_visible(workspace, Panel::Layers, true)?;
}
Ok(())
}
fn publish_visibility(app: &mut crate::CadApp, workspace: &Workspace) {
app.ui.show_toolsets = workspace.layout.contains(&Panel::ToolSets);
app.ui.show_palettes = workspace.layout.contains(&Panel::Layers) || workspace.layout.contains(&Panel::Properties);
}
pub fn command(app: &mut crate::CadApp, reset: bool, params: &Value) -> Result<Value, String> {
let mut workspace = app.ui.docking.clone();
if reset {
workspace = default_workspace();
} else {
sync(&mut workspace, app)?;
apply_command(&mut workspace, params)?;
// An opened panel's floating window comes to the front, in its own OS window too.
if matches!(params.get("operation").and_then(Value::as_str), Some("open" | "activate")) {
app.raise_panel = params.get("panel").and_then(|panel| serde_json::from_value(panel.clone()).ok());
}
}
publish_visibility(app, &workspace);
app.ui.docking = workspace;
Ok(json!({"docking": app.ui.docking}))
}
/// Validate and repair the stored workspace, sync it with the app, and render the dock panels; a failed restore falls back to the default layout with a status message.
pub fn show(app: &mut crate::CadApp, ui: &mut egui::Ui) {
let t = crate::theme::Tokens::get();
let mut workspace = app.ui.docking.clone();
if let Err(error) = validate(&workspace).and_then(|()| sync(&mut workspace, app)) {
app.set_status(format!("Panel layout could not be restored: {error}"));
workspace = default_workspace();
let _ = sync(&mut workspace, app);
}
// Bodies can dispatch commands (including the drawing's typed command line).
// Keep the canonical workspace accessible while rendering an immutable snapshot.
app.ui.docking = workspace.clone();
let mut style = DockStyle::from_ui(ui);
style.min_pane = 96.0;
style.background = t.panel;
style.tab_background = t.chrome;
style.active_background = t.tab_active;
style.text = t.text;
style.inactive_text = t.text_dim;
style.border = egui::Stroke::new(1.0, t.border);
style.accent = t.accent;
style.font = crate::theme::body();
// AutoCAD's palettes dock only in the left and right dock columns: a window edge without a
// dock makes one, and neither the drawing nor the top and bottom edges take a drop.
// Floating title bars only move windows.
style.side_edge_zones = false;
style.new_dock_zones = true;
style.drop_edges = Sides::NONE;
style.title_bar_docks = false;
let mut area = DockArea::new(egui::Id::unique("cadcraft-docking")).input_blocked(native_input_blocked(app, ui.ctx()));
if let Some(panel) = app.raise_panel.take() {
area = area.raise_panel(panel);
}
let mut output = area.show_content(ui, &workspace.layout, &style, &mut Panels { app });
// Keys typed in a floating panel's own OS window run the main window's shortcuts and
// command line; files dropped on one open like files dropped on the main window.
app.forward_native_input(ui.ctx(), std::mem::take(&mut output.forwarded_events), output.forwarded_modifiers);
#[cfg(not(target_arch = "wasm32"))]
for files in std::mem::take(&mut output.window_files) {
for file in files.dropped {
let path = file.path();
if !path.as_os_str().is_empty() {
app.open_path(path);
}
}
}
// Existing panel close buttons and commands still own their visibility switches.
let rendered = workspace;
let mut workspace = app.ui.docking.clone();
let _ = sync(&mut workspace, app);
let stale = workspace != rendered;
if stale {
craft_ui::docking::cancel_drag::<Panel>(ui.ctx(), egui::Id::unique("cadcraft-docking"));
}
publish_visibility(app, &workspace);
app.ui.docking = 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(app, false, &json!({"action": action})))
{
app.set_status(format!("Panel move was not applied: {error}"));
}
}
}
/// Whether the floating panels' own OS windows ignore input: while a modal dialog is up, since
/// egui's `Modal` blocks only the main window. egui's modal layer is last frame's; the app's
/// state covers the frame a modal opens in.
pub fn native_input_blocked(app: &crate::CadApp, ctx: &egui::Context) -> bool {
app.shows_modal() || ctx.memory(|memory| memory.top_modal_layer()).is_some()
}
/// The panels' contents, names, size limits and icons for the dock area.
pub struct Panels<'a> {
pub app: &'a mut crate::CadApp,
}
impl DockContent<Panel> for Panels<'_> {
fn body(&mut self, ui: &mut egui::Ui, panel: &Panel) {
let app = &mut *self.app;
match panel {
Panel::Canvas => {
ui.painter().rect_filled(ui.max_rect(), 0.0, crate::theme::Tokens::get().canvas);
crate::canvas::show(app, ui);
}
Panel::ToolSets => crate::palettes::toolsets(app, ui),
Panel::QuickCalc => crate::palettes::quickcalc::show(app, ui),
Panel::Layers => {
egui::ScrollArea::vertical()
.id_salt("dock-layers")
.auto_shrink([false, false])
.show(ui, |ui| crate::palettes::layers_section(app, ui));
}
Panel::Properties => {
egui::ScrollArea::vertical().id_salt("dock-properties").auto_shrink([false, false]).show(ui, |ui| {
crate::shortcut_menus::palette(app, ui, crate::palettes::properties_section, crate::shortcut_menus::properties_entries)
});
}
Panel::ExternalRefs => {
egui::ScrollArea::both().id_salt("dock-xrefs").auto_shrink([false, false]).show(ui, |ui| crate::xrefs::section(app, ui));
}
Panel::Blocks => {
egui::ScrollArea::vertical()
.id_salt("dock-blocks")
.auto_shrink([false, false])
.show(ui, |ui| crate::blocks_palette::section(app, ui));
}
}
}
fn logical_label(&self, panel: &Panel) -> String {
crate::i18n::t(panel.label()).into()
}
fn permissions(&self, panel: &Panel) -> Permissions {
permissions(panel)
}
fn limits(&self, panel: &Panel) -> PanelLimits {
panel_limits(panel)
}
fn dock_heights(&self, panel: &Panel) -> Option<DockHeights> {
// Layers keeps its list's height above Properties, which takes the rest of the column.
(*panel == Panel::Layers).then(|| DockHeights::new(LAYERS_HEIGHT))
}
fn paint_icon(&mut self, painter: &egui::Painter, rect: egui::Rect, panel: &Panel, _color: egui::Color32) -> bool {
let Some(icon) = panel.icon() else { return false };
crate::icons::paint(painter, rect, icon, false);
true
}
}
fn panel_limits(panel: &Panel) -> PanelLimits {
let (min, max_width) = match panel {
Panel::Canvas => (egui::vec2(300.0, 180.0), 1_000_000.0),
Panel::QuickCalc => (egui::vec2(240.0, 160.0), 600.0),
Panel::ToolSets => (egui::vec2(220.0, 150.0), 480.0),
Panel::Layers | Panel::Properties | Panel::ExternalRefs => (egui::vec2(220.0, 100.0), 720.0),
Panel::Blocks => (egui::vec2(240.0, 260.0), 720.0),
};
PanelLimits { min, max: egui::vec2(max_width, 1_000_000.0) }
}
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.