f67d38b35cc5
shared_docking_ui.rs
//! Shared docking preserves FilmCraft document state and legacy workspace files.
use craft_ui::docking::{Action, DockArea, Hit, Node, Placement, ResizeEdge, Zone};
use craft_ui::layout::{SplitAxis, SplitSize};
use egui::{Event, Modifiers, PointerButton, Rect, pos2, vec2};
use egui_kittest::Harness;
use egui_kittest::kittest::{NodeT, Queryable};
use filmcraft_engine::Session;
use filmcraft_ui_egui::{
FilmcraftApp,
dock::{self, Layout, LayoutExt, PanelKind},
menus,
};
use serde_json::json;
fn tabs(panels: &[PanelKind], active: usize) -> Node<PanelKind> {
Node::Tabs { panels: panels.to_vec(), active }
}
fn split(vertical: bool, size: SplitSize, a: Node<PanelKind>, b: Node<PanelKind>) -> Node<PanelKind> {
Node::Split { axis: if vertical { SplitAxis::Vertical } else { SplitAxis::Horizontal }, size, first: Box::new(a), second: Box::new(b) }
}
fn root(node: Node<PanelKind>) -> Layout {
Layout { root: Some(node), floating: vec![] }
}
/// Whether a panel is in the docked frame tree (not a floating window).
trait Docked {
fn docked(&self, panel: PanelKind) -> bool;
}
impl Docked for Layout {
fn docked(&self, panel: PanelKind) -> bool {
Layout { root: self.root.clone(), floating: vec![] }.contains(&panel)
}
}
fn layout() -> Layout {
root(split(
false,
SplitSize::Ratio(0.3),
tabs(&[PanelKind::Project, PanelKind::Info, PanelKind::History], 1),
tabs(&[PanelKind::Source, PanelKind::Program], 1),
))
}
#[test]
fn active_tab_underline_follows_selection_even_when_another_tab_is_hovered() {
let mut session = Session::default();
session.prefs.appearance.accessible_contrast = true;
let mut app = FilmcraftApp::new(session);
app.ui.dock = layout();
let mut h = Harness::builder().with_size(vec2(1200.0, 760.0)).build_eframe(move |_| app);
for _ in 0..4 {
step(&mut h);
}
let underlined = |h: &Harness<'_, FilmcraftApp>, panel: PanelKind| {
let tab = rect(h, &format!("panel.tab.{}", panel.id()));
h.output().shapes.iter().find_map(|shape| match &shape.shape {
egui::Shape::Text(text) if tab.contains(text.pos) && text.galley.text() == panel.title() => {
Some(text.galley.job.sections.iter().any(|section| section.format.underline.width > 0.0))
}
_ => None,
})
};
assert_eq!(underlined(&h, PanelKind::Info), Some(true));
assert_eq!(underlined(&h, PanelKind::History), Some(false));
click(&mut h, "panel.tab.History");
let inactive = rect(&h, "panel.tab.Info").center();
h.event(Event::PointerMoved(inactive));
step(&mut h);
assert_eq!(underlined(&h, PanelKind::Info), Some(false));
assert_eq!(underlined(&h, PanelKind::History), Some(true));
}
#[test]
fn shared_transactions_keep_selection_and_reject_invalid_moves_atomically() {
let mut layout = layout();
layout.apply(Action::Close { panel: PanelKind::Project }).unwrap();
assert!(layout.is_visible(PanelKind::Info));
let before = layout.clone();
for action in [
Action::Move { panel: PanelKind::Info, anchor: PanelKind::Tools, placement: Placement::Split(Zone::Left) },
Action::Float { panel: PanelKind::Info, rect: [0.0, 0.0, f32::NAN, 100.0] },
Action::Move { panel: PanelKind::Info, anchor: PanelKind::Program, placement: Placement::Tab { before: Some(PanelKind::Tools) } },
] {
assert!(layout.apply(action).is_err());
assert_eq!(layout, before);
}
layout.apply(Action::Float { panel: PanelKind::Info, rect: [50.0, 50.0, 400.0, 300.0] }).unwrap();
layout.apply(Action::Move { panel: PanelKind::Info, anchor: PanelKind::Program, placement: Placement::Split(Zone::Bottom) }).unwrap();
assert!(layout.floating.is_empty());
assert!(layout.is_visible(PanelKind::Info));
}
#[test]
fn builtin_and_legacy_workspace_shapes_roundtrip_and_save_floating() {
for name in dock::WORKSPACES {
let layout = dock::workspace(name);
for entry in
[json!({"name": name, "workspace": dock::Workspace::new(layout.clone())}), json!({"name": name, "layout": legacy(layout.root.as_ref().unwrap())})]
{
let prefs: dock::WorkspacePrefs = serde_json::from_value(json!({"saved": [entry], "current": name})).unwrap();
let loaded = dock::saved_docking(&prefs, name);
loaded.validate().unwrap();
assert_eq!(loaded, layout);
assert!(serde_json::to_value(&prefs).unwrap()["saved"][0].get("floating").is_none());
}
}
let dir = std::env::temp_dir().join(format!("filmcraft-shared-dock-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let mut session = Session::default();
session.prefs_path = Some(dir.join("preferences.json"));
let mut app = FilmcraftApp::new(session);
let ctx = egui::Context::default();
app.ui.dock = layout();
menus::invoke(&mut app, &ctx, "window.floatPanel", json!({"panel": "Info", "rect": [45, 65, 420, 320]})).unwrap();
menus::invoke(&mut app, &ctx, "window.workspace.saveAs", json!({"name": "Floating test"})).unwrap();
let prefs = dock::WorkspacePrefs::load(&dir.join(dock::WORKSPACES_FILE));
let restored = dock::saved_docking(&prefs, "Floating test");
assert_eq!(restored, app.ui.dock);
// Earlier versions read `layout` and `floating`.
assert!(!prefs.saved[0].layout.is_null() && !prefs.saved[0].workspace.is_null());
assert_eq!(prefs.saved[0].floating[0]["panels"], json!(["Info"]));
let mut restarted_session = Session::default();
restarted_session.prefs_path = Some(dir.join("preferences.json"));
let restarted = FilmcraftApp::new(restarted_session);
let mut h = Harness::builder().with_size(vec2(1200.0, 760.0)).build_eframe(move |_| restarted);
for _ in 0..4 {
step(&mut h);
}
assert_eq!(h.state().ui.dock, restored);
std::fs::remove_dir_all(dir).unwrap();
}
#[test]
fn legacy_effects_workspace_drops_only_the_known_inactive_duplicate() {
let expected = dock::workspace("Effects");
let mut legacy_tree = expected.root.clone().unwrap();
fn duplicate(node: &mut Node<PanelKind>) {
match node {
Node::Tabs { panels, active } if panels.as_slice() == [PanelKind::EssentialGraphics] => {
panels.insert(0, PanelKind::EffectControls);
*active = 1;
}
Node::Split { first, second, .. } => {
duplicate(first);
duplicate(second);
}
_ => {}
}
}
duplicate(&mut legacy_tree);
let prefs: dock::WorkspacePrefs =
serde_json::from_value(json!({"saved": [{"name": "Historical Effects", "layout": legacy(&legacy_tree)}], "current": "Historical Effects"})).unwrap();
assert_eq!(dock::saved_docking(&prefs, "Historical Effects"), expected);
}
/// The frame tree as FilmCraft wrote it before its workspaces were craft-ui workspaces.
fn legacy(node: &Node<PanelKind>) -> serde_json::Value {
match node {
Node::Tabs { panels, active } => json!({"Tabs": {"panels": panels, "active": active}}),
Node::Split { axis, size, first, second } => json!({"Split": {
"vertical": *axis == SplitAxis::Vertical,
"size": match size {
SplitSize::Ratio(v) => json!({"Ratio": v}),
SplitSize::FixedFirst(v) => json!({"FixedA": v}),
SplitSize::FixedSecond(v) => json!({"FixedB": v}),
},
"a": legacy(first),
"b": legacy(second),
}}),
_ => unreachable!(),
}
}
fn step(h: &mut Harness<'_, FilmcraftApp>) {
let ctx = h.ctx.clone();
let mut input = std::mem::take(h.input_mut());
eframe::App::raw_input_hook(h.state_mut(), &ctx, &mut input);
*h.input_mut() = input;
h.step();
}
fn rect(h: &Harness<'_, FilmcraftApp>, id: &str) -> Rect {
let element = h.state().auto.find(id).unwrap_or_else(|| panic!("missing {id}"));
Rect::from_min_size(pos2(element.rect[0], element.rect[1]), vec2(element.rect[2], element.rect[3]))
}
fn click(h: &mut Harness<'_, FilmcraftApp>, id: &str) {
let pos = rect(h, id).center();
h.event(Event::PointerMoved(pos));
step(h);
for pressed in [true, false] {
h.event(Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
step(h);
}
for _ in 0..3 {
step(h);
}
}
fn drag(h: &mut Harness<'_, FilmcraftApp>, from: egui::Pos2, to: egui::Pos2, modifiers: Modifiers) {
h.event(Event::ModifiersChanged(modifiers));
h.event(Event::PointerMoved(from));
step(h);
h.event(Event::PointerButton { pos: from, button: PointerButton::Primary, pressed: true, modifiers });
step(h);
for fraction in [0.05, 0.25, 0.5, 0.75, 1.0] {
h.event(Event::PointerMoved(from.lerp(to, fraction)));
step(h);
}
h.event(Event::PointerButton { pos: to, button: PointerButton::Primary, pressed: false, modifiers });
step(h);
h.event(Event::ModifiersChanged(Modifiers::NONE));
for _ in 0..3 {
step(h);
}
}
fn keyboard_resize(h: &mut Harness<'_, FilmcraftApp>, grip_id: egui::Id) {
let before_keys = h.state().ui.dock.floating[0].rect;
for key in [egui::Key::ArrowRight, egui::Key::ArrowDown] {
for pressed in [true, false] {
h.event(Event::Key { key, physical_key: None, pressed, repeat: false, modifiers: Modifiers::NONE });
step(h);
}
}
assert_eq!(h.state().ui.dock.floating[0].rect[2], before_keys[2] + 8.0);
assert_eq!(h.state().ui.dock.floating[0].rect[3], before_keys[3] + 8.0);
h.event(Event::Key { key: egui::Key::Tab, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE });
step(h);
h.event(Event::Key { key: egui::Key::Tab, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE });
for _ in 0..3 {
step(h);
}
assert_ne!(h.ctx.memory(|memory| memory.focused()), Some(grip_id));
}
fn maximize_frame_round_trip(h: &mut Harness<'_, FilmcraftApp>, action_log: &mut Vec<serde_json::Value>) {
let saved_root = h.state().ui.dock.clone();
let saved_floating = h.state().ui.dock.floating.clone();
let ctx = h.ctx.clone();
// Maximize Frame fills the area with a docked frame
h.state_mut().ui.focused = PanelKind::Program;
menus::invoke(h.state_mut(), &ctx, "window.maximizeFrame", json!({})).unwrap();
for _ in 0..3 {
step(h);
}
assert!(rect(h, "panel.Program").width() > 1000.0);
action_log.push(action_state(h, "maximized"));
assert_eq!(h.state().ui.dock, saved_root);
assert_eq!(h.state().ui.dock.floating, saved_floating);
menus::invoke(h.state_mut(), &ctx, "window.maximizeFrame", json!({})).unwrap();
for _ in 0..3 {
step(h);
}
assert_eq!(h.state().ui.dock.floating, saved_floating);
}
#[test]
fn real_panel_drag_merges_splits_floats_and_redocks_without_editing_documents() {
let mut session = Session::default();
session.execute("file.openDemoProject", json!({})).unwrap();
let app = FilmcraftApp::new(session);
let snapshots = std::env::var_os("CRAFT_UI_DOCKING_SNAPSHOT_DIR").map(std::path::PathBuf::from);
let mut builder = Harness::builder().with_size(vec2(1200.0, 760.0));
if snapshots.is_some() {
builder = builder.wgpu();
}
let mut h = builder.build_eframe(move |_| app);
for _ in 0..4 {
step(&mut h);
}
h.state_mut().ui.dock = root(split(true, SplitSize::Ratio(0.62), layout().root.unwrap(), tabs(&[PanelKind::Timeline], 0)));
for _ in 0..3 {
step(&mut h);
}
let project = h.state().session.project.clone();
let mut action_log = vec![action_state(&h, "start")];
let playheads = h.state().session.state.playheads.clone();
let from = rect(&h, "panel.tab.Info").center();
let to = rect(&h, "panel.Program").center();
drag(&mut h, from, to, Modifiers::NONE);
assert!(h.state().ui.dock.is_visible(PanelKind::Info));
assert!(same_group(&h.state().ui.dock, PanelKind::Info, PanelKind::Program));
action_log.push(action_state(&h, "merged"));
let from = rect(&h, "panel.tab.Info").center();
let before = rect(&h, "panel.tab.Source");
drag(&mut h, from, pos2(before.left() + 2.0, before.center().y), Modifiers::NONE);
assert_eq!(tabs_containing(&h.state().ui.dock, PanelKind::Info).first(), Some(&PanelKind::Info));
action_log.push(action_state(&h, "reordered"));
let from = rect(&h, "panel.tab.Info").center();
let left = rect(&h, "panel.History");
// Activate a visible sibling after the source left its original group.
let to = pos2(left.left() + 8.0, left.center().y);
drag(&mut h, from, to, Modifiers::NONE);
assert!(h.state().ui.dock.is_visible(PanelKind::Info));
assert!(!same_group(&h.state().ui.dock, PanelKind::Info, PanelKind::History));
assert!(!same_group(&h.state().ui.dock, PanelKind::Info, PanelKind::Program));
action_log.push(action_state(&h, "split"));
click(&mut h, "panel.tab.Program");
assert!(h.state().auto.elements.iter().any(|element| element.id.starts_with("timeline.clip.")));
assert!(h.state().auto.find("program.transport.playhead.stepForward").is_some());
let from = rect(&h, "panel.tab.Info").center();
drag(&mut h, from, pos2(700.0, 400.0), Modifiers::COMMAND);
assert_eq!(h.state().ui.dock.floating.len(), 1);
assert_eq!(h.query_all_by_label("Resize panel window").next().unwrap().accesskit_node().role(), egui::accesskit::Role::Button);
action_log.push(action_state(&h, "floated"));
let original = h.state().ui.dock.floating[0].rect;
let grip = rect(&h, "panel.float.0.resize").center();
drag(&mut h, grip, grip + vec2(36.0, 24.0), Modifiers::NONE);
assert!(h.state().ui.dock.floating[0].rect[2] > original[2] + 25.0);
assert!(h.state().ui.dock.floating[0].rect[3] > original[3] + 15.0);
action_log.push(action_state(&h, "resized"));
let grip_id = DockArea::<PanelKind>::hit_id(filmcraft_ui_egui::dock_area_id(), &Hit::Resize(PanelKind::Info, ResizeEdge::BottomRight));
// A pointer drag leaves no focus on the grip; focused from the keyboard, it takes arrows.
assert_ne!(h.ctx.memory(|memory| memory.focused()), Some(grip_id));
h.ctx.memory_mut(|memory| memory.request_focus(grip_id));
step(&mut h);
assert_eq!(h.ctx.memory(|memory| memory.focused()), Some(grip_id));
keyboard_resize(&mut h, grip_id);
action_log.push(action_state(&h, "keyboard-resized"));
let resized = h.state().ui.dock.floating[0].rect;
let header = rect(&h, "panel.float.0.move");
let from = pos2(header.right() - 24.0, header.center().y);
drag(&mut h, from, from - vec2(24.0, 18.0), Modifiers::NONE);
assert!(h.state().ui.dock.floating[0].rect[0] < resized[0] - 15.0);
assert!(h.state().ui.dock.floating[0].rect[1] < resized[1] - 10.0);
action_log.push(action_state(&h, "moved"));
maximize_frame_round_trip(&mut h, &mut action_log);
if let Some(directory) = &snapshots {
std::fs::create_dir_all(directory).unwrap();
h.render().unwrap().save(directory.join("filmcraft-floating.png")).unwrap();
}
let from = rect(&h, "panel.tab.Info").center();
let to = rect(&h, "panel.History").center();
drag(&mut h, from, to, Modifiers::NONE);
assert!(h.state().ui.dock.floating.is_empty());
action_log.push(action_state(&h, "redocked"));
assert!(std::sync::Arc::ptr_eq(&project, &h.state().session.project));
assert_eq!(playheads, h.state().session.state.playheads);
let playhead = h.state().session.playhead();
click(&mut h, "program.transport.playhead.stepForward");
assert!(h.state().session.playhead() > playhead);
assert!(h.state().auto.elements.iter().any(|element| element.id.starts_with("timeline.clip.")));
action_log.push(action_state(&h, "program-step-forward"));
if let Some(directory) = &snapshots {
std::fs::write(directory.join("filmcraft-actions.json"), serde_json::to_vec_pretty(&action_log).unwrap()).unwrap();
}
if let Some(directory) = &snapshots {
h.render().unwrap().save(directory.join("filmcraft-redocked.png")).unwrap();
}
assert!(std::sync::Arc::ptr_eq(&project, &h.state().session.project));
assert!(h.state().ui_error.is_none());
}
#[test]
fn dropping_on_the_window_edge_docks_beside_the_whole_workspace() {
let mut app = FilmcraftApp::new(Session::default());
app.ui.dock = layout();
let mut h = Harness::builder().with_size(vec2(1200.0, 760.0)).build_eframe(move |_| app);
for _ in 0..4 {
step(&mut h);
}
let from = rect(&h, "panel.tab.Info").center();
let leftmost = rect(&h, "panel.Info");
// The outer edge of the leftmost group: without the window-edge zone this splits only that group.
drag(&mut h, from, pos2(leftmost.left() + 2.0, leftmost.center().y), Modifiers::NONE);
assert_eq!(
h.state().ui.dock,
root(split(
false,
SplitSize::Ratio(0.25),
tabs(&[PanelKind::Info], 0),
split(false, SplitSize::Ratio(0.3), tabs(&[PanelKind::Project, PanelKind::History], 1), tabs(&[PanelKind::Source, PanelKind::Program], 1)),
))
);
}
/// A release over no drop target (the menu bar, the gap between two groups) cancels the drag:
/// nothing floats and nothing moves. Only Ctrl/Cmd or leaving the window floats.
#[test]
fn a_release_over_no_target_cancels_the_drag() {
let mut app = FilmcraftApp::new(Session::default());
app.ui.dock = layout();
let mut h = Harness::builder().with_size(vec2(1200.0, 760.0)).build_eframe(move |_| app);
for _ in 0..4 {
step(&mut h);
}
let before = h.state().ui.dock.clone();
let info = rect(&h, "panel.Info");
for to in [pos2(600.0, 10.0), pos2(info.right() + 2.0, info.center().y)] {
let from = rect(&h, "panel.tab.Info").center();
drag(&mut h, from, to, Modifiers::NONE);
assert_eq!(h.state().ui.dock, before, "release at {to:?}");
}
}
#[test]
fn dock_panel_without_anchor_docks_along_a_workspace_edge() {
let mut app = FilmcraftApp::new(Session::default());
app.ui.dock = layout();
let ctx = egui::Context::default();
menus::invoke(&mut app, &ctx, "window.dockPanel", json!({"panel": "Program", "zone": "bottom"})).unwrap();
let Some(Node::Split { axis: SplitAxis::Vertical, size: SplitSize::Ratio(ratio), first, second }) = &app.ui.dock.root else {
panic!("root not split: {:?}", app.ui.dock)
};
assert_eq!(*ratio, 0.75);
assert_eq!(**second, tabs(&[PanelKind::Program], 0));
let a = root((**first).clone());
assert!(!a.contains(&PanelKind::Program) && a.contains(&PanelKind::Source) && a.contains(&PanelKind::Info));
// without an anchor or a side, a docked panel stays where it is
let before = app.ui.dock.clone();
let _ = menus::invoke(&mut app, &ctx, "window.dockPanel", json!({"panel": "Info", "zone": "center"}));
assert_eq!(app.ui.dock, before);
app.ui.dock = root(tabs(&[PanelKind::Project], 0));
assert!(menus::invoke(&mut app, &ctx, "window.dockPanel", json!({"panel": "Project", "zone": "left"})).is_err());
assert_eq!(app.ui.dock, root(tabs(&[PanelKind::Project], 0)));
}
fn same_group(layout: &Layout, first: PanelKind, second: PanelKind) -> bool {
tabs_containing(layout, first).contains(&second)
}
fn tabs_containing(layout: &Layout, panel: PanelKind) -> Vec<PanelKind> {
fn find(node: &Node<PanelKind>, panel: PanelKind) -> Vec<PanelKind> {
match node {
Node::Tabs { panels, .. } if panels.contains(&panel) => panels.clone(),
Node::Split { first, second, .. } => {
let found = find(first, panel);
if found.is_empty() { find(second, panel) } else { found }
}
_ => vec![],
}
}
layout.root.as_ref().map(|node| find(node, panel)).unwrap_or_default()
}
#[test]
fn docking_commands_reject_bad_geometry_and_targets_without_partial_changes() {
let mut app = FilmcraftApp::new(Session::default());
app.ui.dock = layout();
let ctx = egui::Context::default();
let before = app.ui.dock.clone();
for (id, params) in [
("window.floatPanel", json!({"panel": "Info", "rect": [1, 2, 300]})),
("window.floatPanel", json!({"panel": "Info", "rect": [1, 2, 300, 200, 7]})),
("window.floatPanel", json!({"panel": "Info", "rect": [1, 2, 1e100, 200]})),
("window.dockPanel", json!({"panel": "Info", "anchor": "Tools"})),
("window.dockPanel", json!({"panel": "Info", "anchor": "Program", "zone": 42})),
("window.dockPanel", json!({"panel": "Info", "anchor": "Program", "before": "Tools"})),
] {
assert!(menus::invoke(&mut app, &ctx, id, params.clone()).is_err(), "{id} accepted {params}");
assert_eq!(app.ui.dock, before);
assert!(app.ui.dock.floating.is_empty());
}
app.ui.dock = root(tabs(&[PanelKind::Project], 0));
assert!(menus::invoke(&mut app, &ctx, "window.floatPanel", json!({"panel": "Project", "rect": [1, 2, 300, 200]})).is_err());
}
fn action_state(h: &Harness<'_, FilmcraftApp>, action: &str) -> serde_json::Value {
json!({"action": action, "dock": h.state().ui.dock, "floating": h.state().ui.dock.floating, "focused": h.state().ui.focused})
}
#[test]
fn catalog_docking_action_supports_resize_reorder_and_floating_geometry() {
let mut app = FilmcraftApp::new(Session::default());
app.ui.dock = root(split(false, SplitSize::FixedFirst(300.0), tabs(&[PanelKind::Project, PanelKind::Info], 1), tabs(&[PanelKind::Program], 0)));
let ctx = egui::Context::default();
for action in [
Action::ResizeSplit { path: vec![], size: craft_ui::layout::SplitSize::FixedFirst(360.0) },
Action::Move { panel: PanelKind::Info, anchor: PanelKind::Project, placement: Placement::Tab { before: Some(PanelKind::Project) } },
Action::Float { panel: PanelKind::Info, rect: [20.0, 40.0, 300.0, 200.0] },
Action::MoveFloating { panel: PanelKind::Info, rect: [45.0, 65.0, 330.0, 240.0] },
] {
filmcraft_ui_egui::menus::invoke(&mut app, &ctx, "window.dockAction", json!({"action": action})).unwrap();
}
assert_eq!(app.ui.dock.floating[0].rect, [45.0, 65.0, 330.0, 240.0]);
let Some(Node::Split { size, .. }) = &app.ui.dock.root else { panic!("split lost") };
assert_eq!(*size, SplitSize::FixedFirst(360.0));
let before = json!({"dock": app.ui.dock, "floating": app.ui.dock.floating});
assert!(
filmcraft_ui_egui::menus::invoke(
&mut app,
&ctx,
"window.dockAction",
json!({"action": {
"ResizeSplit": {"path": [true, true], "size": {"Ratio": 0.5}}
}})
)
.is_err()
);
assert_eq!(json!({"dock": app.ui.dock, "floating": app.ui.dock.floating}), before);
}
#[test]
fn unreadable_floating_workspace_does_not_erase_valid_workspaces_or_current_name() {
let tree = json!({"Tabs": {"panels": ["Project"], "active": 0}});
let valid = json!({"name": "Valid", "layout": tree, "floating": [{
"panels": ["TextToSpeech", "Timeline"], "active": 0, "rect": [80, 90, 420, 320]
}]});
for (index, bad) in [
json!([{"panels": ["FuturePanel"], "active": 0, "rect": [80, 90, 420, 320]}]),
json!([{"panels": ["Info"], "active": "invalid", "rect": [80, 90, 420, 320]}]),
json!({"malformed": true}),
]
.into_iter()
.enumerate()
{
let path = std::env::temp_dir().join(format!("filmcraft-floating-isolation-{}-{index}.json", std::process::id()));
let prefs = json!({"saved": [valid.clone(), {"name": "Broken", "layout": tree, "floating": bad}], "current": "Valid"});
std::fs::write(&path, serde_json::to_vec(&prefs).unwrap()).unwrap();
let loaded = dock::WorkspacePrefs::load(&path);
assert_eq!(loaded.current, "Valid");
assert_eq!(loaded.saved.len(), 2);
let restored = dock::saved_docking(&loaded, "Valid");
restored.validate().unwrap();
assert_eq!(restored.root, Some(tabs(&[PanelKind::Project], 0)));
assert_eq!(restored.floating[0].panels().copied().collect::<Vec<_>>(), vec![PanelKind::TextToSpeech, PanelKind::Timeline]);
assert_eq!(dock::saved_docking(&loaded, "Broken"), dock::workspace("Broken"));
loaded.save(&path).unwrap();
assert_eq!(dock::WorkspacePrefs::load(&path), loaded, "saving preserves the unreadable entry for a future version");
std::fs::remove_file(path).unwrap();
}
}
#[test]
fn floating_tts_and_timeline_reveal_keeps_one_owner_and_draft_without_project_edits() {
let mut session = Session::default();
session.execute("file.openDemoProject", json!({})).unwrap();
let mut app = FilmcraftApp::new(session);
app.ui.tts.text = "Synthetic retained narration".into();
app.show_panel(PanelKind::TextToSpeech);
let project = app.session.project.clone();
let state = serde_json::to_value(&app.session.state).unwrap();
let draft = serde_json::to_value(&app.ui.tts).unwrap();
let ctx = egui::Context::default();
menus::invoke(&mut app, &ctx, "window.floatPanel", json!({"panel": "TextToSpeech", "rect": [80, 90, 420, 320]})).unwrap();
menus::invoke(
&mut app,
&ctx,
"window.dockAction",
json!({"action": Action::Move {
panel: PanelKind::Timeline, anchor: PanelKind::TextToSpeech, placement: Placement::Tab { before: None }
}}),
)
.unwrap();
app.show_panel(PanelKind::TextToSpeech);
app.show_panel(PanelKind::Timeline);
assert!(!app.ui.dock.docked(PanelKind::TextToSpeech));
assert!(!app.ui.dock.docked(PanelKind::Timeline));
assert_eq!(app.ui.dock.floating.iter().flat_map(|group| group.panels()).filter(|panel| **panel == PanelKind::TextToSpeech).count(), 1);
assert_eq!(app.ui.dock.floating.iter().flat_map(|group| group.panels()).filter(|panel| **panel == PanelKind::Timeline).count(), 1);
assert_eq!(serde_json::to_value(&app.ui.tts).unwrap(), draft);
assert!(std::sync::Arc::ptr_eq(&project, &app.session.project));
assert_eq!(serde_json::to_value(&app.session.state).unwrap(), state);
}
#[test]
fn narration_selection_reveals_covered_floating_tts_once_without_editing_the_project() {
let mut session = Session::default();
session.execute("file.openDemoProject", json!({})).unwrap();
let clip = session
.active_sequence()
.unwrap()
.audio_tracks
.iter()
.flat_map(|track| &track.items)
.find(|clip| {
session.project.item(clip.item).and_then(|item| item.as_media()).is_some_and(|media| media.info.kind == filmcraft_media::MediaKind::AudioOnly)
})
.unwrap()
.clone();
let narration = filmcraft_project::Narration {
text: "Synthetic narration behind an overlapping pane".into(),
language: "en-US".into(),
voice: filmcraft_tts::default_voice_id().into(),
pitch: filmcraft_project::VocalPitch::Default,
pace: 1.2,
speech_duration: filmcraft_time::Tick::ZERO,
};
std::sync::Arc::make_mut(&mut session.project).narrations.insert(clip.item, narration.clone());
let project = session.project.clone();
let mut app = FilmcraftApp::new(session);
app.show_panel(PanelKind::TextToSpeech);
let mut h = Harness::builder().with_size(vec2(1200.0, 760.0)).build_eframe(move |_| app);
for _ in 0..4 {
step(&mut h);
}
let ctx = h.ctx.clone();
for panel in ["TextToSpeech", "Info"] {
menus::invoke(h.state_mut(), &ctx, "window.floatPanel", json!({"panel": panel, "rect": [400, 220, 450, 360]})).unwrap();
for _ in 0..4 {
step(&mut h);
}
}
let covered = rect(&h, "panel.TextToSpeech").center();
assert!(rect(&h, "panel.Info").contains(covered));
ctx.move_to_top(window_layer(&h, PanelKind::Info));
for _ in 0..3 {
step(&mut h);
}
assert_eq!(ctx.layer_id_at(covered), Some(window_layer(&h, PanelKind::Info)), "precondition: Info really covers TTS");
h.state_mut().session.state.selection = vec![clip.id];
for _ in 0..4 {
step(&mut h);
}
let draft = h.state().ui.tts.clone();
assert_eq!(draft.text, narration.text);
assert_eq!(draft.pace, narration.pace);
assert_eq!(draft.loaded_from, Some((clip.id.0, clip.item.0)));
assert_eq!(ctx.layer_id_at(covered), Some(window_layer(&h, PanelKind::TextToSpeech)), "narration selection must bring its floating editor forward");
assert_eq!(h.state().ui.focused, PanelKind::TextToSpeech);
assert!(!h.state().ui.dock.docked(PanelKind::TextToSpeech));
assert_eq!(h.state().ui.dock.floating.iter().flat_map(|group| group.panels()).filter(|panel| **panel == PanelKind::TextToSpeech).count(), 1);
assert!(std::sync::Arc::ptr_eq(&project, &h.state().session.project));
// A reveal is one-shot: drawing the selected narration must not steal stacking
// from another pane that the user subsequently brings forward.
ctx.move_to_top(window_layer(&h, PanelKind::Info));
for _ in 0..4 {
step(&mut h);
}
assert_eq!(ctx.layer_id_at(covered), Some(window_layer(&h, PanelKind::Info)));
assert_eq!(h.state().ui.tts, draft);
menus::invoke(h.state_mut(), &ctx, "window.panel.TextToSpeech", json!({})).unwrap();
for _ in 0..4 {
step(&mut h);
}
assert_eq!(ctx.layer_id_at(covered), Some(window_layer(&h, PanelKind::TextToSpeech)));
assert_eq!(h.state().ui.tts, draft);
assert!(std::sync::Arc::ptr_eq(&project, &h.state().session.project));
// Replacing the workspace cancels a queued reveal before the next render,
// even when the destination happens to contain the same floating panel IDs.
ctx.move_to_top(window_layer(&h, PanelKind::Info));
for _ in 0..3 {
step(&mut h);
}
let saved = dock::SavedWorkspace {
name: "Reveal cancellation".into(),
workspace: serde_json::to_value(dock::Workspace::new(h.state().ui.dock.clone())).unwrap(),
..Default::default()
};
h.state_mut().workspaces.saved.push(saved);
h.state_mut().show_panel(PanelKind::TextToSpeech);
h.state_mut().set_workspace("Reveal cancellation");
for _ in 0..4 {
step(&mut h);
}
assert_eq!(ctx.layer_id_at(covered), Some(window_layer(&h, PanelKind::Info)));
assert_eq!(h.state().ui.tts, draft);
assert!(std::sync::Arc::ptr_eq(&project, &h.state().session.project));
}
/// #1985: a panel closed while floating came back docked when opened again from the Window menu;
/// it now floats again where it was. Closed while docked, it opens docked as before.
#[test]
fn a_panel_closed_while_floating_reopens_floating_where_it_was() {
let mut app = FilmcraftApp::new(Session::default());
let ctx = egui::Context::default();
menus::invoke(&mut app, &ctx, "window.floatPanel", json!({"panel": "Info", "rect": [45, 65, 420, 320]})).unwrap();
let rect = app.ui.dock.floating.iter().find(|g| g.contains(&PanelKind::Info)).unwrap().rect;
menus::invoke(&mut app, &ctx, "window.closePanel", json!({"panel": "Info"})).unwrap();
assert!(!app.ui.dock.docked(PanelKind::Info) && !app.ui.dock.floating.iter().any(|g| g.contains(&PanelKind::Info)));
menus::invoke(&mut app, &ctx, &menus::panel_command_id(PanelKind::Info), json!({})).unwrap();
let back = app.ui.dock.floating.iter().find(|g| g.contains(&PanelKind::Info)).expect("Info floats again");
assert_eq!(back.rect, rect, "where it was");
assert!(!app.ui.dock.docked(PanelKind::Info));
// docked, then closed: it opens docked
menus::invoke(&mut app, &ctx, "window.dockPanel", json!({"panel": "Info", "anchor": "Project"})).unwrap();
menus::invoke(&mut app, &ctx, "window.closePanel", json!({"panel": "Info"})).unwrap();
menus::invoke(&mut app, &ctx, &menus::panel_command_id(PanelKind::Info), json!({})).unwrap();
assert!(app.ui.dock.docked(PanelKind::Info));
assert!(!app.ui.dock.floating.iter().any(|g| g.contains(&PanelKind::Info)));
// the Timeline too, though reopening it first puts it back in its own place in the dock
menus::invoke(&mut app, &ctx, "window.floatPanel", json!({"panel": "Timeline", "rect": [60, 80, 700, 300]})).unwrap();
let rect = app.ui.dock.floating.iter().find(|g| g.contains(&PanelKind::Timeline)).unwrap().rect;
menus::invoke(&mut app, &ctx, "window.closePanel", json!({"panel": "Timeline"})).unwrap();
menus::invoke(&mut app, &ctx, &menus::panel_command_id(PanelKind::Timeline), json!({})).unwrap();
let back = app.ui.dock.floating.iter().find(|g| g.contains(&PanelKind::Timeline)).expect("the Timeline floats again");
assert_eq!(back.rect, rect);
assert!(!app.ui.dock.docked(PanelKind::Timeline));
// with nothing else docked, a reopened panel has to stay docked (the workspace keeps one
// docked panel); its floating place is kept, not lost (#2482 review)
let mut app = FilmcraftApp::new(Session::default());
menus::invoke(&mut app, &ctx, "window.floatPanel", json!({"panel": "Info", "rect": [45, 65, 420, 320]})).unwrap();
let rect = app.ui.dock.floating.iter().find(|g| g.contains(&PanelKind::Info)).unwrap().rect;
for _ in 0..64 {
let Some(p) = PanelKind::ALL.iter().copied().find(|p| app.ui.dock.docked(*p)) else { break };
if menus::invoke(&mut app, &ctx, "window.closePanel", json!({"panel": p.id()})).is_err() {
break;
}
}
let docked = PanelKind::ALL.iter().filter(|p| app.ui.dock.docked(**p)).count();
if docked > 0 {
eprintln!("SKIPPED: the dock cannot be emptied ({docked} panels stay)");
return;
}
menus::invoke(&mut app, &ctx, "window.closePanel", json!({"panel": "Info"})).unwrap();
menus::invoke(&mut app, &ctx, &menus::panel_command_id(PanelKind::Info), json!({})).unwrap();
assert!(app.ui.dock.docked(PanelKind::Info), "the only panel stays docked");
assert!(app.ui.closed_floating.iter().any(|(p, r)| *p == PanelKind::Info && *r == rect), "{:?}", app.ui.closed_floating);
}
/// craft-ui's `window.panel.*` commands and FilmCraft's own docking commands share one path.
#[test]
fn shared_dock_commands_and_filmcraft_names_move_panels() {
let mut app = FilmcraftApp::new(Session::default());
app.ui.dock = layout();
let ctx = egui::Context::default();
menus::invoke(&mut app, &ctx, "window.panel.move", json!({"panel": "Info", "anchor": "Program", "zone": "right"})).unwrap();
assert!(app.ui.dock.is_visible(PanelKind::Info) && !same_group(&app.ui.dock, PanelKind::Info, PanelKind::Program));
menus::invoke(&mut app, &ctx, "window.dockPanel", json!({"panel": "Info", "anchor": "Program", "before": "Source"})).unwrap();
assert_eq!(tabs_containing(&app.ui.dock, PanelKind::Info), vec![PanelKind::Info, PanelKind::Source, PanelKind::Program]);
menus::invoke(&mut app, &ctx, "window.floatPanel", json!({"panel": "Info"})).unwrap();
assert!(app.ui.dock.floating.iter().any(|window| window.contains(&PanelKind::Info)));
menus::invoke(&mut app, &ctx, "window.panel.close", json!({"panel": "Info"})).unwrap();
assert!(!app.ui.dock.contains(&PanelKind::Info));
assert!(menus::invoke(&mut app, &ctx, "window.panel.move", json!({"panel": "Info", "anchor": "Nowhere"})).is_err());
}
/// The layer of the floating window holding `panel`.
fn window_layer(h: &Harness<'_, FilmcraftApp>, panel: PanelKind) -> egui::LayerId {
let window = h.state().ui.dock.floating.iter().find(|window| window.contains(&panel)).unwrap();
DockArea::floating_layer(filmcraft_ui_egui::dock_area_id(), window).unwrap()
}
fn demo_harness() -> Harness<'static, FilmcraftApp> {
let mut session = Session::default();
session.execute("file.openDemoProject", json!({})).unwrap();
let app = FilmcraftApp::new(session);
let mut h = Harness::builder().with_size(vec2(1400.0, 900.0)).build_eframe(move |_| app);
for _ in 0..4 {
step(&mut h);
}
h
}
/// Clicking the Timeline's active sequence tab, in its group header, focuses the Timeline.
#[test]
fn clicking_the_active_sequence_tab_focuses_the_timeline() {
let mut h = demo_harness();
click(&mut h, "panel.tab.Project");
assert_eq!(h.state().ui.focused, PanelKind::Project);
let active = h.state().session.state.active_sequence.unwrap().0;
click(&mut h, &format!("timeline.tab.{active}"));
assert_eq!(h.state().ui.focused, PanelKind::Timeline);
}
/// Dock `panel` as a tab of `anchor`'s group, in front.
fn tab_into(h: &mut Harness<'_, FilmcraftApp>, panel: PanelKind, anchor: PanelKind) {
let ctx = h.ctx.clone();
let action = Action::Move { panel, anchor, placement: Placement::Tab { before: None } };
menus::invoke(h.state_mut(), &ctx, "window.dockAction", json!({ "action": action })).unwrap();
menus::invoke(h.state_mut(), &ctx, "window.panel.activate", json!({ "panel": panel.id() })).unwrap();
for _ in 0..3 {
step(h);
}
assert!(h.state().ui.dock.is_visible(panel) && same_group(&h.state().ui.dock, panel, anchor));
}
/// #3653: with another tab in front of the Program monitor, clicking the Timeline (its body or a
/// sequence tab) brings Program to the front, as in Premiere; the focus stays on the Timeline.
#[test]
fn clicking_the_timeline_brings_the_program_monitor_to_the_front() {
let mut h = demo_harness();
tab_into(&mut h, PanelKind::Properties, PanelKind::Program);
assert!(!h.state().ui.dock.is_visible(PanelKind::Program));
click(&mut h, "panel.tab.Project");
click(&mut h, "panel.Timeline");
let dock = &h.state().ui.dock;
assert!(dock.is_visible(PanelKind::Program), "Program stayed behind Properties");
assert!(same_group(dock, PanelKind::Program, PanelKind::Properties), "the group changed");
assert_eq!(h.state().ui.focused, PanelKind::Timeline);
click(&mut h, "panel.tab.Properties");
assert!(!h.state().ui.dock.is_visible(PanelKind::Program));
let active = h.state().session.state.active_sequence.unwrap().0;
click(&mut h, &format!("timeline.tab.{active}"));
assert!(h.state().ui.dock.is_visible(PanelKind::Program), "a sequence tab click left Program behind");
assert_eq!(h.state().ui.focused, PanelKind::Timeline);
}
/// #3653: Program sharing the Timeline's own group stays behind it, so the Timeline is not hidden
/// by a click on it.
#[test]
fn program_in_the_timeline_group_stays_behind_it() {
let mut h = demo_harness();
tab_into(&mut h, PanelKind::Program, PanelKind::Timeline);
click(&mut h, "panel.tab.Timeline");
click(&mut h, "panel.Timeline");
assert!(h.state().ui.dock.is_visible(PanelKind::Timeline), "the Timeline was hidden");
assert!(!h.state().ui.dock.is_visible(PanelKind::Program));
assert_eq!(h.state().ui.focused, PanelKind::Timeline);
}
/// #3653: a closed Program monitor stays closed when the Timeline is clicked, and a floating one is
/// left as it is.
#[test]
fn clicking_the_timeline_leaves_a_closed_or_floating_program_monitor_alone() {
let mut h = demo_harness();
let ctx = h.ctx.clone();
menus::invoke(h.state_mut(), &ctx, "window.panel.close", json!({"panel": "Program"})).unwrap();
click(&mut h, "panel.Timeline");
assert!(!h.state().ui.dock.contains(&PanelKind::Program), "a click reopened Program");
menus::invoke(h.state_mut(), &ctx, "window.panel.activate", json!({"panel": "Program"})).unwrap();
menus::invoke(h.state_mut(), &ctx, "window.floatPanel", json!({"panel": "Info", "rect": [45, 65, 420, 320]})).unwrap();
let action = Action::Move { panel: PanelKind::Program, anchor: PanelKind::Info, placement: Placement::Tab { before: None } };
menus::invoke(h.state_mut(), &ctx, "window.dockAction", json!({ "action": action })).unwrap();
menus::invoke(h.state_mut(), &ctx, "window.panel.activate", json!({"panel": "Info"})).unwrap();
for _ in 0..3 {
step(&mut h);
}
assert!(!h.state().ui.dock.docked(PanelKind::Program) && !h.state().ui.dock.is_visible(PanelKind::Program));
click(&mut h, "panel.Timeline");
assert!(h.state().ui.dock.is_visible(PanelKind::Info), "the floating window changed tab");
assert_eq!(h.state().ui.focused, PanelKind::Timeline);
}
/// No move or float may empty the frame tree, whichever unit it moves.
#[test]
fn the_last_docked_group_cannot_float_away() {
let mut app = FilmcraftApp::new(Session::default());
app.ui.dock = root(tabs(&[PanelKind::Project, PanelKind::Info], 0));
let ctx = egui::Context::default();
let before = app.ui.dock.clone();
let float = craft_ui::docking::Target::Float { rect: Some([20.0, 20.0, 300.0, 200.0]) };
for action in [Action::MoveGroup { panel: PanelKind::Project, to: float.clone() }, Action::MoveColumn { panel: PanelKind::Project, to: float.clone() }] {
let _ = menus::invoke(&mut app, &ctx, "window.dockAction", json!({ "action": action }));
assert_eq!(app.ui.dock, before);
}
assert!(menus::invoke(&mut app, &ctx, "window.panel.float", json!({"panel": "Project", "group": true})).is_err());
assert_eq!(app.ui.dock, before);
// one panel of the group may float; the other stays docked
menus::invoke(&mut app, &ctx, "window.panel.float", json!({"panel": "Info"})).unwrap();
assert!(app.ui.dock.docked(PanelKind::Project) && !app.ui.dock.docked(PanelKind::Info));
}
/// Tools and the audio meters are ordinary groups with a tab strip: the meters show their tab,
/// narrow Tools at least its drag bar, and either one joins another group.
#[test]
fn tools_and_meters_move_like_any_group() {
let mut h = demo_harness();
assert!(h.state().auto.find("panel.tab.AudioMeters").is_some(), "the meters have no tab");
let from = rect(&h, "panel.drag.Tools").center();
let to = rect(&h, "panel.Program").center();
drag(&mut h, from, to, Modifiers::NONE);
assert!(same_group(&h.state().ui.dock, PanelKind::Tools, PanelKind::Program), "{:?}", h.state().ui.dock);
}
/// A panel floated by command without a rect takes a useful height, not the 120 pt minimum.
#[test]
fn program_floats_at_a_useful_height() {
let mut h = demo_harness();
let ctx = h.ctx.clone();
menus::invoke(h.state_mut(), &ctx, "window.panel.float", json!({"panel": "Program"})).unwrap();
for _ in 0..3 {
step(&mut h);
}
let window = h.state().ui.dock.floating.iter().find(|window| window.contains(&PanelKind::Program)).unwrap();
assert!(window.rect[3] >= 300.0, "Program floated at {:?}", window.rect);
}
/// Only docked frames maximize: Maximize Frame on a floating panel leaves nothing maximized.
#[test]
fn a_floating_panel_does_not_maximize() {
let mut app = FilmcraftApp::new(Session::default());
app.ui.dock = layout();
let ctx = egui::Context::default();
menus::invoke(&mut app, &ctx, "window.floatPanel", json!({"panel": "Info", "rect": [45, 65, 420, 320]})).unwrap();
app.ui.focused = PanelKind::Info;
menus::invoke(&mut app, &ctx, "window.maximizeFrame", json!({})).unwrap();
assert_eq!(app.ui.keys.maximized, None);
app.ui.focused = PanelKind::Program;
menus::invoke(&mut app, &ctx, "window.maximizeFrame", json!({})).unwrap();
assert_eq!(app.ui.keys.maximized, Some(PanelKind::Program));
}
/// A closed panel reopens through `window.panel.activate`.
#[test]
fn activate_reopens_a_closed_panel() {
let mut app = FilmcraftApp::new(Session::default());
app.ui.dock = layout();
let ctx = egui::Context::default();
menus::invoke(&mut app, &ctx, "window.panel.close", json!({"panel": "Info"})).unwrap();
assert!(!app.ui.dock.contains(&PanelKind::Info));
menus::invoke(&mut app, &ctx, "window.panel.activate", json!({"panel": "Info"})).unwrap();
assert!(app.ui.dock.is_visible(PanelKind::Info));
}
/// Press and release `button` at `pos`.
fn click_at(h: &mut Harness<'_, FilmcraftApp>, pos: egui::Pos2, button: PointerButton) {
h.event(Event::PointerMoved(pos));
step(h);
for pressed in [true, false] {
h.event(Event::PointerButton { pos, button, pressed, modifiers: Modifiers::NONE });
step(h);
}
for _ in 0..3 {
step(h);
}
}
/// Right-click the tab `tab` and choose the context-menu item labeled `item`.
fn tab_menu(h: &mut Harness<'_, FilmcraftApp>, tab: &str, item: &str) {
let pos = rect(h, tab).center();
click_at(h, pos, PointerButton::Secondary);
let item = h.get_by_label(item).rect().center();
click_at(h, item, PointerButton::Primary);
}
/// A Timeline tab's context menu carries FilmCraft's Timeline items, and its Close Panel closes
/// the active sequence: the Timeline stays.
#[test]
fn close_panel_on_the_timeline_tab_closes_the_sequence() {
let mut h = demo_harness();
let active = h.state().session.state.active_sequence.unwrap();
let pos = rect(&h, "panel.tab.Timeline").center();
click_at(&mut h, pos, PointerButton::Secondary);
for id in ["panel.menu.Timeline.revealSequence", "panel.tabMenu.Timeline.closeOthers", "panel.tabMenu.Timeline.restoreWorkspace"] {
assert!(h.state().auto.find(id).is_some(), "{id} is missing from the tab menu");
}
let close = h.get_by_label("Close Panel").rect().center();
click_at(&mut h, close, PointerButton::Primary);
assert!(!h.state().session.state.open_sequences.contains(&active), "the sequence stays open");
assert!(h.state().ui.dock.is_visible(PanelKind::Timeline), "the Timeline closed");
}
/// Close Panel Group on a group holding the Timeline closes the active sequence and the group's
/// other panels; the Timeline stays.
#[test]
fn close_panel_group_keeps_the_timeline_and_closes_the_sequence() {
let mut h = demo_harness();
let ctx = h.ctx.clone();
menus::invoke(h.state_mut(), &ctx, "window.dockPanel", json!({"panel": "Info", "anchor": "Timeline", "zone": "center"})).unwrap();
for _ in 0..3 {
step(&mut h);
}
assert!(same_group(&h.state().ui.dock, PanelKind::Info, PanelKind::Timeline));
let active = h.state().session.state.active_sequence.unwrap();
tab_menu(&mut h, "panel.tab.Info", "Close Panel Group");
let state = h.state();
assert!(!state.session.state.open_sequences.contains(&active), "the sequence stays open");
assert!(state.ui.dock.is_visible(PanelKind::Timeline), "the Timeline closed");
assert!(!state.ui.dock.contains(&PanelKind::Info), "Info stays open");
}
/// With the header in the macOS title-bar strip, a floating window saved at the top of the
/// viewport is drawn below the strip, where a press on it cannot move the app window.
#[test]
fn a_floating_panel_stays_out_of_the_integrated_titlebar() {
let mut app = FilmcraftApp::new(Session::default());
app.ui.dock = layout();
app.integrated_titlebar = true;
let ctx = egui::Context::default();
menus::invoke(&mut app, &ctx, "window.floatPanel", json!({"panel": "Info", "rect": [45, 65, 420, 320]})).unwrap();
app.ui.dock.floating.iter_mut().find(|window| window.contains(&PanelKind::Info)).unwrap().rect[1] = 0.0;
let mut h = Harness::builder().with_size(vec2(1200.0, 760.0)).build_eframe(move |_| app);
for _ in 0..3 {
step(&mut h);
}
let drawn = h.ctx.memory(|memory| memory.area_rect(window_layer(&h, PanelKind::Info).id)).expect("Info is drawn floating");
assert!(drawn.min.y >= filmcraft_ui_egui::header::HEIGHT, "drawn at {drawn:?}");
}
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.