From 550aeb0ac9f6d36416109d6b3ccc330b3a8b7028 Mon Sep 17 00:00:00 2001 From: arnav-hiwarkar Date: Thu, 12 Nov 2026 19:00:04 +0530 Subject: [PATCH] #2047: tests for Adaptive Resolution during Timeline and Properties drags Drag/release tests for the playhead, timecode, layer bar, In trim, source slip, key drag, the In/Out/Duration cells and a Properties scrub: a draft while held, Full on the first frame after release. A click, a work-area drag (same pixels) and Fast Previews off keep Full. --- .../tests/it/ui_timeline_interacting.rs | 224 ++++++++++++------ 1 file changed, 145 insertions(+), 79 deletions(-) diff --git a/crates/ui-egui/tests/it/ui_timeline_interacting.rs b/crates/ui-egui/tests/it/ui_timeline_interacting.rs index 29f86b6ff..6ed4c719a 100644 --- a/crates/ui-egui/tests/it/ui_timeline_interacting.rs +++ b/crates/ui-egui/tests/it/ui_timeline_interacting.rs @@ -1,115 +1,181 @@ +//! Fast Previews ▸ Adaptive Resolution while dragging outside the viewer (After Effects): any +//! Timeline drag that changes the frame on screen (the time, or the comp's pixels) draws a draft +//! until release, and the first frame after the release is full resolution again. A plain click, +//! or a drag that changes nothing on screen, keeps Full. use effectcraft_engine::Session; -use effectcraft_engine::project::LayerId; use effectcraft_ui_egui::EffectcraftApp; use egui::{Event, Pos2, pos2, vec2}; use egui_kittest::Harness; use serde_json::json; -fn harness() -> (Harness<'static, EffectcraftApp>, LayerId, u64) { - let mut session = Session::default(); - session.execute("comp.new", json!({"name": "Keys", "width": 320, "height": 180, "frameRate": 30, "duration": 4})).unwrap(); - session.execute("layer.newSolid", json!({"name": "Box", "color": "#e04020", "width": 80, "height": 80})).unwrap(); - let id = session.active_comp().unwrap().layers[0].id; +/// The Timeline of a 10 s comp at 30 fps with a solid (opacity keys at 0 s and 1 s, revealed) +/// and a 20 s precomp trimmed to 3–7 s (its source runs past both ends, so it can slip), in +/// Adaptive Resolution. +struct Fixture { + h: Harness<'static, EffectcraftApp>, + solid: u64, + pre: u64, + opacity: u64, +} + +fn fixture(mode: &str) -> Fixture { + let mut s = Session::default(); + s.execute("comp.new", json!({"name": "Inner", "width": 320, "height": 180, "frameRate": 30, "duration": 20})).unwrap(); + s.execute("comp.new", json!({"name": "Main", "width": 320, "height": 180, "frameRate": 30, "duration": 10})).unwrap(); + let solid = s.execute("layer.newSolid", json!({"name": "Box", "color": "#e04020", "width": 80, "height": 80})).unwrap()["layer"].as_u64().unwrap(); for (time, value) in [(0.0, 0.0), (1.0, 100.0)] { - session.execute("prop.addKey", json!({"layer": id.0, "path": "transform/opacity", "time": time, "value": value})).unwrap(); + s.execute("prop.addKey", json!({"layer": solid, "path": "transform/opacity", "time": time, "value": value})).unwrap(); } - let uid = session.active_comp().unwrap().layer(id).unwrap().props.prop("transform/opacity").unwrap().uid; - session.execute("layer.select", json!({"layers": [id.0]})).unwrap(); - session.execute("view.fastPreviewMode", json!({"mode": "adaptive"})).unwrap(); - let mut harness = Harness::builder().with_size(vec2(1600.0, 1000.0)).build_eframe(|_| EffectcraftApp::new(session)); - harness.run_steps(3); - let context = harness.ctx.clone(); - effectcraft_ui_egui::menus::invoke(harness.state_mut(), &context, "timeline.reveal.opacity", json!({})).unwrap(); - harness.run_steps(4); - (harness, id, uid) + let pre = s.execute("layer.addItem", json!({"item": "Inner"})).unwrap()["layer"].as_u64().unwrap(); + s.execute("layer.timing", json!({"layers": [pre], "in": 3.0, "out": 7.0})).unwrap(); + let comp = s.active_comp().unwrap(); + let opacity = comp.layers.iter().find(|l| l.id.0 == solid).unwrap().props.prop("transform/opacity").unwrap().uid; + s.execute("layer.select", json!({"layers": [solid]})).unwrap(); + s.execute("view.fastPreviewMode", json!({"mode": mode})).unwrap(); + let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).build_eframe(|_| EffectcraftApp::new(s)); + h.run_steps(3); + let ctx = h.ctx.clone(); + effectcraft_ui_egui::menus::invoke(h.state_mut(), &ctx, "timeline.reveal.opacity", json!({})).unwrap(); + h.run_steps(4); + Fixture { h, solid, pre, opacity } } -fn rect(harness: &Harness<'_, EffectcraftApp>, id: &str) -> egui::Rect { - let entry = harness.state().auto.find(id).expect("timeline element"); - egui::Rect::from_min_size(pos2(entry.rect[0], entry.rect[1]), vec2(entry.rect[2], entry.rect[3])) +fn rect(h: &Harness<'_, EffectcraftApp>, id: &str) -> egui::Rect { + let e = h.state().auto.find(id).unwrap_or_else(|| panic!("no {id}")); + egui::Rect::from_min_size(pos2(e.rect[0], e.rect[1]), vec2(e.rect[2], e.rect[3])) } -fn keys(harness: &Harness<'_, EffectcraftApp>, uid: u64) -> Vec { - let mut positions: Vec = harness - .state() - .auto - .query(&format!("timeline.key.{uid}.")) - .iter() - .map(|entry| pos2(entry.rect[0] + entry.rect[2] / 2.0, entry.rect[1] + entry.rect[3] / 2.0)) - .collect(); - positions.sort_by(|left, right| left.x.total_cmp(&right.x)); - positions +/// What a frame-changing drag must change: the project or the current time. +fn on_screen(h: &Harness<'_, EffectcraftApp>) -> (u64, effectcraft_time::Tick) { + (h.state().session.revision, h.state().session.time()) } -fn hold(harness: &mut Harness<'_, EffectcraftApp>, from: Pos2, to: Pos2) { - harness.input_mut().events.push(Event::PointerMoved(from)); - harness.step(); - harness.input_mut().events.push(Event::PointerButton { pos: from, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() }); - harness.step(); +/// Presses at `from` and moves to `to` in ten steps, leaving the button down. +fn hold(h: &mut Harness<'_, EffectcraftApp>, from: Pos2, to: Pos2) { + h.input_mut().events.push(Event::PointerMoved(from)); + h.step(); + h.input_mut().events.push(Event::PointerButton { pos: from, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() }); + h.step(); for step in 1..=10 { - harness.input_mut().events.push(Event::PointerMoved(from + (to - from) * (step as f32 / 10.0))); - harness.step(); + h.input_mut().events.push(Event::PointerMoved(from + (to - from) * (step as f32 / 10.0))); + h.step(); } } -fn release(harness: &mut Harness<'_, EffectcraftApp>, at: Pos2) { - harness.input_mut().events.push(Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: false, modifiers: Default::default() }); - harness.run_steps(2); +/// Releases at `at` and runs exactly one frame: that frame must already be sharp. +fn release(h: &mut Harness<'_, EffectcraftApp>, at: Pos2) { + h.input_mut().events.push(Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: false, modifiers: Default::default() }); + h.step(); } -fn assert_adaptive_during_drag(harness: &Harness<'_, EffectcraftApp>) { - assert!(harness.state().ui.viewer.property_interacting); - assert!(harness.state().viewer_scale(1.0, 1.0) < 1.0); +fn draft(h: &Harness<'_, EffectcraftApp>) -> bool { + h.state().viewer_scale(1.0, 1.0) < 1.0 } -fn assert_full_resolution_after_release(harness: &Harness<'_, EffectcraftApp>) { - assert!(!harness.state().ui.viewer.property_interacting); - assert_eq!(harness.state().viewer_scale(1.0, 1.0), 1.0); +/// Drags from `from` by `by`: a draft while held, Full on the first frame after release. +fn assert_draft_while_dragging(f: &mut Fixture, from: Pos2, by: egui::Vec2) { + let before = on_screen(&f.h); + hold(&mut f.h, from, from + by); + assert_ne!(on_screen(&f.h), before, "the drag changed nothing on screen"); + assert!(f.h.state().ui.viewer.property_interacting, "not interacting while dragging"); + assert!(draft(&f.h), "full resolution while dragging"); + release(&mut f.h, from + by); + assert!(!f.h.state().ui.viewer.property_interacting, "still interacting after release"); + assert!(!draft(&f.h), "the first frame after release is a draft"); } #[test] -fn playhead_drag_uses_adaptive_resolution() { - let (mut harness, _, _) = harness(); - let ruler = rect(&harness, "timeline.ruler"); - let from = pos2(ruler.min.x + 40.0, ruler.max.y - 3.0); - let to = from + vec2(200.0, 0.0); - hold(&mut harness, from, to); - assert_adaptive_during_drag(&harness); - release(&mut harness, to); - assert_full_resolution_after_release(&harness); +fn playhead_drag_draws_a_draft() { + let mut f = fixture("adaptive"); + let ruler = rect(&f.h, "timeline.ruler"); + assert_draft_while_dragging(&mut f, pos2(ruler.min.x + 40.0, ruler.max.y - 3.0), vec2(200.0, 0.0)); } #[test] -fn layer_bar_drag_uses_adaptive_resolution() { - let (mut harness, layer, _) = harness(); - let from = rect(&harness, &format!("timeline.layer.{}.bar", layer.0)).center(); - let to = from + vec2(60.0, 0.0); - hold(&mut harness, from, to); - assert_adaptive_during_drag(&harness); - release(&mut harness, to); - assert_full_resolution_after_release(&harness); +fn timecode_drag_draws_a_draft() { + let mut f = fixture("adaptive"); + let from = rect(&f.h, "timeline.timecode").center(); + assert_draft_while_dragging(&mut f, from, vec2(60.0, 0.0)); } #[test] -fn key_drag_uses_adaptive_resolution() { - let (mut harness, _, uid) = harness(); - let from = keys(&harness, uid)[0]; - let to = from + vec2(60.0, 0.0); - hold(&mut harness, from, to); - assert_adaptive_during_drag(&harness); - release(&mut harness, to); - assert_full_resolution_after_release(&harness); +fn layer_bar_drag_draws_a_draft() { + let mut f = fixture("adaptive"); + let from = rect(&f.h, &format!("timeline.layer.{}.bar", f.solid)).center(); + assert_draft_while_dragging(&mut f, from, vec2(60.0, 0.0)); +} + +#[test] +fn in_point_trim_draws_a_draft() { + let mut f = fixture("adaptive"); + let from = rect(&f.h, &format!("timeline.layer.{}.bar.in", f.pre)).center(); + assert_draft_while_dragging(&mut f, from, vec2(60.0, 0.0)); +} + +#[test] +fn source_slip_draws_a_draft() { + let mut f = fixture("adaptive"); + let from = rect(&f.h, &format!("timeline.layer.{}.sourcel", f.pre)).center(); + assert_draft_while_dragging(&mut f, from, vec2(60.0, 0.0)); +} + +#[test] +fn key_drag_draws_a_draft() { + let mut f = fixture("adaptive"); + let from = rect(&f.h, &format!("timeline.key.{}.0", f.opacity)).center(); + assert_draft_while_dragging(&mut f, from, vec2(60.0, 0.0)); +} + +#[test] +fn in_out_and_duration_cell_drags_draw_a_draft() { + for kind in ["in", "out", "duration"] { + let mut f = fixture("adaptive"); + effectcraft_ui_egui::panels::timeline::set_column(&mut f.h.state_mut().ui.timeline, kind, true).unwrap(); + f.h.run_steps(3); + let from = rect(&f.h, &format!("timeline.layer.{}.{kind}", f.pre)).center(); + assert_draft_while_dragging(&mut f, from, vec2(60.0, 0.0)); + } +} + +#[test] +fn properties_scrub_draws_a_draft() { + let mut f = fixture("adaptive"); + let ctx = f.h.ctx.clone(); + effectcraft_ui_egui::menus::invoke(f.h.state_mut(), &ctx, "window.panel", json!({"panel": "properties"})).unwrap(); + f.h.run_steps(3); + let from = rect(&f.h, &format!("properties.prop.{}.value", f.opacity)).center(); + assert_draft_while_dragging(&mut f, from, vec2(40.0, 0.0)); +} + +#[test] +fn work_area_drag_keeps_full_resolution() { + let mut f = fixture("adaptive"); + let from = rect(&f.h, "timeline.workArea.end").center(); + let before = f.h.state().session.active_comp().unwrap().work_area; + hold(&mut f.h, from, from + vec2(-80.0, 0.0)); + assert_ne!(f.h.state().session.active_comp().unwrap().work_area, before, "the work area moved"); + assert!(!draft(&f.h), "a work-area drag changes no pixels"); + release(&mut f.h, from); } #[test] fn timeline_click_keeps_full_resolution() { - let (mut harness, _, _) = harness(); - let point = rect(&harness, "timeline.ruler").center(); - harness.input_mut().events.push(Event::PointerMoved(point)); - harness.step(); - harness.input_mut().events.push(Event::PointerButton { pos: point, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() }); - harness.step(); - assert!(!harness.state().ui.viewer.property_interacting); - assert_eq!(harness.state().viewer_scale(1.0, 1.0), 1.0); - release(&mut harness, point); + let mut f = fixture("adaptive"); + let point = rect(&f.h, "timeline.ruler").center(); + f.h.input_mut().events.push(Event::PointerMoved(point)); + f.h.step(); + f.h.input_mut().events.push(Event::PointerButton { pos: point, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() }); + f.h.run_steps(3); + assert!(!draft(&f.h)); + release(&mut f.h, point); +} + +#[test] +fn fast_previews_off_keeps_full_resolution() { + let mut f = fixture("off"); + let ruler = rect(&f.h, "timeline.ruler"); + let from = pos2(ruler.min.x + 40.0, ruler.max.y - 3.0); + hold(&mut f.h, from, from + vec2(200.0, 0.0)); + assert!(!draft(&f.h)); + release(&mut f.h, from); }