VSE: Add precise drag and drop and strip previews

This patch adds the drag and drop strip previews in the VSE.
It also adds two new functions to the drag and drop API.

1. "draw_in_view" for callbacks that wants to draw elements in local viewport coordinates
2. "on_drag_start" that can be used for prefetching data only once at the start of the drag.

Reviewed By: Julian, Campbell

Differential Revision: http://developer.blender.org/D14560

5 files changed, 154 insertions, 77 deletions

diff --git a/source/blender/editors/transform/transform.h b/source/blender/editors/transform/transform.h
index 68c9a1c23c3..a3df6a44682 100644
--- a/source/blender/editors/transform/transform.h
+++ b/source/blender/editors/transform/transform.h
@@ -11,8 +11,6 @@
 #include "ED_transform.h"
 #include "ED_view3d.h"
 
-#include "RE_engine.h"
-
 #include "DNA_listBase.h"
 #include "DNA_object_enums.h"
 
diff --git a/source/blender/editors/transform/transform_convert.h b/source/blender/editors/transform/transform_convert.h
index 2b338f6ad08..7080deaec66 100644
--- a/source/blender/editors/transform/transform_convert.h
+++ b/source/blender/editors/transform/transform_convert.h
@@ -8,6 +8,8 @@
 
 #pragma once
 
+#include "RE_engine.h"
+
 struct BMEditMesh;
 struct BMesh;
 struct BezTriple;
diff --git a/source/blender/editors/transform/transform_convert_sequencer.c b/source/blender/editors/transform/transform_convert_sequencer.c
index d7d85646b08..c1e8dab3b3e 100644
--- a/source/blender/editors/transform/transform_convert_sequencer.c
+++ b/source/blender/editors/transform/transform_convert_sequencer.c
@@ -326,13 +326,14 @@ static SeqCollection *query_right_side_strips(ListBase *seqbase, SeqCollection *
   return collection;
 }
 
-static void seq_transform_update_effects(TransInfo *t, SeqCollection *collection)
+static void seq_transform_update_effects(Scene *scene,
+                                         ListBase *seqbasep,
+                                         SeqCollection *collection)
 {
   Sequence *seq;
   SEQ_ITERATOR_FOREACH (seq, collection) {
     if ((seq->type & SEQ_TYPE_EFFECT) && (seq->seq1 || seq->seq2 || seq->seq3)) {
-      ListBase *seqbase = SEQ_active_seqbase_get(SEQ_editing_get(t->scene));
-      SEQ_time_update_sequence(t->scene, seqbase, seq);
+      SEQ_time_update_sequence(scene, seqbasep, seq);
     }
   }
 }
@@ -357,12 +358,12 @@ static ListBase *seqbase_active_get(const TransInfo *t)
 
 /* Offset all strips positioned after left edge of transformed strips bound-box by amount equal
  * to overlap of transformed strips. */
-static void seq_transform_handle_expand_to_fit(TransInfo *t, SeqCollection *transformed_strips)
+static void seq_transform_handle_expand_to_fit(Scene *scene,
+                                               ListBase *seqbasep,
+                                               SeqCollection *transformed_strips,
+                                               bool use_sync_markers)
 {
-  ListBase *seqbasep = seqbase_active_get(t);
-  ListBase *markers = &t->scene->markers;
-  const bool use_sync_markers = (((SpaceSeq *)t->area->spacedata.first)->flag &
-                                 SEQ_MARKER_TRANS) != 0;
+  ListBase *markers = &scene->markers;
 
   SeqCollection *right_side_strips = query_right_side_strips(seqbasep, transformed_strips);
 
@@ -376,7 +377,7 @@ static void seq_transform_handle_expand_to_fit(TransInfo *t, SeqCollection *tran
    * strips on left side. */
   SeqCollection *standalone_strips = extract_standalone_strips(transformed_strips);
   SEQ_transform_seqbase_shuffle_time(
-      standalone_strips, seqbasep, t->scene, markers, use_sync_markers);
+      standalone_strips, seqbasep, scene, markers, use_sync_markers);
   SEQ_collection_free(standalone_strips);
 
   /* Move temporarily moved strips back to their original place and tag for shuffling. */
@@ -384,17 +385,17 @@ static void seq_transform_handle_expand_to_fit(TransInfo *t, SeqCollection *tran
     seq->machine -= MAXSEQ * 2;
   }
   /* Shuffle again to displace strips on right side. Final effect shuffling is done in
-   * seq_transform_handle_overlap. */
+   * SEQ_transform_handle_overlap. */
   SEQ_transform_seqbase_shuffle_time(
-      right_side_strips, seqbasep, t->scene, markers, use_sync_markers);
-  seq_transform_update_effects(t, right_side_strips);
+      right_side_strips, seqbasep, scene, markers, use_sync_markers);
+  seq_transform_update_effects(scene, seqbasep, right_side_strips);
   SEQ_collection_free(right_side_strips);
 }
 
-static SeqCollection *query_overwrite_targets(const TransInfo *t,
+static SeqCollection *query_overwrite_targets(ListBase *seqbasep,
                                               SeqCollection *transformed_strips)
 {
-  SeqCollection *collection = SEQ_query_unselected_strips(seqbase_active_get(t));
+  SeqCollection *collection = SEQ_query_unselected_strips(seqbasep);
 
   Sequence *seq, *seq_transformed;
   SEQ_ITERATOR_FOREACH (seq, collection) {
@@ -449,35 +450,36 @@ static eOvelapDescrition overlap_description_get(const Sequence *transformed,
 }
 
 /* Split strip in 3 parts, remove middle part and fit transformed inside. */
-static void seq_transform_handle_overwrite_split(const TransInfo *t,
+static void seq_transform_handle_overwrite_split(Scene *scene,
+                                                 ListBase *seqbasep,
                                                  const Sequence *transformed,
                                                  Sequence *target)
 {
-  Main *bmain = CTX_data_main(t->context);
-  Scene *scene = t->scene;
-  ListBase *seqbase = seqbase_active_get(t);
+  /* Because we are doing a soft split, bmain is not used in SEQ_edit_strip_split, so we can pass
+   * NULL here. */
+  Main *bmain = NULL;
 
   Sequence *split_strip = SEQ_edit_strip_split(
-      bmain, scene, seqbase, target, transformed->startdisp, SEQ_SPLIT_SOFT, NULL);
+      bmain, scene, seqbasep, target, transformed->startdisp, SEQ_SPLIT_SOFT, NULL);
   SEQ_edit_strip_split(
-      bmain, scene, seqbase, split_strip, transformed->enddisp, SEQ_SPLIT_SOFT, NULL);
-  SEQ_edit_flag_for_removal(scene, seqbase_active_get(t), split_strip);
-  SEQ_edit_remove_flagged_sequences(t->scene, seqbase_active_get(t));
+      bmain, scene, seqbasep, split_strip, transformed->enddisp, SEQ_SPLIT_SOFT, NULL);
+  SEQ_edit_flag_for_removal(scene, seqbasep, split_strip);
+  SEQ_edit_remove_flagged_sequences(scene, seqbasep);
 }
 
 /* Trim strips by adjusting handle position.
  * This is bit more complicated in case overlap happens on effect. */
-static void seq_transform_handle_overwrite_trim(const TransInfo *t,
+static void seq_transform_handle_overwrite_trim(Scene *scene,
+                                                ListBase *seqbasep,
                                                 const Sequence *transformed,
                                                 Sequence *target,
                                                 const eOvelapDescrition overlap)
 {
-  SeqCollection *targets = SEQ_query_by_reference(
-      target, seqbase_active_get(t), SEQ_query_strip_effect_chain);
+  SeqCollection *targets = SEQ_query_by_reference(target, seqbasep, SEQ_query_strip_effect_chain);
 
   /* Expand collection by adding all target's children, effects and their children. */
   if ((target->type & SEQ_TYPE_EFFECT) != 0) {
-    SEQ_collection_expand(seqbase_active_get(t), targets, SEQ_query_strip_effect_chain);
+    SEQ_collection_expand(seqbasep, targets, SEQ_query_strip_effect_chain);
   }
 
   /* Trim all non effects, that have influence on effect length which is overlapping. */
@@ -494,15 +496,16 @@ static void seq_transform_handle_overwrite_trim(const TransInfo *t,
       SEQ_transform_set_right_handle_frame(seq, transformed->startdisp);
     }
 
-    ListBase *seqbase = SEQ_active_seqbase_get(SEQ_editing_get(t->scene));
-    SEQ_time_update_sequence(t->scene, seqbase, seq);
+    SEQ_time_update_sequence(scene, seqbasep, seq);
   }
   SEQ_collection_free(targets);
 }
 
-static void seq_transform_handle_overwrite(const TransInfo *t, SeqCollection *transformed_strips)
+static void seq_transform_handle_overwrite(Scene *scene,
+                                           ListBase *seqbasep,
+                                           SeqCollection *transformed_strips)
 {
-  SeqCollection *targets = query_overwrite_targets(t, transformed_strips);
+  SeqCollection *targets = query_overwrite_targets(seqbasep, transformed_strips);
   SeqCollection *strips_to_delete = SEQ_collection_create(__func__);
 
   Sequence *target;
@@ -519,10 +522,10 @@ static void seq_transform_handle_overwrite(const TransInfo *t, SeqCollection *tr
         SEQ_collection_append_strip(target, strips_to_delete);
       }
       else if (overlap == STRIP_OVERLAP_IS_INSIDE) {
-        seq_transform_handle_overwrite_split(t, transformed, target);
+        seq_transform_handle_overwrite_split(scene, seqbasep, transformed, target);
       }
       else if (ELEM(overlap, STRIP_OVERLAP_LEFT_SIDE, STRIP_OVERLAP_RIGHT_SIDE)) {
-        seq_transform_handle_overwrite_trim(t, transformed, target, overlap);
+        seq_transform_handle_overwrite_trim(scene, seqbasep, transformed, target, overlap);
       }
     }
   }
@@ -534,47 +537,49 @@ static void seq_transform_handle_overwrite(const TransInfo *t, SeqCollection *tr
   if (SEQ_collection_len(strips_to_delete) > 0) {
     Sequence *seq;
     SEQ_ITERATOR_FOREACH (seq, strips_to_delete) {
-      SEQ_edit_flag_for_removal(t->scene, seqbase_active_get(t), seq);
+      SEQ_edit_flag_for_removal(scene, seqbasep, seq);
     }
-    SEQ_edit_remove_flagged_sequences(t->scene, seqbase_active_get(t));
+    SEQ_edit_remove_flagged_sequences(scene, seqbasep);
   }
   SEQ_collection_free(strips_to_delete);
 }
 
-static void seq_transform_handle_overlap_shuffle(const TransInfo *t,
-                                                 SeqCollection *transformed_strips)
+static void seq_transform_handle_overlap_shuffle(Scene *scene,
+                                                 ListBase *seqbasep,
+                                                 SeqCollection *transformed_strips,
+                                                 bool use_sync_markers)
 {
-  ListBase *seqbase = seqbase_active_get(t);
-  ListBase *markers = &t->scene->markers;
-  const bool use_sync_markers = (((SpaceSeq *)t->area->spacedata.first)->flag &
-                                 SEQ_MARKER_TRANS) != 0;
+  ListBase *markers = &scene->markers;
+
   /* Shuffle non strips with no effects attached. */
   SeqCollection *standalone_strips = extract_standalone_strips(transformed_strips);
   SEQ_transform_seqbase_shuffle_time(
-      standalone_strips, seqbase, t->scene, markers, use_sync_markers);
+      standalone_strips, seqbasep, scene, markers, use_sync_markers);
   SEQ_collection_free(standalone_strips);
 }
 
-static void seq_transform_handle_overlap(TransInfo *t, SeqCollection *transformed_strips)
+void SEQ_transform_handle_overlap(Scene *scene,
+                                  ListBase *seqbasep,
+                                  SeqCollection *transformed_strips,
+                                  bool use_sync_markers)
 {
-  ListBase *seqbasep = seqbase_active_get(t);
-  const eSeqOverlapMode overlap_mode = SEQ_tool_settings_overlap_mode_get(t->scene);
+  const eSeqOverlapMode overlap_mode = SEQ_tool_settings_overlap_mode_get(scene);
 
   switch (overlap_mode) {
     case SEQ_OVERLAP_EXPAND:
-      seq_transform_handle_expand_to_fit(t, transformed_strips);
+      seq_transform_handle_expand_to_fit(scene, seqbasep, transformed_strips, use_sync_markers);
       break;
     case SEQ_OVERLAP_OVERWRITE:
-      seq_transform_handle_overwrite(t, transformed_strips);
+      seq_transform_handle_overwrite(scene, seqbasep, transformed_strips);
       break;
     case SEQ_OVERLAP_SHUFFLE:
-      seq_transform_handle_overlap_shuffle(t, transformed_strips);
+      seq_transform_handle_overlap_shuffle(scene, seqbasep, transformed_strips, use_sync_markers);
       break;
   }
 
   if (seq_transform_check_strip_effects(transformed_strips)) {
     /* Update effect strips based on strips just moved in time. */
-    seq_transform_update_effects(t, transformed_strips);
+    seq_transform_update_effects(scene, seqbasep, transformed_strips);
   }
 
   /* If any effects still overlap, we need to move them up.
@@ -582,7 +587,7 @@ static void seq_transform_handle_overlap(TransInfo *t, SeqCollection *transforme
   Sequence *seq;
   SEQ_ITERATOR_FOREACH (seq, transformed_strips) {
     if (SEQ_transform_test_overlap(seqbasep, seq)) {
-      SEQ_transform_seqbase_shuffle(seqbasep, seq, t->scene);
+      SEQ_transform_seqbase_shuffle(seqbasep, seq, scene);
     }
     seq->flag &= ~SEQ_OVERLAP;
   }
@@ -622,11 +627,15 @@ static void freeSeqData(TransInfo *t, TransDataContainer *tc, TransCustomData *c
     return;
   }
 
+  ListBase *seqbasep = seqbase_active_get(t);
+  Scene *scene = t->scene;
+  const bool use_sync_markers = (((SpaceSeq *)t->area->spacedata.first)->flag &
+                                 SEQ_MARKER_TRANS) != 0;
   if (seq_transform_check_overlap(transformed_strips)) {
-    seq_transform_handle_overlap(t, transformed_strips);
+    SEQ_transform_handle_overlap(scene, seqbasep, transformed_strips, use_sync_markers);
   }
 
-  seq_transform_update_effects(t, transformed_strips);
+  seq_transform_update_effects(scene, seqbasep, transformed_strips);
   SEQ_collection_free(transformed_strips);
 
   SEQ_sort(ed->seqbasep);
diff --git a/source/blender/editors/transform/transform_orientations.h b/source/blender/editors/transform/transform_orientations.h
index 5bca05b0c3a..3ac235517a7 100644
--- a/source/blender/editors/transform/transform_orientations.h
+++ b/source/blender/editors/transform/transform_orientations.h
@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include "RE_engine.h"
+
 struct TransInfo;
 
 /**
diff --git a/source/blender/editors/transform/transform_snap_sequencer.c b/source/blender/editors/transform/transform_snap_sequencer.c
index 7715388bf52..7dc361ff5bb 100644
--- a/source/blender/editors/transform/transform_snap_sequencer.c
+++ b/source/blender/editors/transform/transform_snap_sequencer.c
@@ -15,6 +15,7 @@
 #include "BKE_context.h"
 
 #include "ED_screen.h"
+#include "ED_transform.h"
 
 #include "UI_view2d.h"
 
@@ -33,7 +34,6 @@ typedef struct TransSeqSnapData {
   int *target_snap_points;
   int source_snap_point_count;
   int target_snap_point_count;
-  int final_snap_frame;
 } TransSeqSnapData;
 
 /* -------------------------------------------------------------------- */
@@ -58,9 +58,7 @@ static int cmp_fn(const void *a, const void *b)
   return (*(int *)a - *(int *)b);
 }
 
-static void seq_snap_source_points_build(const TransInfo *UNUSED(t),
-                                         TransSeqSnapData *snap_data,
-                                         SeqCollection *snap_sources)
+static void seq_snap_source_points_build(TransSeqSnapData *snap_data, SeqCollection *snap_sources)
 {
   int i = 0;
   Sequence *seq;
@@ -121,15 +119,17 @@ static SeqCollection *seq_collection_extract_effects(SeqCollection *collection)
   return effects;
 }
 
-static SeqCollection *query_snap_targets(const TransInfo *t, SeqCollection *snap_sources)
+static SeqCollection *query_snap_targets(Scene *scene,
+                                         SeqCollection *snap_sources,
+                                         bool exclude_selected)
 {
-  Editing *ed = SEQ_editing_get(t->scene);
+  Editing *ed = SEQ_editing_get(scene);
   ListBase *seqbase = SEQ_active_seqbase_get(ed);
   ListBase *channels = SEQ_channels_displayed_get(ed);
-  const short snap_flag = SEQ_tool_settings_snap_flag_get(t->scene);
+  const short snap_flag = SEQ_tool_settings_snap_flag_get(scene);
   SeqCollection *snap_targets = SEQ_collection_create(__func__);
   LISTBASE_FOREACH (Sequence *, seq, seqbase) {
-    if (seq->flag & SELECT) {
+    if (exclude_selected && seq->flag & SELECT) {
       continue; /* Selected are being transformed. */
     }
     if (SEQ_render_is_muted(channels, seq) && (snap_flag & SEQ_SNAP_IGNORE_MUTED)) {
@@ -152,12 +152,8 @@ static SeqCollection *query_snap_targets(const TransInfo *t, SeqCollection *snap
   return snap_targets;
 }
 
-static int seq_get_snap_target_points_count(const TransInfo *t,
-                                            TransSeqSnapData *UNUSED(snap_data),
-                                            SeqCollection *snap_targets)
+static int seq_get_snap_target_points_count(short snap_mode, SeqCollection *snap_targets)
 {
-  const short snap_mode = t->tsnap.mode;
-
   int count = 2; /* Strip start and end are always used. */
 
   if (snap_mode & SEQ_SNAP_TO_STRIP_HOLD) {
@@ -173,23 +169,21 @@ static int seq_get_snap_target_points_count(const TransInfo *t,
   return count;
 }
 
-static void seq_snap_target_points_alloc(const TransInfo *t,
+static void seq_snap_target_points_alloc(short snap_mode,
                                          TransSeqSnapData *snap_data,
                                          SeqCollection *snap_targets)
 {
-  const size_t point_count = seq_get_snap_target_points_count(t, snap_data, snap_targets);
+  const size_t point_count = seq_get_snap_target_points_count(snap_mode, snap_targets);
   snap_data->target_snap_points = MEM_callocN(sizeof(int) * point_count, __func__);
   memset(snap_data->target_snap_points, 0, sizeof(int));
   snap_data->target_snap_point_count = point_count;
 }
 
-static void seq_snap_target_points_build(const TransInfo *t,
+static void seq_snap_target_points_build(Scene *scene,
+                                         short snap_mode,
                                          TransSeqSnapData *snap_data,
                                          SeqCollection *snap_targets)
 {
-  const Scene *scene = t->scene;
-  const short snap_mode = t->tsnap.mode;
-
   int i = 0;
 
   if (snap_mode & SEQ_SNAP_TO_CURRENT_FRAME) {
@@ -246,11 +240,12 @@ TransSeqSnapData *transform_snap_sequencer_data_alloc(const TransInfo *t)
     return NULL;
   }
 
+  Scene *scene = t->scene;
   TransSeqSnapData *snap_data = MEM_callocN(sizeof(TransSeqSnapData), __func__);
-  ListBase *seqbase = SEQ_active_seqbase_get(SEQ_editing_get(t->scene));
+  ListBase *seqbase = SEQ_active_seqbase_get(SEQ_editing_get(scene));
 
   SeqCollection *snap_sources = SEQ_query_selected_strips(seqbase);
-  SeqCollection *snap_targets = query_snap_targets(t, snap_sources);
+  SeqCollection *snap_targets = query_snap_targets(scene, snap_sources, true);
 
   if (SEQ_collection_len(snap_sources) == 0) {
     SEQ_collection_free(snap_targets);
@@ -261,11 +256,12 @@ TransSeqSnapData *transform_snap_sequencer_data_alloc(const TransInfo *t)
 
   /* Build arrays of snap points. */
   seq_snap_source_points_alloc(snap_data, snap_sources);
-  seq_snap_source_points_build(t, snap_data, snap_sources);
+  seq_snap_source_points_build(snap_data, snap_sources);
   SEQ_collection_free(snap_sources);
 
-  seq_snap_target_points_alloc(t, snap_data, snap_targets);
-  seq_snap_target_points_build(t, snap_data, snap_targets);
+  short snap_mode = t->tsnap.mode;
+  seq_snap_target_points_alloc(snap_mode, snap_data, snap_targets);
+  seq_snap_target_points_build(scene, snap_mode, snap_data, snap_targets);
   SEQ_collection_free(snap_targets);
 
   return snap_data;
@@ -321,3 +317,73 @@ void transform_snap_sequencer_apply_translate(TransInfo *t, float *vec)
 {
   *vec += t->tsnap.snapPoint[0] - t->tsnap.snapTarget[0];
 }
+
+static int transform_snap_sequencer_to_closest_strip_ex(TransInfo *t, int frame_1, int frame_2)
+{
+  Scene *scene = t->scene;
+  TransSeqSnapData *snap_data = MEM_callocN(sizeof(TransSeqSnapData), __func__);
+
+  SeqCollection *empty_col = SEQ_collection_create(__func__);
+  SeqCollection *snap_targets = query_snap_targets(scene, empty_col, false);
+  SEQ_collection_free(empty_col);
+
+  snap_data->source_snap_points = MEM_callocN(sizeof(int) * 2, __func__);
+  snap_data->source_snap_point_count = 2;
+  BLI_assert(frame_1 <= frame_2);
+  snap_data->source_snap_points[0] = frame_1;
+  snap_data->source_snap_points[1] = frame_2;
+
+  short snap_mode = t->tsnap.mode;
+  /* Build arrays of snap points. */
+  seq_snap_target_points_alloc(snap_mode, snap_data, snap_targets);
+  seq_snap_target_points_build(scene, snap_mode, snap_data, snap_targets);
+  SEQ_collection_free(snap_targets);
+
+  t->tsnap.seq_context = snap_data;
+  bool snap_success = transform_snap_sequencer_calc(t);
+  transform_snap_sequencer_data_free(snap_data);
+  t->tsnap.seq_context = NULL;
+
+  float snap_offset = 0;
+  if (snap_success) {
+    t->tsnap.status |= (POINT_INIT | TARGET_INIT);
+    transform_snap_sequencer_apply_translate(t, &snap_offset);
+  }
+  else {
+    t->tsnap.status &= ~(POINT_INIT | TARGET_INIT);
+  }
+
+  return snap_offset;
+}
+
+bool ED_transform_snap_sequencer_to_closest_strip_calc(Scene *scene,
+                                                       ARegion *region,
+                                                       int frame_1,
+                                                       int frame_2,
+                                                       int *r_snap_distance,
+                                                       float *r_snap_frame)
+{
+  TransInfo t;
+  t.scene = scene;
+  t.region = region;
+  t.values[0] = 0;
+  t.data_type = TC_SEQ_DATA;
+
+  t.tsnap.mode = SEQ_tool_settings_snap_mode_get(scene);
+  *r_snap_distance = transform_snap_sequencer_to_closest_strip_ex(&t, frame_1, frame_2);
+  *r_snap_frame = t.tsnap.snapPoint[0];
+  return validSnap(&t);
+}
+
+void ED_draw_sequencer_snap_point(struct bContext *C, float snap_point)
+{
+  /* Reuse the snapping drawing code from the transform system. */
+  TransInfo t;
+  t.mode = TFM_SEQ_SLIDE;
+  t.modifiers = MOD_SNAP;
+  t.spacetype = SPACE_SEQ;
+  t.tsnap.status = (POINT_INIT | TARGET_INIT);
+  t.tsnap.snapPoint[0] = snap_point;
+
+  drawSnapping(C, &t);
+}