mirror of
https://github.com/storytold/effectcraft.git
synced 2026-11-20 09:05:51 +00:00
803 lines
34 KiB
Rust
803 lines
34 KiB
Rust
//! EffectCraft's panels and built-in workspaces in craft-ui's shared docking model
|
||
//! ([`craft_ui::docking`]): splits, tab groups, After Effects' stacked panels and floating
|
||
//! windows. craft-ui owns the layout model, its validation and every transaction; EffectCraft
|
||
//! owns the panel ids, the built-in workspaces and the decorations of its tabs (the comp tabs of
|
||
//! the Timeline, label swatches and viewer locks).
|
||
|
||
use egui::{Align2, Rect, Sense, Stroke, pos2, vec2};
|
||
use serde::{Deserialize, Serialize};
|
||
|
||
pub use craft_ui::docking::{Floating, Node, PanelState, Permissions, StackEntry};
|
||
pub use craft_ui::layout::{SplitAxis, SplitSize};
|
||
|
||
use crate::icons::{self, Icon};
|
||
use crate::theme::Tokens;
|
||
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
|
||
pub enum PanelKind {
|
||
Project,
|
||
EffectControls,
|
||
Composition,
|
||
Layer,
|
||
Timeline,
|
||
Info,
|
||
Audio,
|
||
Preview,
|
||
EffectsPresets,
|
||
Properties,
|
||
Character,
|
||
Paragraph,
|
||
Align,
|
||
Tracker,
|
||
Wiggler,
|
||
Smoother,
|
||
MotionSketch,
|
||
Paint,
|
||
Brushes,
|
||
RenderQueue,
|
||
Flowchart,
|
||
History,
|
||
Markers,
|
||
MaskInterpolation,
|
||
ScriptConsole,
|
||
EssentialGraphics,
|
||
/// A dockable ScriptUI panel (a script from the ScriptUI Panels folder), by script window id.
|
||
ScriptPanel(u32),
|
||
/// Another Composition viewer (View ▸ New Viewer), by viewer id (`panels::viewers`).
|
||
Viewer(u32),
|
||
LumetriScopes,
|
||
Footage,
|
||
MediaBrowser,
|
||
Metadata,
|
||
Progress,
|
||
ContentAwareFill,
|
||
/// Window ▸ Create Nulls From Paths (our own panel).
|
||
CreateNullsFromPaths,
|
||
/// Window ▸ VR Comp Editor (our own panel).
|
||
VrCompEditor,
|
||
}
|
||
|
||
impl PanelKind {
|
||
pub const ALL: [PanelKind; 34] = [
|
||
PanelKind::Project,
|
||
PanelKind::EffectControls,
|
||
PanelKind::Composition,
|
||
PanelKind::Layer,
|
||
PanelKind::Timeline,
|
||
PanelKind::Info,
|
||
PanelKind::Audio,
|
||
PanelKind::Preview,
|
||
PanelKind::EffectsPresets,
|
||
PanelKind::Properties,
|
||
PanelKind::Character,
|
||
PanelKind::Paragraph,
|
||
PanelKind::Align,
|
||
PanelKind::Tracker,
|
||
PanelKind::Wiggler,
|
||
PanelKind::Smoother,
|
||
PanelKind::MotionSketch,
|
||
PanelKind::Paint,
|
||
PanelKind::Brushes,
|
||
PanelKind::RenderQueue,
|
||
PanelKind::Flowchart,
|
||
PanelKind::History,
|
||
PanelKind::Markers,
|
||
PanelKind::MaskInterpolation,
|
||
PanelKind::ScriptConsole,
|
||
PanelKind::EssentialGraphics,
|
||
PanelKind::LumetriScopes,
|
||
PanelKind::Footage,
|
||
PanelKind::MediaBrowser,
|
||
PanelKind::Metadata,
|
||
PanelKind::Progress,
|
||
PanelKind::ContentAwareFill,
|
||
PanelKind::CreateNullsFromPaths,
|
||
PanelKind::VrCompEditor,
|
||
];
|
||
pub fn title(self) -> &'static str {
|
||
match self {
|
||
PanelKind::Project => "Project",
|
||
PanelKind::EffectControls => "Effect Controls",
|
||
PanelKind::Composition => "Composition",
|
||
PanelKind::Layer => "Layer",
|
||
PanelKind::Timeline => "Timeline",
|
||
PanelKind::Info => "Info",
|
||
PanelKind::Audio => "Audio",
|
||
PanelKind::Preview => "Preview",
|
||
PanelKind::EffectsPresets => "Effects & Presets",
|
||
PanelKind::Properties => "Properties",
|
||
PanelKind::Character => "Character",
|
||
PanelKind::Paragraph => "Paragraph",
|
||
PanelKind::Align => "Align",
|
||
PanelKind::Tracker => "Tracker",
|
||
PanelKind::Wiggler => "Wiggler",
|
||
PanelKind::Smoother => "Smoother",
|
||
PanelKind::MotionSketch => "Motion Sketch",
|
||
PanelKind::Paint => "Paint",
|
||
PanelKind::Brushes => "Brushes",
|
||
PanelKind::RenderQueue => "Render Queue",
|
||
PanelKind::Flowchart => "Flowchart",
|
||
PanelKind::History => "History",
|
||
PanelKind::Markers => "Markers",
|
||
PanelKind::MaskInterpolation => "Mask Interpolation",
|
||
PanelKind::ScriptConsole => "Script Console",
|
||
PanelKind::EssentialGraphics => "Essential Graphics",
|
||
PanelKind::ScriptPanel(_) => "ScriptUI Panel",
|
||
PanelKind::Viewer(_) => "Composition",
|
||
PanelKind::LumetriScopes => "Video Scopes",
|
||
PanelKind::Footage => "Footage",
|
||
PanelKind::MediaBrowser => "Media Browser",
|
||
PanelKind::Metadata => "Metadata",
|
||
PanelKind::Progress => "Progress",
|
||
PanelKind::ContentAwareFill => "Content-Aware Fill",
|
||
PanelKind::CreateNullsFromPaths => "Create Nulls From Paths",
|
||
PanelKind::VrCompEditor => "VR Comp Editor",
|
||
}
|
||
}
|
||
pub fn id(self) -> String {
|
||
format!("{self:?}")
|
||
}
|
||
/// The shortcut scope of the panel: an additional viewer is a Composition panel.
|
||
pub fn shortcut_scope(self) -> String {
|
||
match self {
|
||
PanelKind::Viewer(_) => PanelKind::Composition.id(),
|
||
p => p.id(),
|
||
}
|
||
}
|
||
pub fn from_name(s: &str) -> Option<PanelKind> {
|
||
let n = s.to_ascii_lowercase().replace([' ', '_', '-', '&'], "");
|
||
Self::ALL.iter().copied().find(|p| format!("{p:?}").to_ascii_lowercase() == n || p.title().to_ascii_lowercase().replace([' ', '&', '-'], "") == n)
|
||
}
|
||
/// Window-menu shortcut.
|
||
pub fn window_shortcut(self) -> Option<&'static str> {
|
||
match self {
|
||
PanelKind::Project => Some("Cmd+0"),
|
||
PanelKind::Info => Some("Cmd+2"),
|
||
PanelKind::Preview => Some("Cmd+3"),
|
||
PanelKind::Audio => Some("Cmd+4"),
|
||
PanelKind::EffectsPresets => Some("Cmd+5"),
|
||
PanelKind::Character => Some("Cmd+6"),
|
||
PanelKind::Paragraph => Some("Cmd+7"),
|
||
PanelKind::Paint => Some("Cmd+8"),
|
||
PanelKind::Brushes => Some("Cmd+9"),
|
||
PanelKind::RenderQueue => Some("Cmd+Alt+0"),
|
||
PanelKind::EffectControls => Some("F3"),
|
||
_ => None,
|
||
}
|
||
}
|
||
/// Chrome-less panels (none in the AE layout; kept for parity with the docking code).
|
||
pub fn compact(self) -> bool {
|
||
false
|
||
}
|
||
}
|
||
|
||
/// The docked tree plus floating windows.
|
||
pub type Layout = craft_ui::docking::Layout<PanelKind>;
|
||
/// What a workspace saves: the layout, closed panels with where each goes back, and the lock.
|
||
pub type Workspace = craft_ui::docking::Workspace<PanelKind>;
|
||
|
||
/// What may happen to a panel. Every panel moves, floats and closes, as in After Effects
|
||
/// (the Composition panel too: Window ▸ Composition reopens it); the last docked group staying
|
||
/// docked is checked per transaction ([`crate::dock_ui`]).
|
||
pub fn permissions(_panel: &PanelKind) -> Permissions {
|
||
Permissions::default()
|
||
}
|
||
|
||
/// A tab group.
|
||
pub fn tabs(p: &[PanelKind], active: usize) -> Node<PanelKind> {
|
||
Node::Tabs { panels: p.to_vec(), active }
|
||
}
|
||
/// Stacked panels: (panel, open, height). Open entries share the stack's height in proportion to
|
||
/// their heights; an entry without one counts as craft-ui's `DockStyle::min_pane` (40).
|
||
pub fn stack(e: &[(PanelKind, bool, Option<f32>)]) -> Node<PanelKind> {
|
||
Node::Stack { entries: e.iter().map(|&(panel, open, height)| StackEntry { panel, open, height }).collect() }
|
||
}
|
||
/// Two frames side by side.
|
||
pub fn hsplit(size: SplitSize, a: Node<PanelKind>, b: Node<PanelKind>) -> Node<PanelKind> {
|
||
Node::Split { axis: SplitAxis::Horizontal, size, first: Box::new(a), second: Box::new(b) }
|
||
}
|
||
/// Two frames one above the other.
|
||
pub fn vsplit(size: SplitSize, a: Node<PanelKind>, b: Node<PanelKind>) -> Node<PanelKind> {
|
||
Node::Split { axis: SplitAxis::Vertical, size, first: Box::new(a), second: Box::new(b) }
|
||
}
|
||
|
||
/// A workspace of just `root`, with no floating windows.
|
||
pub fn docked(root: Node<PanelKind>) -> Workspace {
|
||
Workspace::new(Layout { root: Some(root), floating: Vec::new() })
|
||
}
|
||
|
||
/// The built-in workspaces: After Effects 2026's (Window ▸ Workspace), less Libraries (an Adobe
|
||
/// service). Learn shows the Home screen (community links instead of Adobe's tutorials);
|
||
/// Essential Graphics uses the Properties panel; Undocked Panels floats the panels over the
|
||
/// Composition panel.
|
||
pub const WORKSPACES: &[&str] = &[
|
||
"Default",
|
||
"Standard",
|
||
"Small Screen",
|
||
"Animation",
|
||
"Effects",
|
||
"Motion Tracking",
|
||
"Paint",
|
||
"Text",
|
||
"Minimal",
|
||
"All Panels",
|
||
"Review",
|
||
"Learn",
|
||
"Essential Graphics",
|
||
"Color",
|
||
"Undocked Panels",
|
||
];
|
||
|
||
/// The floating windows a workspace starts with (Undocked Panels), in points for a window of
|
||
/// about 1680×1020 (craft-ui keeps them inside the window when drawn). Each window has a fixed
|
||
/// id, so a built-in layout built again is the same set of windows.
|
||
fn workspace_floating(name: &str) -> Vec<Floating<PanelKind>> {
|
||
use PanelKind::*;
|
||
let f = |id: u64, panels: &[PanelKind], rect: [f32; 4]| Floating::single(panels.to_vec(), 0, rect).with_id(id);
|
||
match name {
|
||
"Undocked Panels" => vec![
|
||
f(1, &[Project, EffectControls], [24.0, 110.0, 320.0, 420.0]),
|
||
f(2, &[Preview, Info, Audio], [1330.0, 110.0, 320.0, 300.0]),
|
||
f(3, &[EffectsPresets, Properties, Character, Paragraph], [1330.0, 430.0, 320.0, 360.0]),
|
||
f(4, &[Timeline, RenderQueue], [24.0, 640.0, 1280.0, 340.0]),
|
||
],
|
||
_ => vec![],
|
||
}
|
||
}
|
||
|
||
/// The height of a frame's tab strip ([`Tokens::tab_h`]).
|
||
pub const TAB_STRIP: f32 = 30.0;
|
||
/// The height of Default's Preview frame: its tab strip over a 46-point body that fits the
|
||
/// playback controls.
|
||
pub const PREVIEW_FRAME: f32 = TAB_STRIP + 46.0;
|
||
|
||
/// The built-in layout of a named workspace (an unknown name gets Default's).
|
||
pub fn workspace(name: &str) -> Layout {
|
||
Layout { root: Some(workspace_root(name)), floating: workspace_floating(name) }
|
||
}
|
||
|
||
/// The docked tree of a named workspace.
|
||
fn workspace_root(name: &str) -> Node<PanelKind> {
|
||
use PanelKind::*;
|
||
use SplitSize::*;
|
||
let right = |p: &[PanelKind], q: &[PanelKind]| vsplit(Ratio(0.45), tabs(p, 0), tabs(q, 0));
|
||
match name {
|
||
"Animation" => vsplit(
|
||
Ratio(0.55),
|
||
hsplit(
|
||
FixedFirst(300.0),
|
||
tabs(&[Project, EffectControls], 1),
|
||
hsplit(FixedSecond(300.0), tabs(&[Composition, Layer], 0), right(&[Info, Preview, Audio], &[EffectsPresets, Smoother, Wiggler, MotionSketch])),
|
||
),
|
||
tabs(&[Timeline, RenderQueue], 0),
|
||
),
|
||
"Effects" => vsplit(
|
||
Ratio(0.58),
|
||
hsplit(
|
||
FixedFirst(340.0),
|
||
tabs(&[EffectControls, Project], 0),
|
||
hsplit(FixedSecond(300.0), tabs(&[Composition, Layer], 0), right(&[Info, Preview], &[EffectsPresets])),
|
||
),
|
||
tabs(&[Timeline, RenderQueue], 0),
|
||
),
|
||
"Motion Tracking" => vsplit(
|
||
Ratio(0.6),
|
||
hsplit(
|
||
FixedFirst(300.0),
|
||
tabs(&[Project, EffectControls], 0),
|
||
hsplit(FixedSecond(300.0), tabs(&[Layer, Composition], 0), right(&[Info, Preview], &[Tracker])),
|
||
),
|
||
tabs(&[Timeline], 0),
|
||
),
|
||
"Paint" => vsplit(
|
||
Ratio(0.6),
|
||
hsplit(
|
||
FixedFirst(300.0),
|
||
tabs(&[Project, EffectControls], 0),
|
||
hsplit(FixedSecond(300.0), tabs(&[Layer, Composition], 0), right(&[Paint, Info], &[Brushes, Preview])),
|
||
),
|
||
tabs(&[Timeline], 0),
|
||
),
|
||
"Text" => vsplit(
|
||
Ratio(0.58),
|
||
hsplit(
|
||
FixedFirst(300.0),
|
||
tabs(&[Project, EffectControls], 0),
|
||
hsplit(FixedSecond(300.0), tabs(&[Composition], 0), right(&[Character, Paragraph], &[Align, Preview, EffectsPresets])),
|
||
),
|
||
tabs(&[Timeline], 0),
|
||
),
|
||
"Minimal" => vsplit(Ratio(0.6), tabs(&[Composition], 0), tabs(&[Timeline], 0)),
|
||
// Review: a large viewer with the markers and the project beside it.
|
||
"Review" => vsplit(
|
||
Ratio(0.66),
|
||
hsplit(
|
||
FixedFirst(280.0),
|
||
tabs(&[Project, Markers], 0),
|
||
hsplit(FixedSecond(260.0), tabs(&[Composition, Layer], 0), right(&[Preview, Info], &[Audio])),
|
||
),
|
||
tabs(&[Timeline, RenderQueue], 0),
|
||
),
|
||
// Essential Graphics: the Properties panel (After Effects' successor to the Essential
|
||
// Graphics panel) full height on the right, type panels beside the viewer.
|
||
"Essential Graphics" => hsplit(
|
||
FixedSecond(320.0),
|
||
vsplit(
|
||
Ratio(0.58),
|
||
hsplit(
|
||
FixedFirst(280.0),
|
||
tabs(&[Project, EffectControls], 0),
|
||
hsplit(FixedSecond(260.0), tabs(&[Composition, Layer], 0), right(&[Character, Paragraph], &[Align, Preview])),
|
||
),
|
||
tabs(&[Timeline], 0),
|
||
),
|
||
tabs(&[Properties, EffectsPresets], 0),
|
||
),
|
||
// Color: wide Effect Controls for grading effects, Info for colour readouts.
|
||
"Color" => vsplit(
|
||
Ratio(0.6),
|
||
hsplit(
|
||
FixedFirst(360.0),
|
||
tabs(&[EffectControls, Project], 0),
|
||
hsplit(FixedSecond(340.0), tabs(&[Composition, Layer], 0), right(&[LumetriScopes, Info, Preview], &[EffectsPresets])),
|
||
),
|
||
tabs(&[Timeline], 0),
|
||
),
|
||
// Undocked Panels: the Composition panel docked, the others floating
|
||
// ([`workspace_floating`]).
|
||
"Undocked Panels" => tabs(&[Composition, Layer, Flowchart], 0),
|
||
"Small Screen" => vsplit(
|
||
Ratio(0.55),
|
||
hsplit(
|
||
FixedFirst(240.0),
|
||
tabs(&[Project, EffectControls], 0),
|
||
hsplit(FixedSecond(240.0), tabs(&[Composition], 0), tabs(&[Info, Preview, EffectsPresets], 1)),
|
||
),
|
||
tabs(&[Timeline], 0),
|
||
),
|
||
"All Panels" => vsplit(
|
||
Ratio(0.55),
|
||
hsplit(
|
||
FixedFirst(300.0),
|
||
tabs(&[Project, EffectControls, Flowchart, History, MediaBrowser, Metadata], 0),
|
||
hsplit(
|
||
FixedSecond(300.0),
|
||
tabs(&[Composition, Layer, Footage], 0),
|
||
right(
|
||
&[Info, Preview, Audio, Align, Character, Paragraph, LumetriScopes],
|
||
&[
|
||
EffectsPresets,
|
||
Properties,
|
||
Tracker,
|
||
Wiggler,
|
||
Smoother,
|
||
MotionSketch,
|
||
Paint,
|
||
Brushes,
|
||
Markers,
|
||
ContentAwareFill,
|
||
CreateNullsFromPaths,
|
||
VrCompEditor,
|
||
],
|
||
),
|
||
),
|
||
),
|
||
tabs(&[Timeline, RenderQueue, Progress], 0),
|
||
),
|
||
"Standard" => vsplit(
|
||
Ratio(0.56),
|
||
hsplit(
|
||
FixedFirst(300.0),
|
||
tabs(&[Project, EffectControls], 0),
|
||
hsplit(FixedSecond(290.0), tabs(&[Composition, Layer], 0), right(&[Info, Audio], &[Preview, EffectsPresets])),
|
||
),
|
||
tabs(&[Timeline, RenderQueue], 0),
|
||
),
|
||
// Default (as in After Effects): Project/Effect Controls | Composition over the Timeline,
|
||
// and a full-height right column: a short Preview frame above the Properties frame.
|
||
_ => hsplit(
|
||
FixedSecond(300.0),
|
||
vsplit(
|
||
Ratio(0.56),
|
||
hsplit(FixedFirst(300.0), tabs(&[Project, EffectControls], 0), tabs(&[Composition, Layer], 0)),
|
||
tabs(&[Timeline, RenderQueue], 0),
|
||
),
|
||
vsplit(FixedFirst(PREVIEW_FRAME), tabs(&[Preview], 0), tabs(&[Properties, Align, Audio, EffectsPresets], 0)),
|
||
),
|
||
}
|
||
}
|
||
|
||
/// Queries on a workspace that EffectCraft's menus, commands and panels ask.
|
||
pub trait WorkspaceExt {
|
||
/// `p` is in the docked tree.
|
||
fn is_docked(&self, p: PanelKind) -> bool;
|
||
/// `p` is in a floating window.
|
||
fn is_floating(&self, p: PanelKind) -> bool;
|
||
/// `p` is open, docked or floating.
|
||
fn is_open(&self, p: PanelKind) -> bool;
|
||
/// `p` shows: the front tab of its group, an open stacked panel, not in a minimized window.
|
||
fn is_visible(&self, p: PanelKind) -> bool;
|
||
/// The panels of the tab group holding `p` (a stacked panel is a group of its own).
|
||
fn group_of(&self, p: PanelKind) -> Vec<PanelKind>;
|
||
/// Every open panel, docked first.
|
||
fn panels(&self) -> Vec<PanelKind>;
|
||
}
|
||
|
||
pub(crate) fn node_panels(node: &Node<PanelKind>, out: &mut Vec<PanelKind>) {
|
||
match node {
|
||
Node::Split { first, second, .. } => {
|
||
node_panels(first, out);
|
||
node_panels(second, out);
|
||
}
|
||
Node::Tabs { panels, .. } => out.extend(panels.iter().copied()),
|
||
Node::Stack { entries } => out.extend(entries.iter().map(|e| e.panel)),
|
||
Node::Dock { columns, .. } => {
|
||
for group in columns.iter().flat_map(|c| c.groups.iter()) {
|
||
out.extend(group.panels.iter().copied());
|
||
}
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
fn node_group(node: &Node<PanelKind>, p: PanelKind) -> Option<Vec<PanelKind>> {
|
||
match node {
|
||
Node::Split { first, second, .. } => node_group(first, p).or_else(|| node_group(second, p)),
|
||
Node::Tabs { panels, .. } => panels.contains(&p).then(|| panels.clone()),
|
||
Node::Stack { entries } => entries.iter().any(|e| e.panel == p).then(|| vec![p]),
|
||
Node::Dock { columns, .. } => columns.iter().flat_map(|c| c.groups.iter()).find(|g| g.panels.contains(&p)).map(|g| g.panels.clone()),
|
||
_ => None,
|
||
}
|
||
}
|
||
|
||
impl WorkspaceExt for Workspace {
|
||
fn is_docked(&self, p: PanelKind) -> bool {
|
||
self.layout.root.as_ref().is_some_and(|root| node_group(root, p).is_some())
|
||
}
|
||
fn is_floating(&self, p: PanelKind) -> bool {
|
||
self.layout.floating.iter().any(|w| w.contains(&p))
|
||
}
|
||
fn is_open(&self, p: PanelKind) -> bool {
|
||
self.layout.contains(&p)
|
||
}
|
||
fn is_visible(&self, p: PanelKind) -> bool {
|
||
self.layout.panel_state(&p) == PanelState::Front
|
||
}
|
||
fn group_of(&self, p: PanelKind) -> Vec<PanelKind> {
|
||
self.layout.root.iter().chain(self.layout.floating.iter().map(|w| &w.root)).find_map(|node| node_group(node, p)).unwrap_or_default()
|
||
}
|
||
fn panels(&self) -> Vec<PanelKind> {
|
||
let mut out = Vec::new();
|
||
for node in self.layout.root.iter().chain(self.layout.floating.iter().map(|w| &w.root)) {
|
||
node_panels(node, &mut out);
|
||
}
|
||
out
|
||
}
|
||
}
|
||
|
||
/// Every panel a workspace names: open, or closed with a recorded place.
|
||
pub fn referenced_panels(workspace: &Workspace) -> Vec<PanelKind> {
|
||
let mut out = workspace.panels();
|
||
out.extend(workspace.hidden.iter().map(|(p, _)| *p));
|
||
if let Some(saved) = &workspace.saved {
|
||
for node in saved.root.iter().chain(saved.floating.iter().map(|w| &w.root)) {
|
||
node_panels(node, &mut out);
|
||
}
|
||
}
|
||
out
|
||
}
|
||
|
||
/// The automation id of the gap below stacked panel `p`: `dock.gutter.<path>s<i>`, with the
|
||
/// stack's split path (`a`/`b` per level) and the entry's index.
|
||
pub fn stack_gutter_id(layout: &Layout, p: PanelKind) -> Option<String> {
|
||
fn rec(node: &Node<PanelKind>, p: PanelKind, path: &mut String, depth: usize) -> Option<String> {
|
||
if depth > craft_ui::docking::MAX_DEPTH {
|
||
return None;
|
||
}
|
||
match node {
|
||
Node::Split { first, second, .. } => {
|
||
path.push('a');
|
||
if let Some(id) = rec(first, p, path, depth + 1) {
|
||
return Some(id);
|
||
}
|
||
path.pop();
|
||
path.push('b');
|
||
let found = rec(second, p, path, depth + 1);
|
||
path.pop();
|
||
found
|
||
}
|
||
Node::Stack { entries } => entries.iter().position(|e| e.panel == p).map(|i| format!("dock.gutter.{path}s{i}")),
|
||
_ => None,
|
||
}
|
||
}
|
||
rec(layout.root.as_ref()?, p, &mut String::new(), 0)
|
||
}
|
||
|
||
/// One document a panel shows as a tab of its own (the Timeline: one tab per open comp, as in
|
||
/// After Effects).
|
||
#[derive(Debug, Clone, PartialEq)]
|
||
pub struct DocTab {
|
||
pub id: u64,
|
||
pub title: String,
|
||
/// The comp's label colour.
|
||
pub swatch: egui::Color32,
|
||
/// The document the panel shows now.
|
||
pub active: bool,
|
||
}
|
||
|
||
/// What the Timeline's comp tabs did this frame.
|
||
#[derive(Debug, Clone, PartialEq)]
|
||
pub enum DocAction {
|
||
/// Show comp `id`.
|
||
Activate(u64),
|
||
/// Close comp `id`'s Timeline (its ×, or a middle click).
|
||
Close(u64),
|
||
}
|
||
|
||
/// Room around a tab's label, as craft-ui gives its dock tabs.
|
||
const TAB_PADDING: f32 = 24.0;
|
||
/// Width of the » button that lists the comp tabs with no room in the strip.
|
||
const DOC_OVERFLOW: f32 = 22.0;
|
||
/// Room for the × after a comp's name. Every comp tab keeps it, so a tab keeps its width when it
|
||
/// is shown or hovered.
|
||
const DOC_CLOSE: f32 = 16.0;
|
||
|
||
/// A comp tab's text: the label swatch, then the name, as the panel tabs with a swatch show it.
|
||
fn doc_job(doc: &DocTab, font: &egui::FontId, color: egui::Color32) -> egui::text::LayoutJob {
|
||
let mut job = egui::text::LayoutJob::default();
|
||
job.append("\u{25a0} ", 0.0, egui::TextFormat::simple(font.clone(), doc.swatch));
|
||
job.append(&doc.title, 0.0, egui::TextFormat::simple(font.clone(), color));
|
||
job
|
||
}
|
||
|
||
/// The width of one line of `job` at the fonts' current size.
|
||
fn text_width(ctx: &egui::Context, job: egui::text::LayoutJob) -> f32 {
|
||
ctx.fonts_mut(|f| f.layout_job(job)).size().x
|
||
}
|
||
|
||
/// The width each comp tab asks for in the Timeline group's tab row.
|
||
pub fn doc_widths(ctx: &egui::Context, docs: &[DocTab], font: &egui::FontId) -> Vec<f32> {
|
||
docs.iter().map(|d| text_width(ctx, doc_job(d, font, egui::Color32::WHITE)) + TAB_PADDING + DOC_CLOSE).collect()
|
||
}
|
||
|
||
/// The × of comp tab `doc` at `rect`, clipped to `clip`; true when clicked. `shown` is the comp
|
||
/// the Timeline shows while it is the group's shown panel. Automation:
|
||
/// `panel.tab.Timeline.<comp>.close`, and `panel.tab.Timeline.close` for the shown comp's.
|
||
fn doc_close(
|
||
ui: &mut egui::Ui,
|
||
rect: Rect,
|
||
clip: Rect,
|
||
doc: &DocTab,
|
||
shown: bool,
|
||
style: &craft_ui::docking::DockStyle,
|
||
reg: &mut crate::automation::Registry,
|
||
) -> bool {
|
||
let timeline = PanelKind::Timeline.id();
|
||
let hit = ui.interact(rect.expand(2.0), egui::Id::unique(("comp-tab-close", doc.id)), Sense::click());
|
||
hit.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, hit.enabled(), "Close"));
|
||
let cc = if hit.hovered() { style.text } else { style.inactive_text };
|
||
let k = 3.5;
|
||
let painter = ui.painter().with_clip_rect(clip);
|
||
painter.line_segment([rect.center() + vec2(-k, -k), rect.center() + vec2(k, k)], Stroke::new(1.2, cc));
|
||
painter.line_segment([rect.center() + vec2(-k, k), rect.center() + vec2(k, -k)], Stroke::new(1.2, cc));
|
||
reg.add_response(&format!("panel.tab.{timeline}.{}.close", doc.id), &hit, "Close");
|
||
if shown {
|
||
reg.add_response(&format!("panel.tab.{timeline}.close"), &hit, "Close");
|
||
}
|
||
hit.clicked()
|
||
}
|
||
|
||
/// Draw the Timeline's comp tabs into `strip`, the part of the Timeline group's tab row after its
|
||
/// panel tabs. Each is a tab like the panel tabs: the comp's label swatch and name, then a ×
|
||
/// that closes the comp's Timeline: always on the shown comp while the Timeline is the group's
|
||
/// shown panel (`selected`), on the other comp tabs while the pointer is over them. Tabs that do
|
||
/// not fit go to a » menu at the end; the shown comp's tab always stays in the row. Shift+, and
|
||
/// Shift+. step through every open comp. Automation: `panel.tab.Timeline.<comp>`, the ×s (see
|
||
/// [`doc_close`]), `panel.tab.Timeline.more` for », and `panel.tab.Timeline.more.<comp>` for its
|
||
/// items.
|
||
pub fn doc_tabs(
|
||
ui: &mut egui::Ui,
|
||
strip: Rect,
|
||
docs: &[DocTab],
|
||
selected: bool,
|
||
style: &craft_ui::docking::DockStyle,
|
||
reg: &mut crate::automation::Registry,
|
||
) -> Vec<DocAction> {
|
||
let mut out = Vec::new();
|
||
let timeline = PanelKind::Timeline.id();
|
||
let widths = doc_widths(ui.ctx(), docs, &style.font);
|
||
let active = docs.iter().position(|d| d.active).unwrap_or(0);
|
||
let fit = craft_ui::tabs::fit_whole(&widths, active, strip.width(), DOC_OVERFLOW);
|
||
let clip = strip.intersect(ui.clip_rect());
|
||
let mid = strip.center().y;
|
||
let mut x = strip.min.x;
|
||
for (index, width) in &fit.shown {
|
||
let Some(doc) = docs.get(*index) else { continue };
|
||
let tab = Rect::from_min_size(pos2(x, strip.min.y), vec2(*width, strip.height()));
|
||
x += width;
|
||
let on = selected && doc.active;
|
||
let color = if on { style.text } else { style.inactive_text };
|
||
let mut job = doc_job(doc, &style.font, color);
|
||
job.wrap = egui::text::TextWrapping {
|
||
max_width: (tab.width() - TAB_PADDING - DOC_CLOSE).max(0.0),
|
||
max_rows: 1,
|
||
break_anywhere: true,
|
||
overflow_character: Some('\u{2026}'),
|
||
};
|
||
let galley = ui.fonts_mut(|f| f.layout_job(job));
|
||
let label_end = tab.min.x + TAB_PADDING * 0.5 + galley.size().x;
|
||
let resp = craft_ui::tabs::Tab::new(egui::Id::unique(("comp-tab", doc.id)), &doc.title, on).focus_stroke(Stroke::new(1.0, style.accent)).show_at(
|
||
ui,
|
||
tab,
|
||
|ui, response| {
|
||
let painter = ui.painter().with_clip_rect(tab.intersect(clip));
|
||
painter.rect_filled(tab, 0.0, if on || response.hovered() { style.active_background } else { style.tab_background });
|
||
painter.galley(pos2(tab.min.x + TAB_PADDING * 0.5, mid - galley.size().y * 0.5), galley.clone(), color);
|
||
},
|
||
);
|
||
let resp = if galley.elided { resp.on_hover_text(&doc.title) } else { resp };
|
||
reg.add_response(&format!("panel.tab.{timeline}.{}", doc.id), &resp, &doc.title);
|
||
// After the tab, so the × takes the clicks over it.
|
||
if on || ui.rect_contains_pointer(tab.intersect(clip)) {
|
||
let cr = Rect::from_center_size(pos2(label_end + DOC_CLOSE / 2.0, mid), vec2(10.0, 10.0));
|
||
if doc_close(ui, cr, tab.intersect(clip), doc, on, style, reg) {
|
||
out.push(DocAction::Close(doc.id));
|
||
}
|
||
}
|
||
if resp.clicked() {
|
||
out.push(DocAction::Activate(doc.id));
|
||
}
|
||
if resp.middle_clicked() {
|
||
out.push(DocAction::Close(doc.id));
|
||
}
|
||
}
|
||
if !fit.overflow.is_empty() && fit.overflow_width > 0.0 {
|
||
let more = Rect::from_min_size(pos2(x, strip.min.y), vec2(fit.overflow_width, strip.height()));
|
||
let resp = ui.interact(more, egui::Id::unique("comp-tabs-more"), Sense::click());
|
||
resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, resp.enabled(), "More compositions"));
|
||
reg.add_response(&format!("panel.tab.{timeline}.more"), &resp, "More compositions");
|
||
let color = if resp.hovered() { style.text } else { style.inactive_text };
|
||
ui.painter().with_clip_rect(more.intersect(clip)).text(more.center(), Align2::CENTER_CENTER, "\u{bb}", style.font.clone(), color);
|
||
egui::Popup::menu(&resp).show(|ui| {
|
||
egui::ScrollArea::vertical().max_height(360.0).show(ui, |ui| {
|
||
for index in &fit.overflow {
|
||
let Some(doc) = docs.get(*index) else { continue };
|
||
let item = ui.button(doc_job(doc, &style.font, style.text));
|
||
item.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, item.enabled(), &doc.title));
|
||
reg.add_response(&format!("panel.tab.{timeline}.more.{}", doc.id), &item, &doc.title);
|
||
if item.clicked() {
|
||
out.push(DocAction::Activate(doc.id));
|
||
ui.close();
|
||
}
|
||
}
|
||
});
|
||
});
|
||
}
|
||
out
|
||
}
|
||
|
||
/// A panel lock button (Composition viewers and the Timeline keep their comp while locked,
|
||
/// Effect Controls its layer): a closed padlock while locked, an open one while unlocked.
|
||
/// Returns true when clicked. Automation: `panel.tab.<panel>.lock`.
|
||
pub fn lock_button(ui: &mut egui::Ui, rect: Rect, panel: PanelKind, locked: bool, t: &Tokens, reg: &mut crate::automation::Registry) -> bool {
|
||
let resp = ui.interact(rect, egui::Id::unique(("tab-lock", panel.id())), Sense::click());
|
||
let color = if locked {
|
||
t.tab_text_active
|
||
} else if resp.hovered() {
|
||
t.tab_text
|
||
} else {
|
||
t.text_faint
|
||
};
|
||
icons::paint(ui.painter(), rect.shrink(2.0), if locked { Icon::Lock } else { Icon::LockOpen }, color);
|
||
reg.add_response(&format!("panel.tab.{}.lock", panel.id()), &resp, if locked { "Unlock" } else { "Lock" });
|
||
crate::widgets::focus_outline(ui, &resp, t);
|
||
resp.clicked()
|
||
}
|
||
|
||
/// Placeholder body for panels that are not implemented yet.
|
||
pub fn placeholder(ui: &mut egui::Ui, rect: Rect, t: &Tokens, text: &str) {
|
||
ui.painter().text(rect.center(), Align2::CENTER_CENTER, text, Tokens::ui(12.0), t.text_faint);
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
use PanelKind::*;
|
||
use craft_ui::docking::{Action, Placement, Zone};
|
||
|
||
fn apply(w: &mut Workspace, action: Action<PanelKind>) {
|
||
w.apply(action, permissions).unwrap();
|
||
}
|
||
|
||
/// Only the title changes: existing saved workspace layouts still deserialize.
|
||
#[test]
|
||
fn scopes_label_is_descriptive_and_its_saved_identity_stays_compatible() {
|
||
let panel: PanelKind = serde_json::from_str("\"LumetriScopes\"").unwrap();
|
||
assert_eq!(panel, LumetriScopes);
|
||
assert_eq!(panel.title(), "Video Scopes");
|
||
assert_eq!(panel.id(), "LumetriScopes");
|
||
assert_eq!(serde_json::to_string(&panel).unwrap(), "\"LumetriScopes\"");
|
||
}
|
||
|
||
#[test]
|
||
fn after_effects_workspaces_exist_with_their_core_panels() {
|
||
for name in WORKSPACES {
|
||
let w = Workspace::new(workspace(name));
|
||
w.validate().unwrap_or_else(|e| panic!("{name}: {e}"));
|
||
assert!(w.is_docked(Composition), "{name}");
|
||
if *name != "Undocked Panels" {
|
||
assert!(w.is_docked(Timeline), "{name}");
|
||
}
|
||
}
|
||
let all = Workspace::new(workspace("All Panels"));
|
||
for p in PanelKind::ALL.iter().filter(|p| !matches!(p, ScriptConsole | EssentialGraphics | MaskInterpolation)) {
|
||
assert!(all.is_open(*p), "All Panels lacks {p:?}");
|
||
}
|
||
// No built-in workspace uses accordions: right columns are frames split vertically.
|
||
fn no_stack(node: &Node<PanelKind>) -> bool {
|
||
match node {
|
||
Node::Split { first, second, .. } => no_stack(first) && no_stack(second),
|
||
Node::Stack { .. } => false,
|
||
_ => true,
|
||
}
|
||
}
|
||
for name in WORKSPACES {
|
||
let layout = workspace(name);
|
||
assert!(layout.root.iter().chain(layout.floating.iter().map(|f| &f.root)).all(no_stack), "{name}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn default_right_column_is_a_short_preview_frame_over_the_properties_frame() {
|
||
let default = workspace("Default");
|
||
let Some(Node::Split { second, size: SplitSize::FixedSecond(300.0), .. }) = &default.root else { panic!("{default:?}") };
|
||
let Node::Split { axis: SplitAxis::Vertical, size: SplitSize::FixedFirst(PREVIEW_FRAME), first, second } = second.as_ref() else {
|
||
panic!("{second:?}")
|
||
};
|
||
assert_eq!(**first, tabs(&[Preview], 0));
|
||
assert_eq!(**second, tabs(&[Properties, Align, Audio, EffectsPresets], 0));
|
||
let mut w = Workspace::new(default);
|
||
assert!(w.is_visible(Preview) && w.is_visible(Properties) && !w.is_visible(Align));
|
||
// The Properties frame takes tabs; the Preview frame stays a frame of its own.
|
||
apply(&mut w, Action::Move { panel: Project, anchor: Properties, placement: Placement::Tab { before: None } });
|
||
assert_eq!(w.group_of(Project), vec![Properties, Align, Audio, EffectsPresets, Project]);
|
||
assert_eq!(w.group_of(Preview), vec![Preview]);
|
||
}
|
||
|
||
#[test]
|
||
fn panels_split_off_and_join_tab_groups() {
|
||
let mut w = docked(hsplit(SplitSize::FixedFirst(300.0), tabs(&[Project, EffectControls], 0), tabs(&[Composition, Layer], 0)));
|
||
apply(&mut w, Action::Move { panel: EffectControls, anchor: Composition, placement: Placement::Split(Zone::Right) });
|
||
assert_eq!(w.group_of(EffectControls), vec![EffectControls]);
|
||
assert_eq!(w.group_of(Project), vec![Project]);
|
||
apply(&mut w, Action::Move { panel: EffectControls, anchor: Composition, placement: Placement::Tab { before: Some(Layer) } });
|
||
assert_eq!(w.group_of(Composition), vec![Composition, EffectControls, Layer]);
|
||
assert!(w.is_visible(EffectControls));
|
||
// A rejected move (onto itself, onto a closed panel) changes nothing.
|
||
let before = w.clone();
|
||
assert!(w.apply(Action::Move { panel: Project, anchor: Info, placement: Placement::Split(Zone::Left) }, permissions).is_err());
|
||
assert_eq!(w, before);
|
||
}
|
||
|
||
#[test]
|
||
fn closed_panels_reopen_where_they_were_docked_or_floating() {
|
||
let mut w = Workspace::new(workspace("Standard"));
|
||
apply(&mut w, Action::Close { panel: Info });
|
||
assert!(!w.is_open(Info));
|
||
w.set_visible(Info, true, None, permissions).unwrap();
|
||
assert_eq!(w.group_of(Info), vec![Info, Audio]);
|
||
apply(&mut w, Action::Float { panel: Audio, rect: [40.0, 50.0, 300.0, 200.0] });
|
||
apply(&mut w, Action::Close { panel: Audio });
|
||
w.set_visible(Audio, true, None, permissions).unwrap();
|
||
assert!(w.is_floating(Audio));
|
||
// Closing an earlier, inactive tab keeps the shown panel.
|
||
let mut w = docked(tabs(&[Properties, Align, EffectsPresets], 2));
|
||
apply(&mut w, Action::Close { panel: Properties });
|
||
assert!(w.is_visible(EffectsPresets));
|
||
// A panel never laid out opens beside its anchor.
|
||
apply(&mut w, Action::Open { panel: History, anchor: Some(Align) });
|
||
assert_eq!(w.group_of(History), vec![Align, EffectsPresets, History]);
|
||
assert_eq!(referenced_panels(&w).iter().filter(|p| **p == Properties).count(), 1, "the closed panel is still known");
|
||
}
|
||
}
|