f67d38b35cc5
drop_preview_ui.rs
//! Dragging a Project item over the Timeline previews every track the drop fills (#1887): an item
//! with picture and sound shows a box on its video track and on its audio track, not only on the
//! row under the pointer, and the drop then lands on exactly the previewed tracks.
use std::collections::BTreeSet;
use std::sync::mpsc::{Sender, channel};
use egui_kittest::Harness;
use filmcraft_engine::Session;
use filmcraft_project::{BinEntry, ItemId};
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>,
/// `FILMCRAFT_UI_SNAPSHOT_DIR`: where each drag's mid-drag frame is saved (off by default).
snapshots: Option<std::path::PathBuf>,
}
impl Driver {
/// The demo project with a new, empty sequence open.
fn demo() -> Self {
let mut session = Session::default();
session.execute("file.openDemoProject", json!({})).expect("demo project");
session.execute("file.newSequence", json!({"name": "Drop preview", "width": 1280, "height": 720, "fps": 24})).expect("sequence");
session.prefs.timeline.clip_mismatch_warning = false;
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 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 ok(&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(r) = reply.try_recv() {
assert_eq!(r["ok"], true, "{method} {params}: {r}");
return r["result"].clone();
}
}
panic!("no reply to {method} {params}");
}
fn ids(&mut self, prefix: &str) -> BTreeSet<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()
}
fn rect(&mut self, id: &str) -> egui::Rect {
let v = self.ok("ui.elements", json!({"prefix": id}));
let e = v.as_array().unwrap().iter().find(|e| e["id"] == id).unwrap_or_else(|| panic!("no element {id}")).clone();
let r: Vec<f32> = e["rect"].as_array().unwrap().iter().map(|x| x.as_f64().unwrap() as f32).collect();
egui::Rect::from_min_size(egui::pos2(r[0], r[1]), egui::vec2(r[2], r[3]))
}
fn send(&mut self, e: egui::Event) {
self.harness.input_mut().events.push(e);
self.frames(1);
}
/// The demo's Footage bin open in the Project panel's list view: an item in it carrying
/// `video` / `audio`, and its row's centre.
fn footage_item(&mut self, video: bool, audio: bool) -> Option<(ItemId, egui::Pos2)> {
let p = &self.harness.state().session.project;
let bin = p.root.children.iter().find_map(|e| if let BinEntry::Bin(b) = e { (b.name == "Footage").then(|| b.clone()) } else { None })?;
let item = bin.children.iter().find_map(|e| match e {
BinEntry::Item(i) if p.source_streams(*i) == (video, audio) => Some(*i),
_ => None,
})?;
self.ok("ui.panel.show", json!({"panel": "Project"}));
self.ok("engine.execute", json!({"command": "project.view.set", "params": {"view": "list"}}));
self.ok("ui.menu.invoke", json!({"id": "projectPanel.openBin", "params": {"bin": bin.id.0, "how": "inPlace"}}));
self.frames(4);
let row = self.rect(&format!("project.item.{}", item.0));
Some((item, row.center()))
}
/// Drag from `from` to 60 px into the clip area of the track row labelled `track`; returns the
/// drop previews shown there while the button is still down, then drops.
fn drag_to_track(&mut self, from: egui::Pos2, track: &str) -> BTreeSet<String> {
let row = self.rect(&format!("timeline.track.{track}.target"));
let panel = self.rect("panel.Timeline");
let to = egui::pos2(panel.min.x + self.harness.state().ui.timeline.header_w + 60.0, row.center().y);
let button = |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
self.send(egui::Event::PointerMoved(from));
self.send(button(from, true));
for k in 1..=12 {
self.send(egui::Event::PointerMoved(from.lerp(to, k as f32 / 12.0)));
}
self.frames(2);
let shown = self.ids("timeline.dropPreview.");
self.snapshot(&format!("drop-preview-over-{track}"));
self.send(button(to, false));
self.frames(4);
shown
}
fn snapshot(&mut self, name: &str) {
let Some(dir) = self.snapshots.clone() else { return };
match self.harness.render() {
Ok(img) => {
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join(format!("{name}.png"));
img.save(&path).unwrap();
eprintln!("snapshot: {}", path.display());
}
Err(e) => eprintln!("snapshot {name} skipped: {e}"),
}
}
/// "V2" / "A1" labels of the active sequence's tracks that hold a clip of `item`.
fn tracks_holding(&self, item: ItemId) -> BTreeSet<String> {
let q = self.harness.state().session.active_sequence().unwrap();
let named = |letter: char, tracks: &[filmcraft_project::Track]| {
tracks
.iter()
.enumerate()
.filter(|(_, t)| t.items.iter().any(|c| c.item == item))
.map(move |(k, _)| format!("{letter}{}", k + 1))
.collect::<Vec<_>>()
};
named('V', &q.video_tracks).into_iter().chain(named('A', &q.audio_tracks)).collect()
}
}
fn previews(tracks: &[&str]) -> BTreeSet<String> {
tracks.iter().map(|t| format!("timeline.dropPreview.{t}")).collect()
}
#[test]
fn a_clip_with_picture_and_sound_previews_its_video_and_audio_tracks() {
for (hover, expected) in [("V2", ["V2", "A2"]), ("A1", ["V1", "A1"])] {
let mut d = Driver::demo();
let (item, from) = d.footage_item(true, true).expect("the demo has a clip with picture and sound");
let shown = d.drag_to_track(from, hover);
assert_eq!(shown, previews(&expected), "hovering {hover}");
let placed: BTreeSet<String> = d.tracks_holding(item).into_iter().map(|t| format!("timeline.dropPreview.{t}")).collect();
assert_eq!(placed, shown, "the drop lands on the previewed tracks (hovering {hover})");
}
}
#[test]
fn a_picture_only_item_over_an_audio_track_previews_the_video_track_it_goes_to() {
let mut d = Driver::demo();
let made = d.ok("engine.execute", json!({"command": "file.newColorMatte", "params": {"width": 64, "height": 36, "color": "#ff0000"}}));
let item = ItemId(made["item"].as_u64().expect("a color matte"));
assert_eq!(d.harness.state().session.project.source_streams(item), (true, false));
d.ok("ui.panel.show", json!({"panel": "Project"}));
d.ok("engine.execute", json!({"command": "project.view.set", "params": {"view": "list"}}));
d.frames(4);
let from = d.rect(&format!("project.item.{}", item.0)).center();
let shown = d.drag_to_track(from, "A2");
assert_eq!(shown, previews(&["V2"]));
assert_eq!(d.tracks_holding(item), ["V2".to_string()].into_iter().collect());
}
/// Review on #2151: with the nest toggle off a sequence edits in as its clips, one track per
/// source track, counted from the track it is dropped on. Dropped on V2 (not V1), the previewed
/// rows are the rows the clips land on.
#[test]
fn a_sequence_dropped_unnested_on_v2_previews_the_tracks_its_clips_land_on() {
let mut d = Driver::demo();
d.ok("engine.execute", json!({"command": "sequence.nestSequences", "params": {"on": false}}));
let (seq, bin) = {
let s = &d.harness.state().session;
let p = &s.project;
let bin = p
.root
.children
.iter()
.find_map(|e| if let BinEntry::Bin(b) = e { (b.name == "Sequences").then(|| b.clone()) } else { None })
.expect("the demo's Sequences bin");
let seq = bin
.children
.iter()
.find_map(|e| match e {
BinEntry::Item(i) if p.sequence(*i).is_some() && Some(*i) != s.state.active_sequence => Some(*i),
_ => None,
})
.expect("the demo sequence");
(seq, bin.id)
};
d.ok("ui.panel.show", json!({"panel": "Project"}));
d.ok("engine.execute", json!({"command": "project.view.set", "params": {"view": "list"}}));
d.ok("ui.menu.invoke", json!({"id": "projectPanel.openBin", "params": {"bin": bin.0, "how": "inPlace"}}));
d.frames(4);
let from = d.rect(&format!("project.item.{}", seq.0)).center();
let shown = d.drag_to_track(from, "V2");
let filled: BTreeSet<String> = {
let q = d.harness.state().session.active_sequence().unwrap();
let named = |letter: char, tracks: &[filmcraft_project::Track]| {
tracks
.iter()
.enumerate()
.filter(|(_, t)| !t.items.is_empty())
.map(move |(k, _)| format!("timeline.dropPreview.{letter}{}", k + 1))
.collect::<Vec<_>>()
};
named('V', &q.video_tracks).into_iter().chain(named('A', &q.audio_tracks)).collect()
};
assert!(filled.len() > 2, "the demo sequence spans several tracks: {filled:?}");
assert!(!filled.contains("timeline.dropPreview.V1"), "nothing lands below the drop track: {filled:?}");
assert_eq!(shown, filled, "the previewed rows are the rows the clips land on");
}
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.