EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
UI: expression value colour tests require every part, hover in every panel and a drag (#1306)
tylerjenningsw764e9c5cde24
diff --git a/crates/ui-egui/tests/ui_expression_values.rs b/crates/ui-egui/tests/ui_expression_values.rsindex 9b226429b..6c07b774e 100644--- a/crates/ui-egui/tests/ui_expression_values.rs+++ b/crates/ui-egui/tests/ui_expression_values.rs@@ -1,8 +1,10 @@//! #1306 (from #1072): a property driven by an expression shows its value in red, the expression//! colour, in the Timeline, Effect Controls and the Properties panel, as in After Effects: scalars,-//! every part of a vector (with its separator) and both parts of an angle, hovered too, in dark and-//! light themes. A disabled, removed or empty expression shows the ordinary colour again. The-//! tests read the colour the value text is painted with.+//! every part of a vector (with its separator) and both parts of an angle (with its sign), hovered+//! and dragged too, in dark and light themes. A disabled, removed or empty expression shows the+//! ordinary colour again. The tests read the colour the value text is painted with (the frame's+//! text shapes: the numbers are painted with an override colour, the separator and sign as plain+//! text), and require every expected part to be there.use effectcraft_engine::Session;use effectcraft_engine::project::{LayerId, PropGroup};@@ -10,19 +12,39 @@ use effectcraft_ui_egui::EffectcraftApp;use effectcraft_ui_egui::dock::PanelKind;use effectcraft_ui_egui::theme::ThemeKind;use egui::epaint::Shape;-use egui::{Color32, Event, Pos2, Rect, pos2, vec2};+use egui::{Color32, Event, Modifiers, PointerButton, Pos2, Rect, pos2, vec2};use egui_kittest::Harness;use serde_json::json;-const PANELS: [&str; 3] = ["timeline.prop", "effectControls.prop", "properties.prop"];+const TIMELINE: &str = "timeline.prop";+const EFFECT_CONTROLS: &str = "effectControls.prop";+const PROPERTIES: &str = "properties.prop";-/// A comp with one solid: (layer, transform Position / Rotation / Opacity / Scale uids, the-/// Transform effect's Position / Rotation / Opacity uids).+#[derive(Clone, Copy, Debug, PartialEq)]+enum Kind {+ /// Two components (X, Y).+ Vector,+ /// Revolutions, sign and degrees.+ Angle,+ Scalar,+}++/// A property whose value the tests check, and the panels that must show it.+#[derive(Clone, Copy, Debug)]+struct Checked {+ uid: u64,+ kind: Kind,+ panels: &'static [&'static str],+}++/// A comp with one solid and the Transform effect on it.struct Ids {layer: u64,- layer_props: [u64; 3],- scale: u64,- effect_props: [u64; 3],+ /// Transform Position, Rotation and Opacity (Timeline and Properties panel), and the Transform+ /// effect's Position, Rotation and Opacity (Effect Controls).+ driven: [Checked; 6],+ /// Transform Scale: no expression.+ scale: Checked,}fn setup() -> (Harness<'static, EffectcraftApp>, Ids) {@@ -34,11 +56,20 @@ fn setup() -> (Harness<'static, EffectcraftApp>, Ids) {let uid = |path: &str| layer.props.prop(path).unwrap_or_else(|| panic!("no {path}")).uid;let g: &PropGroup = layer.props.find_group(fx).unwrap();let fuid = |m: &str| g.get(m).unwrap_or_else(|| panic!("no effect {m}")).uid;+ const LAYER: &[&str] = &[TIMELINE, PROPERTIES];+ const EFFECT: &[&str] = &[EFFECT_CONTROLS];+ let c = |uid, kind, panels| Checked { uid, kind, panels };let ids = Ids {layer: l,- layer_props: [uid("transform/position"), uid("transform/rotation"), uid("transform/opacity")],- scale: uid("transform/scale"),- effect_props: [fuid("position"), fuid("rotation"), fuid("opacity")],+ driven: [+ c(uid("transform/position"), Kind::Vector, LAYER),+ c(uid("transform/rotation"), Kind::Angle, LAYER),+ c(uid("transform/opacity"), Kind::Scalar, LAYER),+ c(fuid("position"), Kind::Vector, EFFECT),+ c(fuid("rotation"), Kind::Angle, EFFECT),+ c(fuid("opacity"), Kind::Scalar, EFFECT),+ ],+ scale: c(uid("transform/scale"), Kind::Vector, LAYER),};let transform = layer.props.sub("transform").unwrap().uid;s.state.selected_layers = vec![LayerId(l)];@@ -51,37 +82,42 @@ fn setup() -> (Harness<'static, EffectcraftApp>, Ids) {(h, ids)}-fn set_expression(h: &mut Harness<'_, EffectcraftApp>, ids: &Ids, prop: u64, p: serde_json::Value) {- let mut p = p;+fn set_expression(h: &mut Harness<'_, EffectcraftApp>, ids: &Ids, prop: u64, p: &serde_json::Value) {+ let mut p = p.clone();p["layer"] = json!(ids.layer);p["prop"] = json!(prop);h.state_mut().session.execute("prop.setExpression", p).unwrap();+}++fn set_theme(h: &mut Harness<'_, EffectcraftApp>, theme: ThemeKind) {+ let ctx = h.ctx.clone();+ h.state_mut().set_theme(&ctx, theme);h.run_steps(3);}-/// The value's area in `panel`: its value, revolutions and vector components together (so a-/// vector's separator and an angle's sign are inside).-fn value_rect(h: &Harness<'_, EffectcraftApp>, panel: &str, uid: u64) -> Option<Rect> {- let ids = [- format!("{panel}.{uid}.value"),- format!("{panel}.{uid}.revolutions"),- format!("{panel}.{uid}.value.0"),- format!("{panel}.{uid}.value.1"),- format!("{panel}.{uid}.value.2"),- ];- ids.iter()- .filter_map(|id| h.state().auto.find(id))- .map(|e| Rect::from_min_size(pos2(e.rect[0], e.rect[1]), vec2(e.rect[2], e.rect[3])))- .reduce(|a, b| a.union(b))+fn rect_of(h: &Harness<'_, EffectcraftApp>, id: &str) -> Rect {+ let e = h.state().auto.find(id).unwrap_or_else(|| panic!("no {id}: the part isn't shown"));+ Rect::from_min_size(pos2(e.rect[0], e.rect[1]), vec2(e.rect[2], e.rect[3]))+}++/// The area of `c`'s value in `panel`, every expected part required: both components of a vector,+/// the revolutions and degrees of an angle (the separator and sign lie between them).+fn value_area(h: &Harness<'_, EffectcraftApp>, panel: &str, c: Checked) -> Rect {+ let uid = c.uid;+ match c.kind {+ Kind::Vector => rect_of(h, &format!("{panel}.{uid}.value.0")).union(rect_of(h, &format!("{panel}.{uid}.value.1"))),+ Kind::Angle => rect_of(h, &format!("{panel}.{uid}.revolutions")).union(rect_of(h, &format!("{panel}.{uid}.value"))),+ Kind::Scalar => rect_of(h, &format!("{panel}.{uid}.value")),+ }}-/// The colours of the text painted inside `area` in the last frame.-fn text_colors(h: &Harness<'_, EffectcraftApp>, area: Rect) -> Vec<Color32> {- fn walk(s: &Shape, area: Rect, out: &mut Vec<Color32>) {+/// The text painted inside `area` in the last frame, with its colour.+fn texts(h: &Harness<'_, EffectcraftApp>, area: Rect) -> Vec<(String, Color32)> {+ fn walk(s: &Shape, area: Rect, out: &mut Vec<(String, Color32)>) {match s {Shape::Vec(v) => v.iter().for_each(|s| walk(s, area, out)),Shape::Text(t) if area.expand(1.0).contains_rect(t.visual_bounding_rect()) && !t.galley.text().trim().is_empty() => {- out.push(t.override_text_color.unwrap_or(t.fallback_color));+ out.push((t.galley.text().trim().to_string(), t.override_text_color.unwrap_or(t.fallback_color)));}_ => {}}@@ -93,71 +129,80 @@ fn text_colors(h: &Harness<'_, EffectcraftApp>, area: Rect) -> Vec<Color32> {out}-/// The colours `uid`'s value is painted with in every panel (each panel must show it).-fn value_colors(h: &Harness<'_, EffectcraftApp>, uid: u64) -> Vec<(&'static str, Vec<Color32>)> {- PANELS- .iter()- .filter_map(|panel| {- let area = value_rect(h, panel, uid)?;- Some((*panel, text_colors(h, area)))- })- .collect()-}--fn assert_all(h: &Harness<'_, EffectcraftApp>, uids: &[u64], want: Color32, what: &str) {- for &uid in uids {- let shown = value_colors(h, uid);- assert!(!shown.is_empty(), "{what}: @{uid} is shown in a panel");- for (panel, colors) in shown {- assert!(!colors.is_empty(), "{what}: @{uid} in {panel} paints its value");- assert!(colors.iter().all(|c| *c == want), "{what}: @{uid} in {panel}: {colors:?}, want {want:?}");+/// `c`'s value in `panel` shows every part, all in `want`: two numbers and (in the Timeline) the+/// `,` of a vector, the revolutions, sign and degrees of an angle, the number of a scalar.+fn assert_value(h: &Harness<'_, EffectcraftApp>, panel: &str, c: Checked, want: Color32, what: &str) {+ let shown = texts(h, value_area(h, panel, c));+ let numbers = shown.iter().filter(|(s, _)| s.chars().any(|ch| ch.is_ascii_digit())).count();+ let has = |text: &str| shown.iter().any(|(s, _)| s == text);+ let ctx = format!("{what}: {:?} @{} in {panel}: {shown:?}", c.kind, c.uid);+ match c.kind {+ Kind::Vector => {+ assert!(numbers >= 2, "{ctx}: both components");+ if panel == TIMELINE {+ assert!(has(","), "{ctx}: the separator");+ }+ }+ Kind::Angle => {+ assert!(numbers >= 2, "{ctx}: revolutions and degrees");+ assert!(has("+") || has("-"), "{ctx}: the sign");+ }+ Kind::Scalar => assert!(numbers >= 1, "{ctx}: the number"),+ }+ assert!(shown.iter().all(|(_, col)| *col == want), "{ctx}: want {want:?}");+}++/// Every checked property in every panel it belongs to.+fn assert_all(h: &Harness<'_, EffectcraftApp>, checked: &[Checked], want: Color32, what: &str) {+ for c in checked {+ for panel in c.panels {+ assert_value(h, panel, *c, want, what);}}}-/// Expression-driven values are red in every panel and both themes; other values stay blue.+/// Expression-driven values are red in every panel, in both themes; Scale (none) stays blue.#[test]fn expression_driven_values_are_red_in_every_panel() {let (mut h, ids) = setup();- for p in ids.layer_props.iter().chain(&ids.effect_props) {- set_expression(&mut h, &ids, *p, json!({"expression": "value"}));- }- // Every value is shown somewhere: the layer's in the Timeline and Properties, the effect's in- // Effect Controls.- for p in ids.layer_props {- assert!(value_rect(&h, "timeline.prop", p).is_some() && value_rect(&h, "properties.prop", p).is_some(), "@{p} in the Timeline and Properties");- }- for p in ids.effect_props {- assert!(value_rect(&h, "effectControls.prop", p).is_some(), "@{p} in Effect Controls");+ for c in ids.driven {+ set_expression(&mut h, &ids, c.uid, &json!({"expression": "value"}));}for theme in [ThemeKind::Dark, ThemeKind::Light] {- let ctx = h.ctx.clone();- h.state_mut().set_theme(&ctx, theme);- h.run_steps(3);+ set_theme(&mut h, theme);let t = h.state().tokens;assert_ne!(t.expr_text, t.hot_text);- let all: Vec<u64> = ids.layer_props.iter().chain(&ids.effect_props).copied().collect();- assert_all(&h, &all, t.expr_text, &format!("{theme:?} expression"));+ assert_all(&h, &ids.driven, t.expr_text, &format!("{theme:?} expression"));assert_all(&h, &[ids.scale], t.hot_text, &format!("{theme:?} no expression"));}}-/// Disabled, removed or empty: the ordinary colour; enabled again: red.+/// Disabled, removed or whitespace-only: the ordinary colour; enabled again: red. Every part of+/// every value is checked again after each change, in both themes.#[test]-fn disabled_removed_and_empty_expressions_show_the_ordinary_colour() {+fn expression_state_changes_switch_the_colour() {let (mut h, ids) = setup();- let [position, rotation, opacity] = ids.layer_props;- for p in ids.layer_props {- set_expression(&mut h, &ids, p, json!({"expression": "value"}));+ let states = [+ (json!({"expression": "value"}), true, "enabled"),+ (json!({"enabled": false}), false, "disabled"),+ (json!({"enabled": true}), true, "enabled again"),+ (json!({"expression": ""}), false, "removed"),+ (json!({"expression": "value"}), true, "set again"),+ (json!({"expression": " "}), false, "whitespace only"),+ ];+ for theme in [ThemeKind::Dark, ThemeKind::Light] {+ set_theme(&mut h, theme);+ let t = h.state().tokens;+ for (p, red, what) in &states {+ for c in ids.driven {+ set_expression(&mut h, &ids, c.uid, p);+ }+ h.run_steps(3);+ let want = if *red { t.expr_text } else { t.hot_text };+ assert_all(&h, &ids.driven, want, &format!("{theme:?} {what}"));+ assert_all(&h, &[ids.scale], t.hot_text, &format!("{theme:?} {what}: Scale"));+ }}- let t = h.state().tokens;- assert_all(&h, &ids.layer_props, t.expr_text, "enabled");- set_expression(&mut h, &ids, position, json!({"enabled": false}));- set_expression(&mut h, &ids, rotation, json!({"expression": ""}));- set_expression(&mut h, &ids, opacity, json!({"expression": " "}));- assert_all(&h, &ids.layer_props, t.hot_text, "disabled, removed, empty");- set_expression(&mut h, &ids, position, json!({"enabled": true}));- assert_all(&h, &[position], t.expr_text, "enabled again");}fn hover(h: &mut Harness<'_, EffectcraftApp>, at: Pos2) {@@ -165,23 +210,64 @@ fn hover(h: &mut Harness<'_, EffectcraftApp>, at: Pos2) {h.run_steps(2);}-/// Hovering a value (which turns an ordinary value's colour to the hover accent) keeps an-/// expression-driven one red.+/// Hovering a value (an ordinary one takes the hover accent) keeps an expression-driven one red,+/// in every panel and both themes.#[test]fn a_hovered_expression_value_stays_red() {let (mut h, ids) = setup();- let [_, _, opacity] = ids.layer_props;- set_expression(&mut h, &ids, opacity, json!({"expression": "value"}));+ let opacity = ids.driven.iter().filter(|c| c.kind == Kind::Scalar).copied().collect::<Vec<_>>();+ for c in &opacity {+ set_expression(&mut h, &ids, c.uid, &json!({"expression": "value"}));+ }+ h.run_steps(3);+ for theme in [ThemeKind::Dark, ThemeKind::Light] {+ set_theme(&mut h, theme);+ let t = h.state().tokens;+ for c in &opacity {+ for panel in c.panels {+ let area = value_area(&h, panel, *c);+ hover(&mut h, area.center());+ let at = h.ctx.input(|i| i.pointer.hover_pos());+ assert!(at.is_some_and(|p| area.contains(p)), "{theme:?} {panel}: the pointer is over the value");+ assert_value(&h, panel, *c, t.expr_text, &format!("{theme:?} hovered"));+ }+ }+ // An ordinary value does take the hover accent.+ let area = value_area(&h, TIMELINE, ids.scale);+ let x = rect_of(&h, &format!("{TIMELINE}.{}.value.0", ids.scale.uid)).center();+ hover(&mut h, x);+ let shown = texts(&h, area);+ assert!(shown.iter().any(|(_, c)| *c == t.accent_hover), "{theme:?} an ordinary hovered value: {shown:?}");+ hover(&mut h, pos2(5.0, 5.0));+ }+}++/// Dragging (scrubbing) an expression-driven value keeps it red while the drag is on, in the+/// Timeline and Effect Controls.+#[test]+fn a_dragged_expression_value_stays_red() {+ let (mut h, ids) = setup();+ let opacity = ids.driven.iter().filter(|c| c.kind == Kind::Scalar).copied().collect::<Vec<_>>();+ for c in &opacity {+ set_expression(&mut h, &ids, c.uid, &json!({"expression": "value"}));+ }+ h.run_steps(3);let t = h.state().tokens;- for panel in ["timeline.prop", "properties.prop"] {- let area = value_rect(&h, panel, opacity).expect("the value");- hover(&mut h, area.center());- let colors = text_colors(&h, area);- assert!(!colors.is_empty() && colors.iter().all(|c| *c == t.expr_text), "{panel} hovered: {colors:?}");+ for (c, panel) in [(opacity[0], TIMELINE), (opacity[1], EFFECT_CONTROLS)] {+ let at = value_area(&h, panel, c).center();+ h.input_mut().events.push(Event::PointerMoved(at));+ h.step();+ h.input_mut().events.push(Event::PointerButton { pos: at, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE });+ h.step();+ for k in 1..=4 {+ h.input_mut().events.push(Event::PointerMoved(at + vec2(3.0 * k as f32, 0.0)));+ h.step();+ }+ assert!(h.ctx.dragged_id().is_some(), "{panel}: a drag is on");+ assert_value(&h, panel, c, t.expr_text, &format!("{panel} dragged"));+ let end = at + vec2(12.0, 0.0);+ h.input_mut().events.push(Event::PointerButton { pos: end, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE });+ h.run_steps(3);+ hover(&mut h, pos2(5.0, 5.0));}- // An ordinary value does take the hover accent there.- let area = value_rect(&h, "timeline.prop", ids.scale).expect("Scale");- hover(&mut h, area.left_center() + vec2(6.0, 0.0));- let colors = text_colors(&h, area);- assert!(colors.contains(&t.accent_hover), "an ordinary hovered value: {colors:?}");}