566 lines
26 KiB
Rust
566 lines
26 KiB
Rust
//! Headless UI tests of trimming in the Timeline (#259): a press acts on what was under the
|
|
//! pointer when the button went down, the side of a cut picks the clip, and the cursor,
|
|
//! `ui.timeline.hit` and the press agree. The real `FilmcraftApp` under `egui_kittest` with the
|
|
//! demo project, the pointer moving a few pixels per frame as a mouse does.
|
|
|
|
use std::sync::mpsc::{Sender, channel};
|
|
|
|
use egui::{CursorIcon, Pos2, pos2};
|
|
use egui_kittest::Harness;
|
|
use filmcraft_engine::Session;
|
|
use filmcraft_project::ClipId;
|
|
use filmcraft_ui_egui::FilmcraftApp;
|
|
use filmcraft_ui_egui::control::ControlRequest;
|
|
use serde_json::{Value, json};
|
|
|
|
/// Two clips of the demo project that share a cut on V1.
|
|
const CITY: &str = "City_Night_Drive.mp4";
|
|
const DUNES: &str = "Desert_Dunes.mp4";
|
|
|
|
struct Driver {
|
|
harness: Harness<'static, FilmcraftApp>,
|
|
tx: Sender<ControlRequest>,
|
|
}
|
|
|
|
impl Driver {
|
|
/// The demo project, snapping off so drags land exactly where the pointer goes. Frames are
|
|
/// 1/60 s apart, as on a display: at the harness's default 1/4 s, a press held for four frames
|
|
/// is already a drag by time (egui's 0.8 s click limit), wherever the pointer is.
|
|
fn demo() -> Self {
|
|
let mut session = Session::default();
|
|
session.execute("file.openDemoProject", json!({})).expect("demo project");
|
|
session.execute("sequence.snap", json!({"on": false})).expect("snapping off");
|
|
let (tx, rx) = channel();
|
|
let app = FilmcraftApp::new(session).with_control(rx);
|
|
let harness = Harness::builder().with_size(egui::vec2(1600.0, 980.0)).with_step_dt(1.0 / 60.0).with_max_steps(10_000).build_eframe(move |_cc| app);
|
|
let mut d = Driver { harness, tx };
|
|
d.frames(4);
|
|
// `ui.elements` answers once the timeline has finished fitting the sequence
|
|
d.ok("ui.elements", json!({"prefix": "timeline.clip."}));
|
|
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 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 app(&self) -> &FilmcraftApp {
|
|
self.harness.state()
|
|
}
|
|
|
|
/// Press at `from`, move to `to` over `steps` frames (as a mouse does), release.
|
|
fn drag(&mut self, from: Pos2, to: Pos2, steps: usize) {
|
|
let push = |d: &mut Self, e: egui::Event| d.harness.input_mut().events.push(e);
|
|
push(self, egui::Event::PointerMoved(from));
|
|
self.frames(1);
|
|
push(self, egui::Event::PointerButton { pos: from, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() });
|
|
self.frames(1);
|
|
for i in 1..=steps {
|
|
push(self, egui::Event::PointerMoved(from + (to - from) * (i as f32 / steps as f32)));
|
|
self.frames(1);
|
|
}
|
|
push(self, egui::Event::PointerButton { pos: to, button: egui::PointerButton::Primary, pressed: false, modifiers: Default::default() });
|
|
self.frames(2);
|
|
}
|
|
|
|
/// Move the pointer to `at` with no button down, and let the Timeline react.
|
|
fn hover(&mut self, at: Pos2) {
|
|
self.harness.input_mut().events.push(egui::Event::PointerMoved(at));
|
|
self.frames(2);
|
|
}
|
|
|
|
/// The cursor the last frame asked for.
|
|
fn cursor(&self) -> CursorIcon {
|
|
self.harness.output().platform_output.cursor_icon
|
|
}
|
|
|
|
/// Render the window to `<target tmp>/ui-screenshots/<name>.png` (needs a GPU).
|
|
fn screenshot(&mut self, name: &str) -> std::path::PathBuf {
|
|
self.frames(2);
|
|
let img = self.harness.render().expect("render");
|
|
let png = filmcraft_ui_egui::control::encode_png(img.as_raw(), img.width(), img.height()).expect("png");
|
|
let dir = std::path::PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join("ui-screenshots");
|
|
std::fs::create_dir_all(&dir).unwrap();
|
|
let path = dir.join(format!("{name}.png"));
|
|
std::fs::write(&path, png).unwrap();
|
|
eprintln!("screenshot: {}", path.display());
|
|
path
|
|
}
|
|
|
|
/// The clip named `name` on V1.
|
|
fn v1_clip(&self, name: &str) -> u64 {
|
|
let seq = self.app().session.active_sequence().expect("sequence");
|
|
seq.video_tracks[0].items.iter().find(|i| i.name == name).unwrap_or_else(|| panic!("no {name} on V1")).id.0
|
|
}
|
|
|
|
/// A clip's (start, end) in ticks.
|
|
fn span(&self, clip: u64) -> (i64, i64) {
|
|
let seq = self.app().session.active_sequence().expect("sequence");
|
|
let (_, it) = seq.find_item(ClipId(clip)).expect("clip");
|
|
(it.start.0, it.end().0)
|
|
}
|
|
|
|
/// Screen x of a clip's In and Out edges, and a y 8 px below the top of its track: the band
|
|
/// where edges are grabbed, above the lower part of a track where a transition on a cut takes
|
|
/// the press (the demo has one on the City_Night_Drive / Desert_Dunes cut).
|
|
fn edges(&mut self, clip: u64) -> (f32, f32, f32) {
|
|
// `ui.timeline.locate` answers with points 2 px inside the edges
|
|
let i = self.ok("ui.timeline.locate", json!({"clip": clip, "edge": "in"}));
|
|
let o = self.ok("ui.timeline.locate", json!({"clip": clip, "edge": "out"}));
|
|
let f = |v: &Value, k: &str| v[k].as_f64().expect("number") as f32;
|
|
let id = format!("timeline.clip.{clip}");
|
|
let els = self.ok("ui.elements", json!({"prefix": id}));
|
|
let el = els.as_array().expect("elements").iter().find(|e| e["id"] == id.as_str()).unwrap_or_else(|| panic!("no {id}: {els}")).clone();
|
|
let top = el["rect"][1].as_f64().expect("rect") as f32;
|
|
(f(&i, "x") - 2.0, f(&o, "x") + 2.0, top + 8.0)
|
|
}
|
|
|
|
/// Ticks per screen pixel, from a clip's length on screen.
|
|
fn ticks_per_px(&mut self, clip: u64) -> f64 {
|
|
let (s, e) = self.span(clip);
|
|
let (x0, x1, _) = self.edges(clip);
|
|
(e - s) as f64 / f64::from(x1 - x0)
|
|
}
|
|
|
|
/// One frame of the sequence, in ticks.
|
|
fn frame(&self) -> i64 {
|
|
self.app().session.active_sequence().expect("sequence").settings.frame_rate.frame_duration().0
|
|
}
|
|
|
|
fn undo_steps(&self) -> usize {
|
|
self.app().session.history.undo.len()
|
|
}
|
|
}
|
|
|
|
/// #259: grabbing a clip's Out edge 3 px inside and dragging inward trims it, by as far as the
|
|
/// pointer moved. The drag is recognised only once the pointer has moved past egui's 6 pt drag
|
|
/// threshold, about 10 px inside the clip and so outside the 7 px edge zone, where the clip used to
|
|
/// be selected and moved instead.
|
|
#[test]
|
|
fn dragging_an_out_edge_inward_trims_the_clip() {
|
|
let mut d = Driver::demo();
|
|
let city = d.v1_clip(CITY);
|
|
let (x0, x1, y) = d.edges(city);
|
|
let (s0, e0) = d.span(city);
|
|
let (tpp, frame, undo0) = (d.ticks_per_px(city), d.frame(), d.undo_steps());
|
|
let by = ((x1 - x0) / 4.0).round();
|
|
d.drag(pos2(x1 - 3.0, y), pos2(x1 - 3.0 - by, y), by as usize);
|
|
let (s1, e1) = d.span(city);
|
|
assert_eq!(s1, s0, "the In edge stayed: trimmed, not moved");
|
|
assert!(e1 < e0, "the Out edge moved in: {e0} → {e1}");
|
|
let want = f64::from(by) * tpp;
|
|
assert!(((e0 - e1) as f64 - want).abs() <= frame as f64, "the edge moved {} ticks for {by} px ({want} ticks) ± a frame ({frame})", e0 - e1);
|
|
assert_eq!(d.undo_steps(), undo0 + 1, "one undo step");
|
|
}
|
|
|
|
/// Just right of a cut the clip on the right is grabbed: its In edge trims, and the clip on the
|
|
/// left stays as it was. The left clip's Out edge used to claim both sides of the cut.
|
|
#[test]
|
|
fn right_of_a_cut_trims_the_right_clip() {
|
|
let mut d = Driver::demo();
|
|
let (city, dunes) = (d.v1_clip(CITY), d.v1_clip(DUNES));
|
|
assert_eq!(d.span(city).1, d.span(dunes).0, "the demo's City_Night_Drive and Desert_Dunes share a cut");
|
|
let (cut, _, y) = d.edges(dunes);
|
|
let (city0, (s0, e0)) = (d.span(city), d.span(dunes));
|
|
d.drag(pos2(cut + 3.0, y), pos2(cut + 43.0, y), 40);
|
|
let (s1, e1) = d.span(dunes);
|
|
assert!(s1 > s0, "Desert_Dunes' In edge moved right: {s0} → {s1}");
|
|
assert_eq!(e1, e0, "Desert_Dunes' Out edge stayed: trimmed, not moved");
|
|
assert_eq!(d.span(city), city0, "City_Night_Drive is untouched");
|
|
}
|
|
|
|
/// A click that wobbles 5.5 px (still a click to egui, under its 6 pt limit) selects the edit point
|
|
/// that was pressed. It used to be hit-tested where the button came up, 8.5 px inside the clip and
|
|
/// outside the edge zone, and selected the clip.
|
|
#[test]
|
|
fn a_wobbly_click_on_an_edge_selects_the_edit_point() {
|
|
let mut d = Driver::demo();
|
|
let city = d.v1_clip(CITY);
|
|
let st = &mut d.harness.state_mut().session.state;
|
|
st.selection.clear();
|
|
st.edit_points.clear();
|
|
let (_, x1, y) = d.edges(city);
|
|
d.drag(pos2(x1 - 3.0, y), pos2(x1 - 8.5, y), 3);
|
|
let st = &d.app().session.state;
|
|
assert!(st.edit_points.iter().any(|e| e.clip == ClipId(city) && e.out), "City_Night_Drive's Out edge is the edit point: {:?}", st.edit_points);
|
|
assert!(!st.selection.contains(&ClipId(city)), "the clip is not selected");
|
|
}
|
|
|
|
/// A moved clip stays under the point it was grabbed by. It used to lag behind the pointer by the
|
|
/// distance egui waits before it calls a press a drag.
|
|
#[test]
|
|
fn a_moved_clip_follows_the_pointer_from_where_it_was_grabbed() {
|
|
let mut d = Driver::demo();
|
|
let city = d.v1_clip(CITY);
|
|
let (x0, x1, y) = d.edges(city);
|
|
let (s0, _) = d.span(city);
|
|
let (tpp, frame) = (d.ticks_per_px(city), d.frame());
|
|
let mid = (x0 + x1) / 2.0;
|
|
d.drag(pos2(mid, y), pos2(mid + 120.0, y), 30);
|
|
let (s1, _) = d.span(city);
|
|
let want = 120.0 * tpp;
|
|
assert!(((s1 - s0) as f64 - want).abs() <= frame as f64, "moved {} ticks for 120 px ({want} ticks) ± a frame ({frame})", s1 - s0);
|
|
}
|
|
|
|
/// The cursor, `ui.timeline.hit` and the press agree on what is under the pointer: just left of
|
|
/// a cut the left clip's Out edge, just right of it the right clip's In edge, mid-clip no edge.
|
|
/// (That a drag from those points trims those edges is tested above, from the same points.)
|
|
#[test]
|
|
fn cursor_hit_test_and_press_agree_at_a_cut() {
|
|
let mut d = Driver::demo();
|
|
let (city, dunes) = (d.v1_clip(CITY), d.v1_clip(DUNES));
|
|
let (x0, _, _) = d.edges(city);
|
|
let (cut, _, y) = d.edges(dunes);
|
|
let hit = |d: &mut Driver, x: f32, mods: Value| d.ok("ui.timeline.hit", json!({"x": x, "y": y, "modifiers": mods}));
|
|
for (x, clip, edge) in [(cut - 3.0, city, "Out"), (cut + 3.0, dunes, "In")] {
|
|
d.hover(pos2(x, y));
|
|
assert_eq!(d.cursor(), CursorIcon::ResizeColumn, "trim cursor at x {x}");
|
|
let h = hit(&mut d, x, json!({}));
|
|
assert_eq!((h["clip"].as_u64(), h["edge"].as_str(), h["kind"].as_str()), (Some(clip), Some(edge), Some("trim")), "at x {x}: {h}");
|
|
let h = hit(&mut d, x, json!({"command": true}));
|
|
assert_eq!(h["kind"], "ripple", "Cmd at x {x}: {h}");
|
|
}
|
|
let mid = (x0 + cut) / 2.0;
|
|
d.hover(pos2(mid, y));
|
|
assert_eq!(d.cursor(), CursorIcon::Default, "no trim cursor mid-clip");
|
|
let h = hit(&mut d, mid, json!({}));
|
|
assert_eq!((h["clip"].as_u64(), h["kind"].clone()), (Some(city), Value::Null), "mid-clip: {h}");
|
|
}
|
|
|
|
/// Renders the hover bracket at the City_Night_Drive / Desert_Dunes cut to PNGs for visual
|
|
/// review (needs a GPU): `cargo test -p filmcraft-ui-egui --test timeline_trim_ui -- --ignored
|
|
/// hover_bracket_screenshots`. Yellow on City_Night_Drive's Out edge just left of the cut and on
|
|
/// Desert_Dunes' In edge just right of it, red for the Ripple tool, both sides for the Rolling tool.
|
|
#[test]
|
|
#[ignore]
|
|
fn hover_bracket_screenshots() {
|
|
let mut d = Driver::demo();
|
|
let dunes = d.v1_clip(DUNES);
|
|
let (cut, _, y) = d.edges(dunes);
|
|
for (tool, name, x) in
|
|
[("selection", "trim-out", cut - 3.0), ("selection", "trim-in", cut + 3.0), ("ripple", "ripple-in", cut + 3.0), ("rolling", "roll", cut + 3.0)]
|
|
{
|
|
d.ok("ui.set", json!({"tool": tool}));
|
|
d.hover(pos2(x, y));
|
|
d.screenshot(&format!("hover-{name}"));
|
|
}
|
|
}
|
|
|
|
/// A caption's Out edge, grabbed 2 px inside and dragged inward, trims the caption. The gesture
|
|
/// used to be decided where the drag was recognised, about 9 px inside (2 px plus egui's 6 pt drag
|
|
/// threshold), past the 5 px edge zone, so the caption moved.
|
|
#[test]
|
|
fn dragging_a_caption_edge_inward_trims_it() {
|
|
let mut d = Driver::demo();
|
|
let id = d.exec("captions.add", json!({"seconds": 2.0, "durationSeconds": 2.0}))["caption"].as_u64().expect("caption id");
|
|
d.frames(4);
|
|
let name = format!("timeline.caption.{id}");
|
|
let els = d.ok("ui.elements", json!({"prefix": name}));
|
|
let el = els.as_array().expect("elements").iter().find(|e| e["id"] == name.as_str()).unwrap_or_else(|| panic!("no {name}: {els}")).clone();
|
|
let r: Vec<f32> = el["rect"].as_array().expect("rect").iter().map(|v| v.as_f64().expect("number") as f32).collect();
|
|
let (x1, y) = (r[0] + r[2], r[1] + r[3] / 2.0);
|
|
let span = |d: &Driver| {
|
|
let seq = d.app().session.active_sequence().expect("sequence");
|
|
let (_, c) = seq.find_caption(ClipId(id)).expect("caption");
|
|
(c.start.0, c.end().0)
|
|
};
|
|
let (s0, e0) = span(&d);
|
|
d.drag(pos2(x1 - 2.0, y), pos2(x1 - 32.0, y), 30);
|
|
let (s1, e1) = span(&d);
|
|
assert_eq!(s1, s0, "the caption's start stayed: trimmed, not moved");
|
|
assert!(e1 < e0, "the caption's end moved in: {e0} → {e1}");
|
|
}
|
|
|
|
/// #374: renders the Ambient_Score music clip mid-way through a trim of its In edge, with the
|
|
/// mouse button still down, for visual review (needs a GPU): `cargo test -p filmcraft-ui-egui
|
|
/// --test timeline_trim_ui -- --ignored trim_waveform_screenshots`. The waveform stays where it was
|
|
/// and is cut off at the moving edge; it used to squeeze the whole clip's waveform into the shorter
|
|
/// clip, so the sound under the pointer moved while dragging.
|
|
#[test]
|
|
#[ignore]
|
|
fn trim_waveform_screenshots() {
|
|
let mut d = Driver::demo();
|
|
let seq = d.app().session.active_sequence().expect("sequence");
|
|
let music = seq.audio_tracks.iter().flat_map(|t| &t.items).find(|i| i.name.contains("Ambient")).expect("music clip").id.0;
|
|
let (x0, _, y) = d.edges(music);
|
|
// waveform peaks are read on a background thread
|
|
for _ in 0..40 {
|
|
std::thread::sleep(std::time::Duration::from_millis(50));
|
|
d.frames(1);
|
|
}
|
|
d.screenshot("trim-waveform-before");
|
|
let push = |d: &mut Driver, e: egui::Event| d.harness.input_mut().events.push(e);
|
|
let to = pos2(x0 + 160.0, y);
|
|
push(&mut d, egui::Event::PointerMoved(pos2(x0, y)));
|
|
d.frames(1);
|
|
push(&mut d, egui::Event::PointerButton { pos: pos2(x0, y), button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() });
|
|
d.frames(1);
|
|
for i in 1..=20 {
|
|
push(&mut d, egui::Event::PointerMoved(pos2(x0 + 160.0 * i as f32 / 20.0, y)));
|
|
d.frames(1);
|
|
}
|
|
d.screenshot("trim-waveform-dragging");
|
|
push(&mut d, egui::Event::PointerButton { pos: to, button: egui::PointerButton::Primary, pressed: false, modifiers: Default::default() });
|
|
d.frames(2);
|
|
d.screenshot("trim-waveform-released");
|
|
}
|
|
|
|
/// #653: an Out edge dragged far past the end of the clip's media stops there while the drag is
|
|
/// still in progress, at the same place the trim lands on release. It used to follow the pointer
|
|
/// past the media and then jump back when the button came up.
|
|
#[test]
|
|
fn an_edge_dragged_past_the_media_stops_at_its_end() {
|
|
use filmcraft_ui_egui::panels::timeline::Drag;
|
|
let mut d = Driver::demo();
|
|
let last = d.app().session.active_sequence().expect("sequence").video_tracks[0].items.last().expect("a clip on V1").id.0;
|
|
let (_, x1, y) = d.edges(last);
|
|
let (_, e0) = d.span(last);
|
|
let far = filmcraft_time::Tick(3600 * filmcraft_time::TICKS_PER_SECOND);
|
|
let limit = filmcraft_engine::commands::trim_delta(&d.app().session, ClipId(last), filmcraft_edit::Edge::Out, filmcraft_edit::TrimMode::Regular, far)
|
|
.expect("limit");
|
|
let (from, to) = (pos2(x1 - 3.0, y), pos2(x1 + 300.0, y));
|
|
let push = |d: &mut Driver, e: egui::Event| d.harness.input_mut().events.push(e);
|
|
push(&mut d, egui::Event::PointerMoved(from));
|
|
d.frames(1);
|
|
push(&mut d, egui::Event::PointerButton { pos: from, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() });
|
|
d.frames(1);
|
|
for i in 1..=60 {
|
|
push(&mut d, egui::Event::PointerMoved(from + (to - from) * (i as f32 / 60.0)));
|
|
d.frames(1);
|
|
}
|
|
match &d.app().tl.drag {
|
|
Some(Drag::Trim { delta, .. }) => assert_eq!(*delta, limit, "the dragged edge stops at the end of the media"),
|
|
other => panic!("not trimming: {other:?}"),
|
|
}
|
|
push(&mut d, egui::Event::PointerButton { pos: to, button: egui::PointerButton::Primary, pressed: false, modifiers: Default::default() });
|
|
d.frames(2);
|
|
assert_eq!(d.span(last).1, e0 + limit.0, "released where it was shown");
|
|
}
|
|
|
|
/// Dragging a picture in the Trim Monitor must not deadlock: the shift bookkeeping used to call
|
|
/// `drag_delta()` inside `data_mut()`, and both take egui's non-reentrant context write-lock, so
|
|
/// the drag froze the whole app on its first recognised frame (the delta is read before locking
|
|
/// now). The drag commits one normal trim on release.
|
|
#[test]
|
|
fn dragging_in_the_trim_monitor_trims_without_hanging() {
|
|
let mut d = Driver::demo();
|
|
let city = d.v1_clip(CITY);
|
|
d.exec("trim.selectEditPoint", json!({"clip": city, "edge": "out", "kind": "trim"}));
|
|
d.frames(2);
|
|
// the Program panel shows the two-up Trim Monitor once an edit point is selected
|
|
let els = d.ok("ui.elements", json!({"prefix": "trimMonitor."}));
|
|
let out =
|
|
els.as_array().expect("elements").iter().find(|e| e["id"] == "trimMonitor.outgoing").unwrap_or_else(|| panic!("trim monitor not shown: {els}")).clone();
|
|
let r: Vec<f32> = out["rect"].as_array().expect("rect").iter().map(|v| v.as_f64().expect("number") as f32).collect();
|
|
let (cx, cy) = (r[0] + r[2] / 2.0, r[1] + r[3] / 2.0);
|
|
// about 66 px of drag = the 6 pt threshold + 60 px of motion, at 6 px per frame;
|
|
// inward (left) trims into the clip's media, outward would clamp at the seamless cut
|
|
let (_, e0) = d.span(city);
|
|
d.drag(pos2(cx, cy), pos2(cx - 66.0, cy), 33);
|
|
let (_, e1) = d.span(city);
|
|
let frames = (e1 - e0) / d.frame();
|
|
assert!(e1 < e0, "the Out edge moved in by {} frames", frames.abs());
|
|
assert!((6..=14).contains(&-frames), "about 11 frames expected for 60 px at 6 px/frame, moved {}", frames.abs());
|
|
}
|
|
|
|
fn locked_move_keeps_the_original_preview(audio: bool, destination: bool, linked_partner: bool, edge: Option<&str>) {
|
|
let mut d = Driver::demo();
|
|
d.exec("sequence.linkedSelection", json!({"on": linked_partner}));
|
|
let seq = d.app().session.active_sequence().unwrap();
|
|
let tracks = if audio { &seq.audio_tracks } else { &seq.video_tracks };
|
|
let clip = tracks[0].items[0].id;
|
|
let locked = if linked_partner { seq.audio_tracks[0].id } else { tracks[usize::from(destination)].id };
|
|
d.exec("timeline.setTrack", json!({"track": locked.0, "locked": true}));
|
|
d.frames(3);
|
|
let prefix = format!("timeline.clip.{}", clip.0);
|
|
let original = d.ok("ui.elements", json!({"prefix": prefix}))[0]["rect"].clone();
|
|
let r = original.as_array().unwrap();
|
|
let from = pos2(r[0].as_f64().unwrap() as f32 + r[2].as_f64().unwrap() as f32 * 0.5, r[1].as_f64().unwrap() as f32 + 8.0);
|
|
let from = if let Some(edge) = edge {
|
|
let point = d.ok("ui.timeline.locate", json!({"clip": clip.0, "edge": edge}));
|
|
pos2(point["x"].as_f64().unwrap() as f32, from.y)
|
|
} else {
|
|
from
|
|
};
|
|
let mut to = from + egui::vec2(60.0, 0.0);
|
|
if destination {
|
|
let label = if audio { "A2" } else { "V2" };
|
|
let rows = d.ok("ui.elements", json!({"prefix": format!("timeline.track.{label}.target")}));
|
|
let y = &rows[0]["rect"];
|
|
to.y = (y[1].as_f64().unwrap() + y[3].as_f64().unwrap() * 0.5) as f32;
|
|
}
|
|
let before = d.app().session.project.clone();
|
|
let undo = d.app().session.history.undo.len();
|
|
d.harness.input_mut().events.push(egui::Event::PointerMoved(from));
|
|
d.frames(1);
|
|
d.harness.input_mut().events.push(egui::Event::PointerButton {
|
|
pos: from,
|
|
button: egui::PointerButton::Primary,
|
|
pressed: true,
|
|
modifiers: Default::default(),
|
|
});
|
|
d.frames(1);
|
|
for i in 1..=8 {
|
|
d.harness.input_mut().events.push(egui::Event::PointerMoved(from + (to - from) * (i as f32 / 8.0)));
|
|
d.frames(1);
|
|
}
|
|
d.frames(2);
|
|
let elements = d.ok("ui.elements", json!({"prefix": prefix}));
|
|
assert_eq!(elements[0]["rect"], original, "a prohibited move never previews a displaced clip");
|
|
assert_eq!(d.cursor(), CursorIcon::NotAllowed);
|
|
d.harness.input_mut().events.push(egui::Event::PointerButton {
|
|
pos: to,
|
|
button: egui::PointerButton::Primary,
|
|
pressed: false,
|
|
modifiers: Default::default(),
|
|
});
|
|
d.frames(2);
|
|
assert_eq!(serde_json::to_value(&*d.app().session.project).unwrap(), serde_json::to_value(&*before).unwrap());
|
|
assert_eq!(d.app().session.history.undo.len(), undo);
|
|
}
|
|
|
|
#[test]
|
|
fn locked_sources_do_not_preview_a_move() {
|
|
for audio in [false, true] {
|
|
locked_move_keeps_the_original_preview(audio, false, false, None);
|
|
}
|
|
}
|
|
#[test]
|
|
fn locked_destinations_do_not_preview_a_move() {
|
|
for audio in [false, true] {
|
|
locked_move_keeps_the_original_preview(audio, true, false, None);
|
|
}
|
|
}
|
|
#[test]
|
|
fn a_locked_linked_partner_prevents_the_move_preview() {
|
|
locked_move_keeps_the_original_preview(false, false, true, None);
|
|
}
|
|
|
|
#[test]
|
|
fn locked_edges_do_not_preview_a_trim() {
|
|
for audio in [false, true] {
|
|
for edge in ["in", "out"] {
|
|
locked_move_keeps_the_original_preview(audio, false, false, Some(edge));
|
|
}
|
|
}
|
|
}
|
|
|
|
fn move_existing_clip_to_a_new_track(audio: bool, linked: bool) {
|
|
let mut d = Driver::demo();
|
|
d.exec("sequence.linkedSelection", json!({"on": linked}));
|
|
d.exec("sequence.snap", json!({"on": false}));
|
|
d.ok("ui.set", json!({"timeline":{"videoTrackHeight":32,"audioTrackHeight":32}}));
|
|
d.frames(6);
|
|
let q = d.app().session.active_sequence().unwrap();
|
|
let tracks = if audio { &q.audio_tracks } else { &q.video_tracks };
|
|
let count = tracks.len();
|
|
let clip = tracks[0].items[0].id;
|
|
let original = q.find_item(clip).unwrap().1.clone();
|
|
let other = if audio { &q.video_tracks } else { &q.audio_tracks };
|
|
let other_count = other.len();
|
|
let partner = linked.then(|| {
|
|
assert!(original.link.is_some());
|
|
other.iter().flat_map(|t| &t.items).find(|i| i.link == original.link).unwrap().clone()
|
|
});
|
|
let layout = d.app().tl.layout.as_ref().unwrap();
|
|
let row = layout.rows.iter().find(|r| r.track == tracks[0].id).unwrap();
|
|
let outer = layout.rows.iter().find(|r| r.track == tracks.last().unwrap().id).unwrap();
|
|
let from = egui::pos2(layout.x_of(original.start + filmcraft_time::Tick(original.duration.0 / 2)), row.rect.min.y + 8.0);
|
|
let to = egui::pos2(from.x, if audio { outer.rect.max.y + 8.0 } else { outer.rect.min.y - 8.0 });
|
|
assert!(layout.content.contains(to));
|
|
assert!(layout.row_at(to.y).is_none());
|
|
let before = d.app().session.project.clone();
|
|
let undo = d.app().session.history.undo.len();
|
|
d.harness.input_mut().events.push(egui::Event::PointerMoved(from));
|
|
d.frames(1);
|
|
d.harness.input_mut().events.push(egui::Event::PointerButton {
|
|
pos: from,
|
|
button: egui::PointerButton::Primary,
|
|
pressed: true,
|
|
modifiers: Default::default(),
|
|
});
|
|
d.frames(1);
|
|
for i in 1..=12 {
|
|
d.harness.input_mut().events.push(egui::Event::PointerMoved(from + (to - from) * (i as f32 / 12.0)));
|
|
d.frames(1);
|
|
}
|
|
// A frame updates the gesture, then the next frame paints its destination.
|
|
d.frames(2);
|
|
let preview = d.ok("ui.elements", json!({"prefix":format!("timeline.newTrackPreview.{}",clip.0)}));
|
|
assert_eq!(preview.as_array().unwrap().len(), 1, "new destination is shown during the drag");
|
|
assert_eq!(*d.app().session.project, *before);
|
|
assert_eq!(d.app().session.history.undo.len(), undo);
|
|
d.harness.input_mut().events.push(egui::Event::PointerButton {
|
|
pos: to,
|
|
button: egui::PointerButton::Primary,
|
|
pressed: false,
|
|
modifiers: Default::default(),
|
|
});
|
|
d.frames(2);
|
|
let q = d.app().session.active_sequence().unwrap();
|
|
let tracks = if audio { &q.audio_tracks } else { &q.video_tracks };
|
|
assert_eq!(tracks.len(), count + 1, "drop creates a new outer track");
|
|
assert_eq!(q.find_item(clip).unwrap().0, tracks.last().unwrap().id);
|
|
assert_eq!(q.find_item(clip).unwrap().1, &original);
|
|
let other = if audio { &q.video_tracks } else { &q.audio_tracks };
|
|
assert_eq!(other.len(), other_count + usize::from(linked));
|
|
if let Some(partner) = partner {
|
|
assert_eq!(q.find_item(partner.id).unwrap().0, other.last().unwrap().id);
|
|
assert_eq!(q.find_item(partner.id).unwrap().1, &partner);
|
|
}
|
|
assert_eq!(d.app().session.history.undo.len(), undo + 1);
|
|
let after = d.app().session.project.clone();
|
|
d.exec("edit.undo", json!({}));
|
|
assert_eq!(*d.app().session.project, *before);
|
|
d.exec("edit.redo", json!({}));
|
|
assert_eq!(*d.app().session.project, *after);
|
|
}
|
|
|
|
#[test]
|
|
fn existing_video_clip_drag_above_tracks_adds_a_track() {
|
|
move_existing_clip_to_a_new_track(false, false);
|
|
}
|
|
|
|
#[test]
|
|
fn existing_audio_clip_drag_below_tracks_adds_a_track() {
|
|
move_existing_clip_to_a_new_track(true, false);
|
|
}
|
|
|
|
#[test]
|
|
fn linked_video_drag_adds_video_and_audio_tracks() {
|
|
move_existing_clip_to_a_new_track(false, true);
|
|
}
|
|
|
|
#[test]
|
|
fn linked_audio_drag_adds_audio_and_video_tracks() {
|
|
move_existing_clip_to_a_new_track(true, true);
|
|
}
|