f67d38b35cc5
panels_ui.rs
//! Headless UI tests of the M8.9 / M12.6 panels: Video Scopes (layouts, the settings menu,
//! footer), Metadata (edit a field by typing, undo), Timecode, Events, Progress and the Reference
//! Monitor, each opened from Window ▸ and driven by automation id through the control channel.
//!
//! Set `FILMCRAFT_UI_SNAPSHOT_DIR=<dir>` to also render offscreen with wgpu and write `panels-*.png`.
#![allow(dead_code)]
use std::sync::Arc;
use std::sync::mpsc::{Sender, channel};
use egui_kittest::Harness;
use egui_kittest::kittest::Queryable;
use filmcraft_engine::Session;
use filmcraft_ui_egui::FilmcraftApp;
use filmcraft_ui_egui::control::ControlRequest;
use serde_json::{Value, json};
struct Driver {
harness: Harness<'static, FilmcraftApp>,
tx: Sender<ControlRequest>,
snapshots: Option<std::path::PathBuf>,
}
impl Driver {
fn with(session: Session) -> Self {
let (tx, rx) = channel();
let app = FilmcraftApp::new(session).with_control(rx);
let snapshots = std::env::var_os("FILMCRAFT_UI_SNAPSHOT_DIR").map(std::path::PathBuf::from);
let mut b = Harness::builder().with_size(egui::vec2(1600.0, 980.0)).with_max_steps(10_000);
if snapshots.is_some() {
b = b.wgpu();
}
let harness = b.build_eframe(move |_cc| app);
let mut d = Driver { harness, tx, snapshots };
d.frames(4);
d
}
fn demo() -> Self {
let mut session = Session::default();
session.execute("file.openDemoProject", json!({})).expect("demo project");
Self::with(session)
}
fn frames(&mut self, n: usize) {
for _ in 0..n {
let ctx = self.harness.ctx.clone();
let mut raw = std::mem::take(self.harness.input_mut());
eframe::App::raw_input_hook(self.harness.state_mut(), &ctx, &mut raw);
*self.harness.input_mut() = raw;
self.harness.step();
}
}
fn call(&mut self, method: &str, params: Value) -> Value {
let (req, reply) = ControlRequest::new(method, params.clone());
self.tx.send(req).unwrap();
for _ in 0..600 {
self.frames(1);
if let Ok(v) = reply.try_recv() {
return v;
}
}
panic!("no reply to {method} {params}");
}
fn ok(&mut self, method: &str, params: Value) -> Value {
let v = self.call(method, params.clone());
assert_eq!(v["ok"], json!(true), "{method} {params} failed: {v}");
v["result"].clone()
}
fn exec(&mut self, command: &str, params: Value) -> Value {
self.ok("engine.execute", json!({"command": command, "params": params}))
}
fn click(&mut self, id: &str) {
self.ok("ui.click", json!({"id": id}));
self.frames(2);
}
fn ids(&mut self, prefix: &str) -> Vec<String> {
let v = self.ok("ui.elements", json!({"prefix": prefix}));
v.as_array().unwrap().iter().filter_map(|e| e["id"].as_str().map(str::to_string)).collect()
}
/// The id and rect of each automation element whose id starts with `prefix`.
fn rects(&mut self, prefix: &str) -> Vec<(String, egui::Rect)> {
let v = self.ok("ui.elements", json!({"prefix": prefix}));
v.as_array()
.unwrap()
.iter()
.map(|e| {
let r: Vec<f32> = e["rect"].as_array().unwrap().iter().map(|x| x.as_f64().unwrap() as f32).collect();
(e["id"].as_str().unwrap().to_string(), egui::Rect::from_min_size(egui::pos2(r[0], r[1]), egui::vec2(r[2], r[3])))
})
.collect()
}
fn has(&mut self, id: &str) -> bool {
self.ids(id).iter().any(|i| i == id)
}
fn label(&mut self, id: &str) -> String {
let v = self.ok("ui.elements", json!({"prefix": id}));
v.as_array().unwrap().iter().find(|e| e["id"] == json!(id)).and_then(|e| e["label"].as_str().map(str::to_string)).unwrap_or_default()
}
/// Step frames until `id` is registered (frames render on worker threads), for at most two
/// minutes of wall-clock time.
fn wait_for(&mut self, id: &str) {
let t0 = std::time::Instant::now();
while t0.elapsed().as_secs() < 120 {
if self.has(id) {
return;
}
std::thread::sleep(std::time::Duration::from_millis(5));
self.frames(1);
}
panic!("{id} never appeared: {:?}", self.ids(id.split('.').next().unwrap()));
}
fn app(&mut self) -> &mut FilmcraftApp {
self.harness.state_mut()
}
fn ui_panels(&mut self) -> Value {
self.ok("ui.inspect", json!({}))["ui"]["panels"].clone()
}
/// Offscreen render of the window (or the bounding box of the elements under `prefix`).
fn snapshot(&mut self, name: &str, prefix: Option<&str>) {
let Some(dir) = self.snapshots.clone() else { return };
let crop = prefix.map(|p| {
let v = self.ok("ui.elements", json!({"prefix": p}));
let mut bb = [f32::MAX, f32::MAX, f32::MIN, f32::MIN];
for e in v.as_array().unwrap() {
let r = &e["rect"];
let (x, y, w, h) = (r[0].as_f64().unwrap() as f32, r[1].as_f64().unwrap() as f32, r[2].as_f64().unwrap() as f32, r[3].as_f64().unwrap() as f32);
bb = [bb[0].min(x), bb[1].min(y), bb[2].max(x + w), bb[3].max(y + h)];
}
bb
});
self.frames(2);
let img = match self.harness.render() {
Ok(i) => i,
Err(e) => {
eprintln!("snapshot {name} skipped: {e}");
return;
}
};
let ppp = img.width() as f32 / 1600.0;
let img = match crop {
Some(bb) => {
let x0 = ((bb[0] - 24.0) * ppp).max(0.0) as u32;
let y0 = ((bb[1] - 30.0) * ppp).max(0.0) as u32;
let x1 = (((bb[2] + 16.0) * ppp) as u32).min(img.width());
let y1 = (((bb[3] + 46.0) * ppp) as u32).min(img.height());
image::imageops::crop_imm(&img, x0, y0, x1 - x0, y1 - y0).to_image()
}
None => img,
};
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join(format!("{name}.png"));
img.save(&path).unwrap();
eprintln!("snapshot: {}", path.display());
}
}
#[test]
fn every_panel_opens_from_the_window_menu() {
let mut d = Driver::demo();
let menu = d.ok("ui.menu.list", json!({}));
let window: Vec<String> =
menu.as_array().unwrap().iter().filter(|m| m["path"] == json!(["Window"])).filter_map(|m| m["label"].as_str().map(str::to_string)).collect();
for p in ["Events", "Video Scopes", "Metadata", "Progress", "Project Notes", "Reference Monitor", "Timecode"] {
assert!(window.iter().any(|w| w == p), "{p} not in Window: {window:?}");
}
for (panel, key) in [
("LumetriScopes", "scopes.wrench"),
("Metadata", "metadata."),
("Timecode", "timecode.row.0"),
("Events", "events.clearAll"),
("Progress", "progress.showFinished"),
("ReferenceMonitor", "reference.gang"),
("ProjectNotes", "notes.text"),
] {
d.ok("ui.menu.invoke", json!({"id": format!("window.panel.{panel}")}));
d.frames(3);
assert!(d.has(&format!("panel.tab.{panel}")), "{panel} has no tab");
assert!(!d.ids(key).is_empty(), "{panel}: no {key} widgets");
assert_eq!(d.ok("ui.inspect", json!({}))["ui"]["focused"], json!(panel));
}
}
/// #284 point 3: the panel menu's Maximize Frame keeps the layout (Restore Frame brings it back),
/// and closing every panel still leaves a dock that Window ▸ can reopen panels into.
#[test]
fn panel_menu_maximize_restores_and_an_empty_dock_reopens() {
use filmcraft_ui_egui::dock::PanelKind;
let mut d = Driver::demo();
let layout = d.app().ui.dock.clone();
d.click("panel.menu.Program");
assert_eq!(d.label("panel.menu.Program.maximize"), "Maximize Frame");
d.click("panel.menu.Program.maximize");
assert_eq!(d.app().ui.keys.maximized, Some(PanelKind::Program));
assert!(!d.has("panel.Timeline"), "only the maximized panel is shown");
d.click("panel.menu.Program");
assert_eq!(d.label("panel.menu.Program.maximize"), "Restore Frame");
d.click("panel.menu.Program.maximize");
assert_eq!(d.app().ui.keys.maximized, None);
assert_eq!(d.app().ui.dock, layout, "the layout survives maximize / restore");
assert!(d.has("panel.Timeline"));
for p in layout.panels() {
d.ok("ui.panel.close", json!({"panel": p.id()}));
}
assert_eq!(d.app().ui.dock.root, None);
d.ok("ui.menu.invoke", json!({"id": "window.panel.Program"}));
d.ok("ui.menu.invoke", json!({"id": "window.panel.Timeline"}));
d.frames(3);
assert!(d.has("panel.tab.Program") && d.has("panel.tab.Timeline"));
}
/// The History panel menu: Delete Redoable Actions asks for OK and then forgets the dimmed steps
/// (Backspace in the History panel asks the same), and Clear History forgets every step. The
/// project stays as it is.
#[test]
fn history_panel_menu_deletes_redoable_actions_and_clears_the_history() {
let mut d = Driver::demo();
for name in ["A", "B", "C"] {
d.exec("file.newBin", json!({"name": name}));
}
d.exec("edit.undo", json!({}));
d.exec("edit.undo", json!({}));
d.ok("ui.menu.invoke", json!({"id": "window.panel.History"}));
d.frames(3);
let redo = |d: &mut Driver| d.exec("history.list", json!({}))["redo"].as_array().unwrap().len();
assert_eq!(redo(&mut d), 2);
let project = d.app().session.project.clone();
d.click("panel.menu.History");
assert_eq!(d.label("panel.menu.History.deleteRedoable"), "Delete Redoable Actions");
assert_eq!(d.label("panel.menu.History.clear"), "Clear History");
d.click("panel.menu.History.deleteRedoable");
assert!(d.has("history.deleteRedoable.ok"), "Delete Redoable Actions asks first");
assert_eq!(redo(&mut d), 2, "nothing is deleted before OK");
d.click("history.deleteRedoable.cancel");
assert!(!d.has("history.deleteRedoable.ok"));
assert_eq!(redo(&mut d), 2, "Cancel keeps the steps");
d.ok("ui.key", json!({"key": "Backspace"}));
d.frames(2);
assert!(d.has("history.deleteRedoable.ok"), "Backspace in the History panel asks too");
d.click("history.deleteRedoable.ok");
assert!(!d.has("history.deleteRedoable.ok"));
assert_eq!(redo(&mut d), 0);
assert_eq!(*d.app().session.project, *project, "the project does not change");
d.click("panel.menu.History");
d.click("panel.menu.History.clear");
assert_eq!(d.exec("history.list", json!({})), json!({"undo": [], "redo": []}));
assert_eq!(*d.app().session.project, *project, "the project does not change");
assert!(!d.app().session.is_enabled("history.clear"), "an empty history has nothing to clear");
}
/// Each History row shows the icon of the command that made its step, oldest first, and an undone
/// step keeps its icon. The Open row has none. Clicking a row still moves the project to it.
#[test]
fn history_rows_show_the_command_icon() {
let mut d = Driver::demo();
let n0 = d.app().session.history.undo.len();
d.exec("file.newBin", json!({"name": "A"}));
d.exec("markers.add", json!({}));
d.exec("edit.undo", json!({}));
d.ok("ui.menu.invoke", json!({"id": "window.panel.History"}));
d.frames(3);
let (bin, marker) = (format!("history.row.{}", n0 + 1), format!("history.row.{}", n0 + 2));
assert_eq!(d.label("history.row.0"), "Open");
assert!(!d.has("history.row.0.icon"), "the starting state is not an action");
assert_eq!(d.label(&format!("{bin}.icon")), "Folder");
assert_eq!(d.label(&format!("{marker}.icon")), "Marker", "an undone step keeps its icon");
assert!(!d.has(&format!("history.row.{}", n0 + 3)));
d.click(&marker);
assert_eq!(d.app().session.history.redo.len(), 0, "clicking the undone row redoes it");
assert_eq!(d.label(&format!("{marker}.icon")), "Marker");
d.click(&bin);
assert_eq!(d.app().session.history.redo.len(), 1);
assert_eq!(d.label(&format!("{marker}.icon")), "Marker", "the icon stays with its row through undo");
}
/// On a History row partly scrolled out of the panel, the `.icon` target is the part of the drawn
/// icon that still shows: it lies inside its row, at the drawn icon's left edge, and it is not
/// registered once the icon itself is scrolled out.
#[test]
fn history_icon_targets_follow_rows_scrolled_part_out() {
let mut d = Driver::demo();
for i in 0..60 {
d.exec("file.newBin", json!({"name": format!("Bin {i}")}));
}
d.ok("ui.menu.invoke", json!({"id": "window.panel.History"}));
d.frames(3);
let mut clipped = 0;
for _ in 0..40 {
let rects = d.rects("history.row.");
let rows: Vec<&(String, egui::Rect)> = rects.iter().filter(|(id, _)| !id.ends_with(".icon")).collect();
for (id, row) in &rows {
let icon = rects.iter().find(|(i, _)| *i == format!("{id}.icon")).map(|(_, r)| *r);
if row.height() < 19.5 {
clipped += 1;
}
let Some(icon) = icon else { continue };
let inside = row.expand(0.01).contains_rect(icon);
assert!(inside, "{id}: icon {icon:?} outside its row {row:?}");
assert!((icon.min.x - (row.min.x + 6.0)).abs() < 0.01, "{id}: icon {icon:?} is not at the drawn icon's left edge in {row:?}");
assert!(icon.height() <= 14.01 && icon.height() > 0.0, "{id}: icon {icon:?}");
}
let Some((last, _)) = rows.last() else { panic!("no History rows") };
let last = last.clone();
d.ok("ui.scroll", json!({"id": last, "dy": -7.0}));
d.frames(3);
}
assert!(clipped > 0, "no row was ever partly scrolled out");
}
/// The wheel over a tab strip switches that group's tab: down = next, up = previous, one tab per
/// notch, smaller trackpad steps adding up to a notch, stopping at the ends. Over the panel's
/// content the wheel leaves the tabs alone.
#[test]
fn wheel_over_a_tab_strip_switches_tabs() {
use craft_ui::docking::Node;
use filmcraft_ui_egui::dock::PanelKind;
fn shown(d: &mut Driver) -> PanelKind {
fn find(n: &Node<PanelKind>) -> Option<PanelKind> {
match n {
Node::Tabs { panels, active } if panels.contains(&PanelKind::Project) => panels.get(*active).copied(),
Node::Split { first, second, .. } => find(first).or_else(|| find(second)),
_ => None,
}
}
d.app().ui.dock.root.as_ref().and_then(find).unwrap()
}
fn wheel(d: &mut Driver, dy: f64) {
let id = format!("panel.tab.{}", shown(d).id());
d.ok("ui.scroll", json!({"id": id, "dy": dy}));
d.frames(2);
}
let mut d = Driver::demo();
assert_eq!(shown(&mut d), PanelKind::Project);
wheel(&mut d, -40.0);
assert_eq!(shown(&mut d), PanelKind::MediaBrowser);
wheel(&mut d, 40.0);
assert_eq!(shown(&mut d), PanelKind::Project);
wheel(&mut d, 120.0);
assert_eq!(shown(&mut d), PanelKind::Project, "no wrap past the first tab");
// a trackpad swipe in small steps moves one tab once the steps add up to a notch
let r = d.ok("ui.elements", json!({"prefix": "panel.tab.Project"}))[0]["rect"].clone();
let at = egui::pos2((r[0].as_f64().unwrap() + r[2].as_f64().unwrap() / 2.0) as f32, (r[1].as_f64().unwrap() + r[3].as_f64().unwrap() / 2.0) as f32);
d.harness.input_mut().events.push(egui::Event::PointerMoved(at));
d.frames(1);
for step in 0..5 {
d.harness.input_mut().events.push(egui::Event::MouseWheel {
unit: egui::MouseWheelUnit::Point,
source: egui::MouseWheelSource::Wheel,
delta: egui::vec2(0.0, -10.0),
modifiers: egui::Modifiers::NONE,
phase: egui::TouchPhase::Move,
});
d.frames(1);
let expect = if step < 3 { PanelKind::Project } else { PanelKind::MediaBrowser };
assert_eq!(shown(&mut d), expect, "after {} pt", (step + 1) * 10);
}
d.ok("ui.scroll", json!({"id": "panel.MediaBrowser", "dy": -40.0}));
d.frames(2);
assert_eq!(shown(&mut d), PanelKind::MediaBrowser, "the wheel over the content keeps the tab");
for _ in 0..10 {
wheel(&mut d, -40.0);
}
assert_eq!(shown(&mut d), PanelKind::History, "no wrap past the last tab");
}
#[test]
fn lumetri_scopes_layouts_menu_and_footer() {
let mut d = Driver::demo();
d.ok("ui.set", json!({"workspace": "Color"}));
d.ok("ui.panel.show", json!({"panel": "LumetriScopes"}));
// the default: RGB parade, Rec. 709, 8 Bit, Clamp Signal
d.wait_for("scopes.view.parade");
assert_eq!(d.label("scopes.space"), "Rec. 709");
let p = d.ui_panels();
assert_eq!((p["scopes"]["shown"].clone(), p["scopes"]["scale"].clone(), p["scopes"]["clamp"].clone()), (json!(["parade"]), json!("bits8"), json!(true)));
d.snapshot("panels-scopes-parade", Some("scopes."));
// the wrench menu: add the YUV vectorscope, switch the waveform type through its submenu
d.click("scopes.wrench");
assert!(d.has("scopes.menu.vectorscopeYuv"), "{:?}", d.ids("scopes.menu"));
d.click("scopes.menu.vectorscopeYuv");
d.wait_for("scopes.view.vectorscopeYuv");
assert!(d.has("scopes.view.parade"));
// Clamp Signal in the footer
d.click("scopes.clamp");
assert_eq!(d.ui_panels()["scopes"]["clamp"], json!(false));
// all five scopes in a grid, through ui.set; then a preset
d.ok("ui.set", json!({"panels": {"scopes": {"shown": ["vectorscopeYuv", "vectorscopeHls", "histogram", "parade", "waveform"], "waveformType": "yc", "paradeType": "rgbWhite", "brightness": "bright", "targets": "100"}}}));
for k in ["vectorscopeYuv", "vectorscopeHls", "histogram", "parade", "waveform"] {
d.wait_for(&format!("scopes.view.{k}"));
}
let rects: Vec<Value> = d.ok("ui.elements", json!({"prefix": "scopes.view."})).as_array().unwrap().iter().map(|e| e["rect"].clone()).collect();
assert_eq!(rects.len(), 5);
d.snapshot("panels-scopes-five", Some("scopes."));
d.click("scopes.wrench");
d.ok("ui.click", json!({"id": "scopes.menu.presets"}));
d.frames(3);
d.wait_for("scopes.menu.preset.5");
d.click("scopes.menu.preset.5");
let s = d.ui_panels()["scopes"].clone();
assert_eq!(s["preset"], json!("Four Scopes (YUV, float, no clamp)"), "{s}");
assert_eq!((s["scale"].clone(), s["clamp"].clone(), s["paradeType"].clone()), (json!("float"), json!(false), json!("yuv")));
assert_eq!(s["shown"].as_array().unwrap().len(), 4);
// colour space: Rec. 601 shows in the footer
d.ok("ui.set", json!({"panels": {"scopes": {"colorSpace": "rec601"}}}));
d.frames(3);
assert_eq!(d.label("scopes.space"), "Rec. 601");
// the numbers behind it, for agents
let r = d.exec("scopes.read", json!({"scopes": ["histogram"], "colorSpace": "601", "bins": false}));
assert_eq!(r["matrix"], "Bt601");
assert!(r["histogram"]["samples"].as_u64().unwrap() > 1000, "{r}");
}
#[test]
fn metadata_panel_edits_a_field_with_undo() {
let mut d = Driver::demo();
let item = d.app().session.project.items.values().filter(|i| i.as_media().is_some()).map(|i| i.id).min().unwrap();
d.app().session.state.project_selection = vec![item];
d.app().ui.focused = filmcraft_ui_egui::dock::PanelKind::Project;
d.ok("ui.menu.invoke", json!({"id": "window.panel.Metadata"}));
d.ok("ui.set", json!({"focused": "Project"}));
d.frames(3);
let name = d.app().session.project.item(item).unwrap().name.clone();
assert_eq!(d.label("metadata.header"), format!("Clip: {name}"));
for id in [
"metadata.field.Name",
"metadata.label",
"metadata.field.MediaStart",
"metadata.field.MediaDuration",
"metadata.field.Scene",
"metadata.field.LogNote",
"metadata.field.FilePath",
"metadata.section.File",
] {
assert!(d.has(id), "{id} missing: {:?}", d.ids("metadata."));
}
d.snapshot("panels-metadata", Some("metadata."));
// type into Scene and commit with Enter: one undo step
let undo0 = d.app().session.history.undo.len();
d.click("metadata.field.Scene");
d.ok("ui.type", json!({"text": "42A"}));
d.frames(2);
d.ok("ui.key", json!({"key": "Enter"}));
d.frames(3);
assert_eq!(d.app().session.project.item(item).unwrap().metadata.get("Scene").map(String::as_str), Some("42A"));
assert_eq!(d.app().session.history.undo.len(), undo0 + 1);
assert_eq!(d.label("metadata.field.Scene"), "42A");
d.exec("edit.undo", json!({}));
d.frames(2);
assert!(!d.app().session.project.item(item).unwrap().metadata.contains_key("Scene"));
// the same edit from an agent
d.exec("metadata.set", json!({"item": item.0, "field": "Tape Name", "value": "A001"}));
d.frames(2);
assert_eq!(d.label("metadata.field.TapeName"), "A001");
}
/// #620: notes typed into Project Notes land in the project; one typing session is one undo step.
#[test]
fn project_notes_panel_types_into_the_project_with_undo() {
let mut d = Driver::demo();
d.ok("ui.menu.invoke", json!({"id": "window.panel.ProjectNotes"}));
d.frames(3);
let undo0 = d.app().session.history.undo.len();
d.click("notes.text");
d.ok("ui.type", json!({"text": "Fix logo"}));
d.frames(2);
d.ok("ui.key", json!({"key": "Enter"}));
d.ok("ui.type", json!({"text": "at 1:02"}));
d.frames(3);
assert_eq!(d.app().session.project.notes, "Fix logo\nat 1:02");
assert_eq!(d.app().session.history.undo.len(), undo0 + 1);
assert_eq!(d.label("notes.text"), "Fix logo\nat 1:02");
d.exec("edit.undo", json!({}));
d.frames(2);
assert_eq!(d.app().session.project.notes, "");
// an agent writes them, the panel shows them
d.exec("project.setNotes", json!({"text": "From the script"}));
d.frames(2);
assert_eq!(d.label("notes.text"), "From the script");
}
#[test]
fn timecode_panel_rows_and_modes() {
let mut d = Driver::demo();
d.exec("playhead.set", json!({"timecode": "00:00:02:00"}));
d.ok("ui.menu.invoke", json!({"id": "window.panel.Timecode"}));
d.frames(3);
assert_eq!(d.label("timecode.row.0"), "00:00:02:00");
d.click("timecode.addRow");
assert_eq!(d.ui_panels()["timecode"]["rows"].as_array().unwrap().len(), 2);
// the new row is a duration: the sequence's
let (dur, df, rate) = {
let q = d.app().session.active_sequence().unwrap();
(q.duration(), q.settings.drop_frame, q.settings.frame_rate)
};
let want = filmcraft_time::format_time(dur, rate, df, filmcraft_time::TimeDisplay::Timecode, 48000);
assert_eq!(d.label("timecode.row.1"), want);
// frames display and Remaining through ui.set
d.ok("ui.set", json!({"panels": {"timecode": {"rows": [{"mode": "current", "display": "Frames"}, {"mode": "remaining"}]}}}));
d.frames(2);
let frame = rate.frame_at(d.app().session.playhead());
assert_eq!(d.label("timecode.row.0"), frame.to_string());
let rem = filmcraft_time::format_time(dur - d.app().session.playhead(), rate, df, filmcraft_time::TimeDisplay::Timecode, 48000);
assert_eq!(d.label("timecode.row.1"), rem);
d.snapshot("panels-timecode", Some("timecode."));
// right-click menu: Media Time
d.ok("ui.click", json!({"id": "timecode.row.1", "button": "right"}));
d.frames(2);
if d.has("timecode.row.1.mode.media") {
d.click("timecode.row.1.mode.media");
assert_eq!(d.ui_panels()["timecode"]["rows"][1]["mode"], json!("media"));
}
}
#[test]
fn events_and_progress_panels() {
let mut d = Driver::demo();
d.exec("events.clear", json!({}));
d.ok("ui.menu.invoke", json!({"id": "window.panel.Events"}));
d.frames(2);
// a failed command shows up as an error row
let r = d.call("engine.execute", json!({"command": "presets.rename", "params": {}}));
assert_eq!(r["ok"], json!(false));
d.frames(2);
let rows = d.ids("events.row.");
assert_eq!(rows.len(), 1, "{rows:?}");
assert!(d.label(&rows[0]).contains("name"), "{}", d.label(&rows[0]));
d.click(&rows[0]);
assert!(d.has("events.details"));
d.snapshot("panels-events", Some("events."));
// filter: errors only still shows it; Clear All empties the list
d.ok("ui.set", json!({"panels": {"events": {"level": "error"}}}));
d.frames(2);
assert_eq!(d.ids("events.row.").len(), 1);
d.click("events.clearAll");
assert!(d.ids("events.row.").is_empty());
assert!(d.app().session.log.entries.is_empty());
// Progress: a running job with a Cancel button
let job = filmcraft_engine::Job {
id: 4242,
label: "Export demo.mp4".into(),
progress: Arc::new(Default::default()),
result: Arc::new(std::sync::Mutex::new(None)),
};
job.progress.total.store(10, std::sync::atomic::Ordering::Relaxed);
job.progress.done.store(4, std::sync::atomic::Ordering::Relaxed);
d.app().session.jobs.push(job.clone());
d.ok("ui.menu.invoke", json!({"id": "window.panel.Progress"}));
d.frames(3);
assert!(d.label("progress.job.4242").contains("40 %"), "{}", d.label("progress.job.4242"));
d.snapshot("panels-progress", Some("progress."));
d.click("progress.cancel.4242");
assert!(job.progress.cancel.load(std::sync::atomic::Ordering::Relaxed));
*job.result.lock().unwrap() = Some(Err("cancelled".into()));
d.frames(3);
assert!(!d.has("progress.cancel.4242"));
assert!(d.label("progress.job.4242").contains("Cancelled"));
// the Events panel logged the job
let ev = d.exec("events.list", json!({}));
let msgs: Vec<&str> = ev["entries"].as_array().unwrap().iter().filter_map(|e| e["message"].as_str()).collect();
assert!(msgs.contains(&"Started: Export demo.mp4") && msgs.contains(&"Cancelled: Export demo.mp4"), "{msgs:?}");
// hide finished jobs
d.click("progress.showFinished");
assert!(!d.has("progress.job.4242"));
}
#[test]
fn reference_monitor_parks_gangs_and_shows_scopes() {
let mut d = Driver::demo();
d.ok("ui.menu.invoke", json!({"id": "window.panel.ReferenceMonitor"}));
d.frames(3);
assert_eq!(d.label("reference.timecode"), "00:00:00:00");
d.exec("playhead.set", json!({"timecode": "00:00:03:00"}));
d.frames(2);
// parked: the playhead moved, the reference did not
assert_eq!(d.label("reference.timecode"), "00:00:00:00");
d.click("reference.matchPlayhead");
assert_eq!(d.label("reference.timecode"), "00:00:03:00");
d.click("reference.stepForward");
assert_eq!(d.label("reference.timecode"), "00:00:03:01");
// ganged: follows the playhead
d.click("reference.gang");
assert_eq!(d.ui_panels()["reference"]["ganged"], json!(true));
d.exec("playhead.set", json!({"timecode": "00:00:01:00"}));
d.frames(2);
assert_eq!(d.label("reference.timecode"), "00:00:01:00");
d.wait_for("reference.picture");
d.snapshot("panels-reference-composite", Some("reference."));
// scopes of the reference frame
d.ok("ui.set", json!({"panels": {"reference": {"display": "scopes"}}}));
d.wait_for("reference.scopes.view.vectorscopeYuv");
d.wait_for("reference.scopes.view.waveform");
d.snapshot("panels-reference-scopes", Some("reference."));
}
#[test]
fn scopes_of_colour_bars() {
let mut s = Session::default();
let id = s.execute("file.newBarsAndTone", json!({"seconds": 2})).unwrap()["item"].as_u64().unwrap();
s.execute("file.newSequenceFromClip", json!({"items": [id]})).unwrap();
let mut d = Driver::with(s);
d.ok(
"ui.set",
json!({"workspace": "Color", "panels": {"scopes": {"shown": ["vectorscopeYuv", "histogram", "parade", "waveform"], "waveformType": "luma"}}}),
);
d.ok("ui.panel.show", json!({"panel": "LumetriScopes"}));
for k in ["vectorscopeYuv", "histogram", "parade", "waveform"] {
d.wait_for(&format!("scopes.view.{k}"));
}
d.snapshot("panels-scopes-bars", Some("scopes."));
// the numbers: the six 75 % bars sit on their targets
let r = d.exec("scopes.read", json!({"scopes": ["vectorscopeYuv", "parade"], "columns": 8}));
let peaks = r["vectorscopeYuv"]["peaks"].as_array().unwrap();
let angles: Vec<f64> = peaks.iter().take(7).map(|p| p["angleDeg"].as_f64().unwrap()).collect();
for t in filmcraft_scopes::targets(filmcraft_scopes::Matrix::Bt709, 191.0 / 255.0) {
let a = filmcraft_scopes::angle_deg(t.cb, t.cr) as f64;
assert!(angles.iter().any(|x| (x - a).abs() < 1.5), "{} at {a:.1}° not in {angles:?}", t.name);
}
}
/// #1075: child backgrounds must not cover the focus outline shared with Program. Check the
/// rendered primitives, including Media Browser's parent group, in both requested themes.
#[test]
fn focused_panel_outline_is_not_covered_by_child_backgrounds() {
fn rectangles<'a>(shape: &'a egui::Shape, clip: egui::Rect, out: &mut Vec<(&'a egui::epaint::RectShape, egui::Rect)>) {
match shape {
egui::Shape::Rect(rect) => out.push((rect, clip)),
egui::Shape::Vec(shapes) => shapes.iter().for_each(|shape| rectangles(shape, clip, out)),
_ => {}
}
}
let mut d = Driver::demo();
for theme in ["dark", "light"] {
d.ok("ui.set", json!({"theme": theme}));
for panel in ["Program", "Text", "LumetriScopes", "EssentialSound", "Timeline", "TextToSpeech", "MediaBrowser"] {
d.ok("ui.panel.show", json!({"panel": panel}));
d.ok("ui.set", json!({"focused": panel}));
d.frames(3);
d.snapshot(&format!("focus-{theme}-{panel}"), None);
let mut rects = Vec::new();
for shape in &d.harness.output().shapes {
rectangles(&shape.shape, shape.clip_rect, &mut rects);
}
let focus = d.harness.state().tokens.focus;
let outlines: Vec<_> = rects
.iter()
.enumerate()
.filter(|(_, (r, _))| r.stroke.color == focus && r.stroke.width == 1.0 && r.rect.width() > 100.0 && r.rect.height() > 80.0)
.collect();
assert_eq!(outlines.len(), 1, "{theme} {panel}: one focus outline for the whole parent group");
let (at, (outline, _)) = outlines[0];
let bounds = outline.rect;
let strips = [
egui::Rect::from_min_max(bounds.min, egui::pos2(bounds.max.x, bounds.min.y + 1.0)),
egui::Rect::from_min_max(egui::pos2(bounds.min.x, bounds.max.y - 1.0), bounds.max),
egui::Rect::from_min_max(bounds.min, egui::pos2(bounds.min.x + 1.0, bounds.max.y)),
egui::Rect::from_min_max(egui::pos2(bounds.max.x - 1.0, bounds.min.y), bounds.max),
];
for (child, clip) in &rects[at + 1..] {
if child.fill.a() != 0 {
let painted = child.rect.intersect(*clip);
assert!(
strips.iter().all(|edge| !edge.intersect(painted).is_positive()),
"{theme} {panel}: a later child background {painted:?} covers the focus outline {bounds:?}"
);
}
}
}
}
}
/// Select two different sources using the same Project-row and Timeline-clip clicks as an editor.
fn inspector_selection_driver() -> (Driver, filmcraft_project::ItemId, filmcraft_project::ItemId, filmcraft_project::ClipId) {
let mut d = Driver::demo();
let seq = d.app().session.active_sequence().unwrap();
let a = seq.video_tracks[0].items[0].item;
let clip = seq.video_tracks[0].items.iter().find(|clip| clip.item != a).unwrap();
let (b, clip) = (clip.item, clip.id);
let bin = d
.app()
.session
.project
.root
.children
.iter()
.find_map(|entry| match entry {
filmcraft_project::BinEntry::Bin(bin) if bin.name == "Footage" => Some(bin.id.0),
_ => None,
})
.unwrap();
d.exec("project.view.set", json!({"view":"list"}));
d.ok("ui.menu.invoke", json!({"id":"window.panel.Metadata"}));
d.ok("ui.menu.invoke", json!({"id":"window.panel.Info"}));
d.click("panel.tab.Project");
d.ok("ui.menu.invoke", json!({"id":"projectPanel.openBin","params":{"bin":bin,"how":"inPlace"}}));
d.click(&format!("project.item.{}", a.0));
assert_eq!(d.app().session.state.project_selection, vec![a]);
d.click(&format!("timeline.clip.{}", clip.0));
assert!(d.app().session.state.selection.contains(&clip));
(d, a, b, clip)
}
#[test]
fn metadata_keeps_the_timeline_item_when_its_tab_and_field_take_focus() {
let (mut d, a, b, _) = inspector_selection_driver();
let b_name = d.app().session.project.item(b).unwrap().name.clone();
assert_eq!(d.label("metadata.header"), format!("Clip: {b_name}"));
d.click("panel.tab.Metadata");
assert_eq!(d.label("metadata.header"), format!("Clip: {b_name}"), "inspector focus must not reactivate the old Project selection");
let before = serde_json::to_value(&d.app().session.project).unwrap();
let undo = d.app().session.history.undo.len();
d.click("metadata.field.Scene");
d.ok("ui.type", json!({"text":"42B"}));
d.ok("ui.key", json!({"key":"Enter"}));
d.frames(3);
assert_eq!(d.app().session.project.item(b).unwrap().metadata.get("Scene").map(String::as_str), Some("42B"));
assert!(!d.app().session.project.item(a).unwrap().metadata.contains_key("Scene"));
assert_eq!(d.app().session.history.undo.len(), undo + 1);
let after = serde_json::to_value(&d.app().session.project).unwrap();
d.exec("edit.undo", json!({}));
assert_eq!(serde_json::to_value(&d.app().session.project).unwrap(), before);
d.exec("edit.redo", json!({}));
assert_eq!(serde_json::to_value(&d.app().session.project).unwrap(), after);
d.snapshot("panels-metadata-timeline-selection", Some("metadata."));
}
#[test]
fn info_follows_the_timeline_item_and_keeps_sequence_information() {
let (mut d, _, b, _) = inspector_selection_driver();
let name = d.app().session.project.item(b).unwrap().name.clone();
d.click("panel.tab.Info");
assert!(d.harness.query_by_label(&name).is_some(), "Info must show the selected Timeline item's name");
assert_eq!(d.label("info.item"), name, "the item header belongs to Info, not another panel");
assert!(!d.label("info.sequence").is_empty());
assert!(d.harness.query_by_label("Settings:").is_some(), "Info keeps its lower sequence-information section");
d.snapshot("panels-info-timeline-selection", None);
}
#[test]
fn inspectors_follow_reselected_project_items_and_clear_without_stale_targets() {
let (mut d, a, b, clip) = inspector_selection_driver();
let a_name = d.app().session.project.item(a).unwrap().name.clone();
let b_name = d.app().session.project.item(b).unwrap().name.clone();
let timeline_selection = d.app().session.state.selection.clone();
let undo = d.app().session.history.undo.len();
let playhead = d.app().session.playhead();
d.click("panel.tab.Info");
assert_eq!(d.label("info.item"), b_name);
// Selection ownership also follows actual source clicks while both inspectors are hidden.
d.ok("ui.menu.invoke", json!({"id":"window.panel.Source"}));
d.click("panel.tab.Project");
d.click(&format!("project.item.{}", a.0));
d.click(&format!("timeline.clip.{}", clip.0));
d.ok("ui.menu.invoke", json!({"id":"window.panel.Metadata"}));
d.frames(3);
assert_eq!(d.label("metadata.header"), format!("Clip: {b_name}"));
d.click("panel.tab.Project");
d.click(&format!("project.item.{}", a.0));
d.click("panel.tab.Metadata");
assert_eq!(d.label("metadata.header"), format!("Clip: {a_name}"));
d.click("panel.tab.Info");
assert_eq!(d.label("info.item"), a_name);
assert_eq!(d.app().session.state.selection, timeline_selection);
assert_eq!(d.app().session.state.project_selection, vec![a]);
assert_eq!(d.app().session.history.undo.len(), undo, "inspector focus does not create edits");
assert_eq!(d.app().session.playhead(), playhead);
// Preserve Metadata's existing fallback in both directions when a selection is cleared.
d.click(&format!("timeline.clip.{}", clip.0));
d.ok("ui.key", json!({"key":"Cmd+Shift+A"}));
assert!(d.app().session.state.selection.is_empty());
d.click("panel.tab.Metadata");
assert_eq!(d.label("metadata.header"), format!("Clip: {a_name}"));
d.click("panel.tab.Info");
assert_eq!(d.label("info.item"), a_name);
d.click(&format!("timeline.clip.{}", clip.0));
d.click("panel.tab.Project");
d.ok("ui.key", json!({"key":"Cmd+Shift+A"}));
assert!(d.app().session.state.project_selection.is_empty());
d.click("panel.tab.Info");
assert_eq!(d.label("info.item"), b_name);
d.click("panel.tab.Metadata");
assert_eq!(d.label("metadata.header"), format!("Clip: {b_name}"));
d.ok("ui.set", json!({"theme":"light"}));
d.click("panel.tab.Info");
assert_eq!(d.label("info.item"), b_name, "theme and inspector changes keep the selection source");
d.snapshot("panels-info-timeline-selection-light", Some("info."));
d.click(&format!("timeline.clip.{}", clip.0));
d.ok("ui.key", json!({"key":"Cmd+Shift+A"}));
assert!(d.app().session.state.selection.is_empty());
d.click("panel.tab.Metadata");
assert!(d.has("metadata.empty"));
d.click("panel.tab.Info");
assert!(!d.has("info.item"));
assert!(!d.label("info.sequence").is_empty(), "active sequence details remain with no clip selected");
d.click("panel.tab.Project");
d.click(&format!("project.item.{}", a.0));
d.click("panel.tab.Info");
assert_eq!(d.label("info.item"), a_name);
d.exec("file.newProject", json!({"name":"Fresh inspector project"}));
d.frames(3);
assert!(!d.has("info.item"), "no item identity is retained from the old project");
assert!(!d.has("info.sequence"));
d.click("panel.tab.Metadata");
assert!(d.has("metadata.empty"));
}
#[test]
fn inspector_source_defaults_when_loading_an_older_ui_state() {
let ui = filmcraft_ui_egui::state::UiState::default();
let mut saved = serde_json::to_value(&ui).unwrap();
saved["panels"].as_object_mut().unwrap().remove("inspectorSource");
let restored: filmcraft_ui_egui::state::UiState = serde_json::from_value(saved).unwrap();
assert_eq!(restored.panels.inspector_source, filmcraft_ui_egui::panels::panel_state::InspectorSource::Project);
assert_eq!(restored.panels.scopes, ui.panels.scopes);
}
#[test]
fn middle_closing_an_inactive_project_tab_keeps_the_inspector_target() {
let (mut d, _, b, _) = inspector_selection_driver();
let name = d.app().session.project.item(b).unwrap().name.clone();
d.click("panel.tab.Info");
assert_eq!(d.label("info.item"), name);
assert!(d.has("panel.tab.Project"), "the inactive Project tab must be visible before closing it");
let project = serde_json::to_value(&d.app().session.project).unwrap();
let state = d.exec("state.inspect", json!({}));
let history = d.exec("history.list", json!({}));
let revision = d.app().session.revision;
d.ok("ui.click", json!({"id":"panel.tab.Project", "button":"middle"}));
d.frames(3);
assert!(!d.has("panel.tab.Project"), "middle-click closes the inactive tab");
assert_eq!(serde_json::to_value(&d.app().session.project).unwrap(), project);
assert_eq!(d.exec("state.inspect", json!({})), state);
assert_eq!(d.exec("history.list", json!({})), history);
assert_eq!(d.app().session.revision, revision);
let focused = d.app().ui.focused;
let source = d.app().ui.panels.inspector_source;
assert_eq!(d.label("info.item"), name, "closing a tab must not select its stale item; focused={focused:?}, source={source:?}");
}
/// #2329: in the Effects panel what a folder holds is indented under it: an effect's label starts
/// right of its sub-folder's, a sub-folder's right of its top folder's, and the same for presets
/// and Color Grading presets.
#[test]
fn effects_are_indented_under_their_folders() {
fn text_x(d: &mut Driver, text: &str) -> f32 {
fn find(shapes: &[egui::Shape], text: &str) -> Option<f32> {
shapes.iter().find_map(|s| match s {
egui::Shape::Text(t) if t.galley.text() == text => Some(t.pos.x),
egui::Shape::Vec(v) => find(v, text),
_ => None,
})
}
let shapes: Vec<egui::Shape> = d.harness.output().shapes.iter().map(|c| c.shape.clone()).collect();
find(&shapes, text).unwrap_or_else(|| panic!("`{text}` is not drawn"))
}
let mut d = Driver::demo();
d.ok("ui.panel.show", json!({"panel": "Effects"}));
d.frames(3);
// Presets is opened last: its Import/Scan rows push the Color Grading sub-folders below the
// panel's visible area, where they can no longer be clicked.
for folder in ["Video Effects", "Video Effects/Blur & Sharpen", "Color Grading Presets", "Color Grading Presets/Monochrome", "Presets"] {
d.click(&format!("effects.folder.{folder}"));
}
d.frames(2);
let preset = d.app().session.presets.all()[0].name.clone();
let lumetri = filmcraft_render::lumetri_presets::presets().into_iter().find(|p| p.folder == "Monochrome").unwrap().name;
for (outer, inner) in [
("Video Effects", "Blur & Sharpen"),
("Blur & Sharpen", "Gaussian Blur"),
("Presets", preset.as_str()),
("Color Grading Presets", "Monochrome"),
("Monochrome", lumetri),
] {
let (a, b) = (text_x(&mut d, outer), text_x(&mut d, inner));
assert!(b >= a + 12.0, "`{inner}` ({b}) is not indented under `{outer}` ({a})");
}
}
/// #2719: opening the Presets folder scans `<data dir>/Effect Presets`, so a preset file copied
/// there while the app is running shows up without choosing Scan or restarting.
#[test]
fn opening_presets_folder_scans_the_library() {
let data = tempfile::tempdir().unwrap();
let mut session = Session::default();
session.execute("file.openDemoProject", json!({})).expect("demo project");
session.presets.set_dir(data.path());
let library = session.presets.library_dir().unwrap();
let mut d = Driver::with(session);
d.ok("ui.panel.show", json!({"panel": "Effects"}));
d.frames(3);
let name = "Dropped While Running";
let mut preset = serde_json::to_value(&d.app().session.presets.all()[0]).unwrap();
preset["name"] = json!(name);
let file = json!({"format": "filmcraft.effect-presets", "version": 1, "presets": [preset]});
std::fs::write(library.join("dropped.json"), serde_json::to_vec(&file).unwrap()).unwrap();
d.frames(2);
assert!(!d.app().session.presets.all().iter().any(|p| p.name == name), "nothing scans before the folder opens");
d.click("effects.folder.Presets");
assert!(d.app().session.presets.all().iter().any(|p| p.name == name), "opening Presets loads the dropped file");
assert!(d.ids("effects.preset.").iter().any(|id| id.ends_with(name)), "{:?}", d.ids("effects.preset."));
}
#[test]
fn effects_search_matches_turkish_casing() {
let mut d = Driver::demo();
d.exec("prefs.set", json!({"key": "general.interfaceLanguage", "value": "tr"}));
d.ok("ui.panel.show", json!({"panel": "Effects"}));
d.frames(3);
for query in ["IŞIK", "ışık", "Işık"] {
d.ok("ui.set", json!({"effectsSearch": query}));
d.frames(2);
assert!(d.has("effects.item.light_leaks"), "query `{query}` through Effects search caller must find `light_leaks`");
}
}
/// The font of the first run of every text shape drawn this frame, with the text, position and colour.
fn painted_text(d: &Driver) -> Vec<(String, egui::Pos2, egui::FontId, egui::Color32)> {
fn walk(s: &egui::Shape, out: &mut Vec<(String, egui::Pos2, egui::FontId, egui::Color32)>) {
match s {
egui::Shape::Text(t) => {
if let Some(sec) = t.galley.job.sections.first() {
out.push((t.galley.text().to_string(), t.pos, sec.format.font_id.clone(), sec.format.color));
}
}
egui::Shape::Vec(v) => v.iter().for_each(|s| walk(s, out)),
_ => {}
}
}
let mut out = Vec::new();
d.harness.output().shapes.iter().for_each(|c| walk(&c.shape, &mut out));
out
}
// Regression test for #130: the big blue timecodes over the timeline and under the monitors were
// drawn in 15 pt semibold; Premiere's are regular weight, 16 pt, in the timecode colour.
#[test]
fn big_timecodes_are_regular_weight_16pt_in_the_timecode_colour() {
let mut d = Driver::demo();
d.ok("ui.panel.show", json!({"panel": "Program"}));
d.ok("ui.panel.show", json!({"panel": "ReferenceMonitor"}));
d.frames(3);
let timecode = d.app().tokens.timecode;
for id in ["timeline.timecode", "program.timecode", "reference.timecode"] {
let rect = {
let v = d.ok("ui.elements", json!({"prefix": id}));
let e = v.as_array().unwrap().iter().find(|e| e["id"] == json!(id)).unwrap_or_else(|| panic!("no element {id}")).clone();
let r = &e["rect"];
egui::Rect::from_min_size(
egui::pos2(r[0].as_f64().unwrap() as f32, r[1].as_f64().unwrap() as f32),
egui::vec2(r[2].as_f64().unwrap() as f32, r[3].as_f64().unwrap() as f32),
)
};
let shown = d.label(id);
let (_, _, font, color) = painted_text(&d)
.into_iter()
.find(|(text, pos, ..)| *text == shown && rect.expand(2.0).contains(*pos))
.unwrap_or_else(|| panic!("{id}: `{shown}` is not drawn in {rect:?}"));
assert_eq!(font, egui::FontId::new(16.0, egui::FontFamily::Proportional), "{id}: font");
assert_eq!(color, timecode, "{id}: colour");
}
}
// Regression test for #130: the menu bar's menus were drawn in egui's default body size; Premiere's
// are the system's, larger (13 pt) and brighter than panel text.
#[test]
fn menu_bar_menus_use_the_13pt_menu_text() {
let mut d = Driver::demo();
d.click("menu.File");
d.frames(3);
for id in ["menu.File", "menu.file.open", "menu.file.save", "menu.file.saveAs"] {
let v = d.ok("ui.elements", json!({"prefix": id}));
let e = v.as_array().unwrap().iter().find(|e| e["id"] == json!(id)).unwrap_or_else(|| panic!("no menu item {id}")).clone();
let label = e["label"].as_str().unwrap().to_string();
let r = &e["rect"];
let rect = egui::Rect::from_min_size(
egui::pos2(r[0].as_f64().unwrap() as f32, r[1].as_f64().unwrap() as f32),
egui::vec2(r[2].as_f64().unwrap() as f32, r[3].as_f64().unwrap() as f32),
);
let (_, _, font, _) = painted_text(&d)
.into_iter()
.find(|(text, pos, ..)| *text == label && rect.contains(*pos))
.unwrap_or_else(|| panic!("`{label}` is not drawn in {rect:?}"));
assert_eq!(font.size, 13.0, "`{label}` in the File menu");
}
}
/// #3669: opening a clip in the Source monitor must also focus it, so Space plays that clip.
#[test]
fn opening_a_clip_in_source_focuses_it_so_space_plays_it() {
let (mut d, a, _, _) = inspector_selection_driver();
d.click("panel.tab.Project");
// what a double-click on a Project item runs
d.exec("source.open", json!({"item": a.0}));
d.frames(3);
assert_eq!(d.app().session.state.source_item, Some(a));
assert_eq!(d.app().ui.focused, filmcraft_ui_egui::dock::PanelKind::Source, "Source takes focus");
assert!(!d.app().source_playback.clock.playing);
d.ok("ui.key", json!({"key": "Space"}));
d.frames(2);
assert!(d.app().source_playback.clock.playing, "Space plays the Source clip");
}
/// #3669: a closed Source panel is reopened (not left hidden) when a clip opens in it.
#[test]
fn opening_a_clip_in_source_reopens_a_closed_source_panel() {
use filmcraft_ui_egui::dock::PanelKind;
let (mut d, a, _, _) = inspector_selection_driver();
d.ok("ui.panel.close", json!({"panel": PanelKind::Source.id()}));
d.frames(2);
assert!(!d.app().ui.dock.contains(&PanelKind::Source), "Source is closed");
d.exec("source.open", json!({"item": a.0}));
d.frames(3);
assert!(d.app().ui.dock.contains(&PanelKind::Source), "Source is docked again");
assert_eq!(d.app().ui.focused, PanelKind::Source);
}
/// #3669: another maximized panel no longer hides the Source monitor that just got focus.
#[test]
fn opening_a_clip_in_source_clears_another_panels_maximize() {
use filmcraft_ui_egui::dock::PanelKind;
let (mut d, a, _, _) = inspector_selection_driver();
d.app().ui.keys.maximized = Some(PanelKind::Project);
d.exec("source.open", json!({"item": a.0}));
d.frames(3);
assert_eq!(d.app().ui.keys.maximized, None, "the maximize is cleared so Source is visible");
assert_eq!(d.app().ui.focused, PanelKind::Source);
}
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.