Skip to content

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

Fix timeline drop targets and deleted drag layers (#2492)

WillPastor559958ea62ef
diff --git a/crates/ui-egui/src/panels/timeline.rs b/crates/ui-egui/src/panels/timeline.rs
index b9c2f580a..7dff42172 100644
--- a/crates/ui-egui/src/panels/timeline.rs
+++ b/crates/ui-egui/src/panels/timeline.rs
@@ -1509,6 +1509,20 @@ fn insertion(layer_rows: &[(Rect, LayerId)], py: f32, top: f32) -> (Option<usize
(at, y)
}
+/// Resolve a visible insertion boundary through the full outline, including offscreen layers.
+fn layer_drop_target(rows: &[Row], visible: &[(Rect, LayerId)], at: Option<usize>, moving: &[u64]) -> Option<LayerId> {
+ let (anchor, after) = match at {
+ Some(i) => (visible.get(i)?.1, false),
+ None => (visible.last()?.1, true),
+ };
+ rows.iter()
+ .filter(|row| matches!(row.kind, RowKind::Layer))
+ .skip_while(|row| row.layer != anchor)
+ .skip(usize::from(after))
+ .find(|row| !moving.contains(&row.layer.0))
+ .map(|row| row.layer)
+}
+
/// Whether a Project item can replace a layer's source (the same set `layer.replaceSource`
/// accepts): compositions, footage and solids; not folders, data files or 3D models.
fn replaceable_item(it: &effectcraft_engine::project::Item) -> bool {
@@ -4365,7 +4379,11 @@ fn layer_reorder_drag(ui: &mut egui::Ui, g: &mut Rw) {
let (down, released, escape) =
ctx.input(|i| (i.pointer.primary_down(), i.pointer.button_released(egui::PointerButton::Primary), i.key_pressed(egui::Key::Escape)));
let dropped = ctx.drag_stopped_id() == Some(drag.owner) && released;
- let valid = ui.is_enabled() && drag.comp == cid && !escape && (dropped || (down && ctx.dragged_id() == Some(drag.owner)));
+ let valid = ui.is_enabled()
+ && drag.comp == cid
+ && drag.layers.iter().all(|id| comp.layer(LayerId(*id)).is_some())
+ && !escape
+ && (dropped || (down && ctx.dragged_id() == Some(drag.owner)));
if dropped || !valid {
ctx.data_mut(|d| d.remove::<LayerDrag>(layer_drag_id()));
}
@@ -4376,7 +4394,7 @@ fn layer_reorder_drag(ui: &mut egui::Ui, g: &mut Rw) {
&& !layer_rows.is_empty()
{
let (at, line_y) = insertion(&layer_rows, py, rows_rect.min.y);
- let target = at.and_then(|i| layer_rows[i..].iter().find(|(_, l)| !moving.contains(&l.0)).map(|(_, l)| *l));
+ let target = layer_drop_target(&g.tl.rows, &layer_rows, at, moving);
if dropped {
// Only when the order changes (no empty undo step for a drop in place).
let mut order: Vec<u64> = comp.layers.iter().map(|l| l.id.0).filter(|id| !moving.contains(id)).collect();
diff --git a/crates/ui-egui/src/panels/timeline/tests.rs b/crates/ui-egui/src/panels/timeline/tests.rs
index 0355ea5ed..d05787a18 100644
--- a/crates/ui-egui/src/panels/timeline/tests.rs
+++ b/crates/ui-egui/src/panels/timeline/tests.rs
@@ -535,3 +535,13 @@ fn disk_bar_range_covers_partial_frames() {
let above_limit = TMap { start: 100_001.0, ..tm };
assert_eq!(disk_bar_range(&above_limit, clip, 1.0, i64::MAX), 100_000..100_000);
}
+#[test]
+fn layer_drop_target_skips_moving_layers_beyond_the_viewport() {
+ let mut rows: Vec<Row> = (1..=6).map(|id| Row { layer: LayerId(id), depth: 0, kind: RowKind::Layer }).collect();
+ rows.insert(4, Row { layer: LayerId(4), depth: 1, kind: RowKind::Prop { uid: 0 } });
+ let visible: Vec<_> = (2..=4).map(|id| (Rect::NOTHING, LayerId(id))).collect();
+ for at in [Some(2), None] {
+ assert_eq!(layer_drop_target(&rows, &visible, at, &[1, 4, 5]), Some(LayerId(6)), "skip moving headers and their properties across the viewport edge");
+ assert_eq!(layer_drop_target(&rows, &visible, at, &[1, 4, 5, 6]), None, "the stack ends when no stationary layer follows");
+ }
+}
diff --git a/crates/ui-egui/tests/it/ui_viewer.rs b/crates/ui-egui/tests/it/ui_viewer.rs
index 9df6e62a0..c9024ac58 100644
--- a/crates/ui-egui/tests/it/ui_viewer.rs
+++ b/crates/ui-egui/tests/it/ui_viewer.rs
@@ -1835,6 +1835,120 @@ fn timeline_rows_drag_to_top_after_scrolling() {
}
}
+/// An intermediate scroll must not turn the viewport's lower edge into the stack's end.
+fn timeline_reorder_at_viewport_edge(below: bool, multiple: bool) {
+ let mut h = harness();
+ for i in 0..38 {
+ h.state_mut().session.execute("layer.newSolid", json!({"name": format!("Layer {i}"), "color": "#406080", "width": 80, "height": 80})).unwrap();
+ }
+ h.state_mut().session.execute("edit.deselectAll", json!({})).unwrap();
+ h.run_steps(3);
+ let before = timeline_layer_order(&h);
+ let moving = before[..if multiple { 2 } else { 1 }].to_vec();
+ h.state_mut().session.execute("layer.select", json!({"layers": moving})).unwrap();
+ h.run_steps(2);
+ h.state_mut().session.history.clear();
+ let from = timeline_layer_row(&h, moving[0]).center();
+ start_timeline_row_drag(&mut h, from);
+ scroll_timeline(&mut h, -200.0);
+ let visible = |h: &Harness<'_, EffectcraftApp>| {
+ before.iter().copied().filter(|id| h.state().auto.find(&format!("timeline.layer.{id}.row")).is_some()).collect::<Vec<_>>()
+ };
+ // Leave space inside the viewport below the last rendered layer's midpoint.
+ for _ in 0..20 {
+ let last = timeline_layer_row(&h, *visible(&h).last().unwrap());
+ if last.center().y < rect(&h, "timeline.layerMarquee").max.y - 3.0 {
+ break;
+ }
+ scroll_timeline(&mut h, -10.0);
+ }
+ let shown = visible(&h);
+ assert!(!shown.contains(&moving[0]), "the drag owner is culled");
+ let last = *shown.last().unwrap();
+ assert_ne!(last, *before.last().unwrap(), "layers remain below the viewport");
+ let row = timeline_layer_row(&h, last);
+ let viewport = rect(&h, "timeline.layerMarquee");
+ let y = if below { (row.center().y + row.height() * 0.4).min(viewport.max.y - 1.0) } else { row.min.y + row.height() * 0.2 };
+ let to = pos2(row.center().x, y);
+ assert!(viewport.contains(to));
+ assert_eq!(to.y > row.center().y, below);
+ let mut expected: Vec<u64> = before.iter().copied().filter(|id| !moving.contains(id)).collect();
+ let at = expected.iter().position(|id| *id == last).unwrap() + usize::from(below);
+ expected.splice(at..at, moving);
+ release_timeline_row_drag(&mut h, to);
+ assert_eq!(timeline_layer_order(&h), expected, "the drop follows the indicated row boundary");
+ assert_eq!(h.state().session.history.undo.len(), 1);
+ assert_ne!(h.output().platform_output.cursor_icon, egui::CursorIcon::Grabbing);
+ h.state_mut().session.execute("edit.undo", json!({})).unwrap();
+ assert_eq!(timeline_layer_order(&h), before);
+ h.state_mut().session.execute("edit.redo", json!({})).unwrap();
+ assert_eq!(timeline_layer_order(&h), expected);
+}
+
+#[test]
+fn timeline_rows_drag_after_last_visible_row() {
+ for multiple in [false, true] {
+ timeline_reorder_at_viewport_edge(true, multiple);
+ }
+}
+
+#[test]
+fn timeline_rows_drag_before_last_visible_row() {
+ for multiple in [false, true] {
+ timeline_reorder_at_viewport_edge(false, multiple);
+ }
+}
+
+/// A removed ID must not be reinterpreted as a one-based index by layer.arrange.
+fn timeline_reorder_after_deletion(delete_owner: bool) {
+ let mut h = harness();
+ for i in 0..6 {
+ h.state_mut().session.execute("layer.newSolid", json!({"name": format!("Layer {i}"), "color": "#406080", "width": 80, "height": 80})).unwrap();
+ }
+ let before = timeline_layer_order(&h);
+ let removed = *before.last().unwrap();
+ assert!(removed > 0 && removed < before.len() as u64, "the missing ID would also resolve as a surviving layer index");
+ let owner = if delete_owner { removed } else { before[0] };
+ let moving = if delete_owner { vec![removed] } else { vec![owner, removed] };
+ h.state_mut().session.execute("layer.select", json!({"layers": moving})).unwrap();
+ h.run_steps(3);
+ h.state_mut().session.history.clear();
+ let from = timeline_layer_row(&h, owner).center();
+ start_timeline_row_drag(&mut h, from);
+ if !delete_owner {
+ // Changing the selection does not change the group captured by the held drag.
+ h.state_mut().session.execute("layer.select", json!({"layers": [removed]})).unwrap();
+ h.run_steps(2);
+ }
+ key(&mut h, egui::Key::Delete, Default::default());
+ assert!(h.ctx.input(|i| i.pointer.primary_down()), "Delete happened during the held drag");
+ let survivors: Vec<u64> = before.iter().copied().filter(|id| *id != removed).collect();
+ assert_eq!(timeline_layer_order(&h), survivors, "Delete removed only the selected layer");
+ let steps = h.state().session.history.undo.len();
+ let row = timeline_layer_row(&h, survivors[0]);
+ release_timeline_row_drag(&mut h, row.center() - vec2(0.0, row.height() * 0.4));
+ assert_eq!(timeline_layer_order(&h), survivors, "a stale drag cannot move any surviving layer");
+ assert_eq!(h.state().session.history.undo.len(), steps, "release adds no undo step");
+ assert_ne!(h.output().platform_output.cursor_icon, egui::CursorIcon::Grabbing);
+ let from = timeline_layer_row(&h, survivors[0]).center();
+ let row = timeline_layer_row(&h, survivors[1]);
+ drag(&mut h, from, row.center() + vec2(0.0, row.height() * 0.4));
+ let mut expected = survivors;
+ expected.swap(0, 1);
+ assert_eq!(timeline_layer_order(&h), expected, "a later independent drag still works");
+ assert_eq!(h.state().session.history.undo.len(), steps + 1);
+}
+
+#[test]
+fn timeline_rows_drag_cancels_when_the_owner_is_deleted() {
+ timeline_reorder_after_deletion(true);
+}
+
+#[test]
+fn timeline_rows_drag_cancels_when_a_group_member_is_deleted() {
+ timeline_reorder_after_deletion(false);
+}
+
#[test]
fn timeline_rows_drag_cancels_without_a_primary_release() {
for escape in [false, true] {