Skip to content

EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust

Timeline: focus newly added expressions after Alt-click (refs #1072)

tylerjenningswc979f585ac4c
diff --git a/crates/ui-egui/src/panels/timeline.rs b/crates/ui-egui/src/panels/timeline.rs
index 163e6507d..72c071107 100644
--- a/crates/ui-egui/src/panels/timeline.rs
+++ b/crates/ui-egui/src/panels/timeline.rs
@@ -265,10 +265,25 @@ fn whip_into_id(prop: u64) -> egui::Id {
egui::Id::new(("tl-pickwhip-into", prop))
}
-/// After a pick whip into the expression being edited: its editor takes the focus back, the
-/// cursor this many characters before the end (just after the reference).
-fn expr_refocus_id(prop: u64) -> egui::Id {
- egui::Id::new(("tl-expr-refocus", prop))
+/// An expression editor to take the keyboard when it is next drawn: its property, the text to
+/// select as counts of characters before the end (so it fits the expression as it will be then)
+/// and the pass it was asked for in. After a pick whip into the expression being edited, the
+/// cursor goes just after the reference; after an Alt-click on a stopwatch adds an expression,
+/// its whole text is selected, so typing replaces it.
+#[derive(Clone, Copy, Debug)]
+struct ExprFocus {
+ prop: u64,
+ select: [usize; 2],
+ pass: u64,
+}
+
+fn expr_focus_id() -> egui::Id {
+ egui::Id::new("tl-expr-focus")
+}
+
+fn focus_expression(ctx: &egui::Context, prop: u64, select: [usize; 2]) {
+ let pass = ctx.cumulative_pass_nr();
+ ctx.data_mut(|d| d.insert_temp(expr_focus_id(), ExprFocus { prop, select, pass }));
}
#[derive(Clone, Debug)]
@@ -1888,6 +1903,19 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
let rh = t.row_h;
let total_h: f32 = rows.iter().map(|r| row_height(r, rh)).sum();
let max_scroll = (total_h - rows_rect.height() + rh).max(0.0);
+ // An expression editor asked to take the keyboard comes into view; a request whose
+ // expression didn't appear, or that wasn't taken within a few passes, is dropped (it never
+ // takes the keyboard later).
+ if let Some(f) = ctx.data(|d| d.get_temp::<ExprFocus>(expr_focus_id())) {
+ match rows.iter().position(|r| matches!(r.kind, RowKind::Expr { uid, .. } if uid == f.prop)) {
+ Some(i) if ctx.cumulative_pass_nr() <= f.pass.saturating_add(8) => {
+ let top: f32 = rows.iter().take(i).map(|r| row_height(r, rh)).sum();
+ let fits = (top + rows.get(i).map_or(rh, |r| row_height(r, rh)) - rows_rect.height()).max(0.0).min(top);
+ app.ui.timeline.scroll_y = app.ui.timeline.scroll_y.min(top).max(fits);
+ }
+ _ => ctx.data_mut(|d| d.remove::<ExprFocus>(expr_focus_id())),
+ }
+ }
if scroll_to == Some(crate::state::ScrollTo::Layer) {
// The topmost selected layer, in stack order.
let sel = &app.session.state.selected_layers;
@@ -2630,12 +2658,15 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
gp.rect_filled(Rect::from_min_max(pos2(graph_x0, r.min.y), r.max), 0.0, t.expr_bg);
let er = Rect::from_min_max(pos2(graph_x0 + 8.0, r.min.y + 3.0), pos2(rect.max.x - 14.0, r.max.y - 3.0));
let mut buf: String = ctx.data(|d| d.get_temp(buf_id)).unwrap_or_else(|| ex.text.clone());
- if let Some(after) = ctx.data_mut(|d| d.remove_temp::<usize>(expr_refocus_id(*uid))) {
- // A pick whip just put a reference in: editing goes on in the new text,
- // the cursor after the reference.
+ if let Some(f) = ctx.data(|d| d.get_temp::<ExprFocus>(expr_focus_id())).filter(|f| f.prop == *uid) {
+ // Asked for once (a pick whip put a reference in, or an Alt-click added the
+ // expression): editing starts in the expression as it is now.
+ ctx.data_mut(|d| d.remove::<ExprFocus>(expr_focus_id()));
buf = ex.text.clone();
+ let n = buf.chars().count();
+ let [a, b] = f.select.map(|before_end| egui::text::CCursor::new(n.saturating_sub(before_end)));
let mut st = egui::text_edit::TextEditState::load(&ctx, edit_id).unwrap_or_default();
- st.cursor.set_char_range(Some(egui::text::CCursorRange::one(egui::text::CCursor::new(buf.chars().count().saturating_sub(after)))));
+ st.cursor.set_char_range(Some(egui::text::CCursorRange::two(a, b)));
st.store(&ctx, edit_id);
ctx.memory_mut(|m| m.request_focus(edit_id));
}
@@ -2733,6 +2764,15 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
if ui.input(|i| i.modifiers.alt) {
if resp.clicked() {
actions.push(("prop.setExpression".into(), json!({"layer": layer.id.0, "prop": uid})));
+ if prop.expr.is_none() {
+ // Adding one: its editor opens, comes into view and takes the
+ // keyboard with the new expression selected (#1072).
+ app.ui.timeline.expr_closed.remove(uid);
+ focus_expression(&ctx, *uid, [usize::MAX, 0]);
+ } else if ctx.data(|d| d.get_temp::<ExprFocus>(expr_focus_id())).is_some_and(|f| f.prop == *uid) {
+ // Removing it: nothing is left to take the keyboard.
+ ctx.data_mut(|d| d.remove::<ExprFocus>(expr_focus_id()));
+ }
}
} else if let Some((value, merge)) = switch_gesture(ui, &resp, r, "stopwatch", prop.is_animated()) {
actions.push(("prop.toggleAnimation".into(), json!({"layer": layer.id.0, "prop": uid, "value": value, "merge": merge})));
@@ -3057,7 +3097,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
params["expression"] = json!(text);
params["range"] = json!([a, b]);
let after = text.chars().count().saturating_sub(b);
- ctx.data_mut(|d| d.insert_temp(expr_refocus_id(src_prop), after));
+ focus_expression(&ctx, src_prop, [after, after]);
}
actions.push(("prop.pickWhip".into(), params));
}
diff --git a/crates/ui-egui/tests/ui_inline_edit.rs b/crates/ui-egui/tests/ui_inline_edit.rs
index dd20e55b0..7bc5505ed 100644
--- a/crates/ui-egui/tests/ui_inline_edit.rs
+++ b/crates/ui-egui/tests/ui_inline_edit.rs
@@ -539,3 +539,95 @@ fn arrow_keys_move_the_caret_in_rename_fields() {
let layer_name = h.state().session.active_comp().unwrap().layer(effectcraft_engine::project::LayerId(layer)).unwrap().name.clone();
assert_eq!(layer_name, "Pla-te");
}
+
+/// A solid named `name` with its Transform group open in the Timeline; returns the layer, its
+/// Opacity uid and its Rotation uid.
+fn open_transform(h: &mut Harness<'_, EffectcraftApp>, name: &str) -> (u64, u64, u64) {
+ let (layer, opacity, rotation, transform) = {
+ let s = &mut h.state_mut().session;
+ let l = s.execute("layer.newSolid", json!({"name": name, "color": "#406080"})).unwrap()["layer"].as_u64().unwrap();
+ let tr = s.active_comp().unwrap().layer(effectcraft_engine::project::LayerId(l)).unwrap().props.sub("transform").unwrap().clone();
+ (l, tr.get("opacity").unwrap().uid, tr.get("rotation").unwrap().uid, tr.uid)
+ };
+ h.state_mut().ui.timeline.open_layers.insert(layer);
+ h.state_mut().ui.timeline.open_groups.insert(transform);
+ h.run_steps(3);
+ (layer, opacity, rotation)
+}
+
+fn expression(h: &Harness<'_, EffectcraftApp>, layer: u64, prop: u64) -> Option<String> {
+ let comp = h.state().session.active_comp().unwrap();
+ comp.layer(effectcraft_engine::project::LayerId(layer)).unwrap().props.find(prop).unwrap().expr.as_ref().map(|e| e.text.clone())
+}
+
+fn commit_expression(h: &mut Harness<'_, EffectcraftApp>) {
+ h.input_mut().events.push(Event::ModifiersChanged(Modifiers::COMMAND));
+ h.input_mut().events.push(Event::Key { key: Key::Enter, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::COMMAND });
+ h.step();
+ h.input_mut().events.push(Event::ModifiersChanged(Modifiers::NONE));
+ h.run_steps(3);
+}
+
+/// #1072: Alt-clicking a stopwatch adds an expression and its editor takes the keyboard at once,
+/// the new expression selected, so typing replaces it (it took another click). That happens
+/// once: a field clicked next keeps the keyboard, and removing the expression with another
+/// Alt-click leaves nothing to take it.
+#[test]
+fn alt_clicking_a_stopwatch_focuses_the_new_expression() {
+ let (mut h, _) = harness();
+ let (layer, opacity, rotation) = open_transform(&mut h, "Plate");
+ let alt = Modifiers { alt: true, ..Modifiers::NONE };
+ let stopwatch = |h: &Harness<'_, EffectcraftApp>, prop: u64| center(h, &format!("timeline.prop.{prop}.stopwatch"));
+ let at = stopwatch(&h, opacity);
+ click_with(&mut h, at, alt);
+ assert!(expression(&h, layer, opacity).is_some(), "an expression was added");
+ type_text(&mut h, "50");
+ commit_expression(&mut h);
+ assert_eq!(expression(&h, layer, opacity).as_deref(), Some("50"), "typing replaced the new expression");
+ // A field clicked right after an Alt-click keeps the keyboard.
+ let at = stopwatch(&h, rotation);
+ click_with(&mut h, at, alt);
+ let added = expression(&h, layer, rotation).expect("an expression on Rotation");
+ let p = center(&h, "timeline.timecode");
+ click(&mut h, p, 2);
+ type_text(&mut h, "0:00:01:00");
+ key(&mut h, Key::Enter);
+ let frame = h.state().session.active_comp().unwrap().frame_rate.frame_at(h.state().session.time());
+ assert_eq!((frame, expression(&h, layer, rotation)), (24, Some(added)), "the time took the typing, not the expression");
+ // Alt-click again removes the expression; nothing takes the keyboard after it.
+ let at = stopwatch(&h, opacity);
+ click_with(&mut h, at, alt);
+ h.run_steps(5);
+ assert_eq!(expression(&h, layer, opacity), None);
+ assert!(!h.ctx.egui_wants_keyboard_input(), "nothing has the keyboard");
+}
+
+/// #1072: an expression added at the bottom of the Timeline brings its editor into view to take
+/// the keyboard (its row is added below the last one shown).
+#[test]
+fn an_expression_added_at_the_bottom_of_the_timeline_comes_into_view() {
+ let (mut h, _) = harness();
+ let (layer, opacity, _) = open_transform(&mut h, "Bottom");
+ for i in 0..40 {
+ h.state_mut().session.execute("layer.newSolid", json!({"name": format!("Layer {i}"), "color": "#406080"})).unwrap();
+ }
+ h.run_steps(3);
+ // Scroll to the end (the layer is at the bottom of the stack), then until Opacity is the
+ // last row shown.
+ h.state_mut().ui.timeline.scroll_y = 1.0e6;
+ h.run_steps(3);
+ let rows = h.state().auto.find("timeline.scroll").unwrap().rect;
+ let bottom = rows[1] + rows[3];
+ let row = h.state().auto.find(&format!("timeline.prop.{opacity}.row")).unwrap().rect;
+ h.state_mut().ui.timeline.scroll_y += row[1] + row[3] - bottom;
+ h.run_steps(3);
+ let row = h.state().auto.find(&format!("timeline.prop.{opacity}.row")).unwrap().rect;
+ assert!((row[1] + row[3] - bottom).abs() < 1.0, "Opacity is at the bottom: {row:?}");
+ let at = center(&h, &format!("timeline.prop.{opacity}.stopwatch"));
+ click_with(&mut h, at, Modifiers { alt: true, ..Modifiers::NONE });
+ let editor = h.state().auto.find(&format!("timeline.prop.{opacity}.expression")).expect("the editor is drawn").rect;
+ assert!(editor[1] >= rows[1] - 0.5 && editor[1] + editor[3] <= bottom + 0.5, "the editor is in view: {editor:?} in {rows:?}");
+ type_text(&mut h, "25");
+ commit_expression(&mut h);
+ assert_eq!(expression(&h, layer, opacity).as_deref(), Some("25"));
+}