Cleanup: Remove seq->tmp_flag DNA member

Commit f0d20198b290 used this field to flag rendered strips which were
queried by `SEQ_query_rendered_strips()`. Then operators iterate all
strips and checks state of `seq->tmp_flag`.

Use collection returned by `SEQ_query_rendered_strips` directly.
There should be no functional changes.

This commit adds functions `all_strips_from_context` and
`selected_strips_from_context` that provide collection of strips based
on context. Most operators can use this collection directly.
There is already `seq->tmp` DNA field, but is should not be used unless
absolutely necessary. Better option is to use human readable flag.
Best is to not use DNA fields for temporary storage in runtime.

6 files changed, 121 insertions, 146 deletions

diff --git a/source/blender/editors/space_sequencer/sequencer_edit.c b/source/blender/editors/space_sequencer/sequencer_edit.c
index ce538961875..71fd6bb80f5 100644
--- a/source/blender/editors/space_sequencer/sequencer_edit.c
+++ b/source/blender/editors/space_sequencer/sequencer_edit.c
@@ -1728,26 +1728,22 @@ static int sequencer_delete_exec(bContext *C, wmOperator *UNUSED(op))
   Scene *scene = CTX_data_scene(C);
   ListBase *seqbasep = SEQ_active_seqbase_get(SEQ_editing_get(scene));
 
+  if (sequencer_view_has_preview_poll(C) && !sequencer_view_preview_only_poll(C)) {
+    return OPERATOR_CANCELLED;
+  }
+
   SEQ_prefetch_stop(scene);
 
-  const bool is_preview = sequencer_view_has_preview_poll(C);
-  if (is_preview) {
-    if (!sequencer_view_preview_only_poll(C)) {
-      return OPERATOR_CANCELLED;
-    }
-    SEQ_query_rendered_strips_to_tag(seqbasep, scene->r.cfra, 0);
-  }
+  SeqCollection *selected_strips = selected_strips_from_context(C);
+  Sequence *seq;
 
-  LISTBASE_FOREACH (Sequence *, seq, seqbasep) {
-    if (is_preview && (seq->tmp_tag == false)) {
-      continue;
-    }
-    if (seq->flag & SELECT) {
-      SEQ_edit_flag_for_removal(scene, seqbasep, seq);
-    }
+  SEQ_ITERATOR_FOREACH (seq, selected_strips) {
+    SEQ_edit_flag_for_removal(scene, seqbasep, seq);
   }
   SEQ_edit_remove_flagged_sequences(scene, seqbasep);
 
+  SEQ_collection_free(selected_strips);
+
   DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);
   DEG_relations_tag_update(bmain);
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
diff --git a/source/blender/editors/space_sequencer/sequencer_intern.h b/source/blender/editors/space_sequencer/sequencer_intern.h
index 37f17de08a0..d6360be8693 100644
--- a/source/blender/editors/space_sequencer/sequencer_intern.h
+++ b/source/blender/editors/space_sequencer/sequencer_intern.h
@@ -34,6 +34,7 @@ struct Depsgraph;
 struct Main;
 struct Scene;
 struct Sequence;
+struct SeqCollection;
 struct SpaceSeq;
 struct StripElem;
 struct bContext;
@@ -114,6 +115,25 @@ bool sequencer_view_has_preview_poll(struct bContext *C);
 bool sequencer_view_preview_only_poll(const struct bContext *C);
 bool sequencer_view_strips_poll(struct bContext *C);
 
+/**
+ * Returns collection with all strips presented to user. If operation is done in preview,
+ * collection is limited to all presented strips that can produce image output.
+ *
+ * \param C: context
+ * \return collection of strips (`Sequence`)
+ */
+struct SeqCollection *all_strips_from_context(struct bContext *C);
+
+/**
+ * Returns collection with selected strips presented to user. If operation is done in preview,
+ * collection is limited to selected presented strips, that can produce image output at current
+ * frame.
+ *
+ * \param C: context
+ * \return collection of strips (`Sequence`)
+ */
+struct SeqCollection *selected_strips_from_context(struct bContext *C);
+
 /* Externs. */
 extern EnumPropertyItem sequencer_prop_effect_types[];
 extern EnumPropertyItem prop_side_types[];
diff --git a/source/blender/editors/space_sequencer/sequencer_select.c b/source/blender/editors/space_sequencer/sequencer_select.c
index cf18429862e..90dfcc7b14d 100644
--- a/source/blender/editors/space_sequencer/sequencer_select.c
+++ b/source/blender/editors/space_sequencer/sequencer_select.c
@@ -64,6 +64,34 @@
 /** \name Selection Utilities
  * \{ */
 
+SeqCollection *all_strips_from_context(bContext *C)
+{
+  Scene *scene = CTX_data_scene(C);
+  ListBase *seqbase = SEQ_active_seqbase_get(SEQ_editing_get(scene));
+
+  const bool is_preview = sequencer_view_has_preview_poll(C);
+  if (is_preview) {
+    return SEQ_query_rendered_strips(seqbase, scene->r.cfra, 0);
+  }
+
+  return SEQ_query_all_strips(seqbase);
+}
+
+SeqCollection *selected_strips_from_context(bContext *C)
+{
+  Scene *scene = CTX_data_scene(C);
+  ListBase *seqbase = SEQ_active_seqbase_get(SEQ_editing_get(scene));
+
+  const bool is_preview = sequencer_view_has_preview_poll(C);
+  if (is_preview) {
+    SeqCollection *strips = SEQ_query_rendered_strips(seqbase, scene->r.cfra, 0);
+    SEQ_filter_selected_strips(strips);
+    return strips;
+  }
+
+  return SEQ_query_selected_strips(seqbase);
+}
+
 static void select_surrounding_handles(Scene *scene, Sequence *test) /* XXX BRING BACK */
 {
   Sequence *neighbor;
@@ -411,25 +439,18 @@ static void sequencer_select_do_updates(bContext *C, Scene *scene)
 static int sequencer_de_select_all_exec(bContext *C, wmOperator *op)
 {
   int action = RNA_enum_get(op->ptr, "action");
-
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = SEQ_editing_get(scene);
-  Sequence *seq;
 
-  const bool is_preview = sequencer_view_has_preview_poll(C);
-  if (is_preview) {
-    if (!sequencer_view_preview_only_poll(C)) {
-      return OPERATOR_CANCELLED;
-    }
-    SEQ_query_rendered_strips_to_tag(ed->seqbasep, scene->r.cfra, 0);
+  if (sequencer_view_has_preview_poll(C) && !sequencer_view_preview_only_poll(C)) {
+    return OPERATOR_CANCELLED;
   }
 
+  SeqCollection *strips = all_strips_from_context(C);
+  Sequence *seq;
+
   if (action == SEL_TOGGLE) {
     action = SEL_SELECT;
-    for (seq = ed->seqbasep->first; seq; seq = seq->next) {
-      if (is_preview && (seq->tmp_tag == false)) {
-        continue;
-      }
+    SEQ_ITERATOR_FOREACH (seq, strips) {
       if (seq->flag & SEQ_ALLSEL) {
         action = SEL_DESELECT;
         break;
@@ -437,10 +458,7 @@ static int sequencer_de_select_all_exec(bContext *C, wmOperator *op)
     }
   }
 
-  for (seq = ed->seqbasep->first; seq; seq = seq->next) {
-    if (is_preview && (seq->tmp_tag == false)) {
-      continue;
-    }
+  SEQ_ITERATOR_FOREACH (seq, strips) {
     switch (action) {
       case SEL_SELECT:
         seq->flag &= ~(SEQ_LEFTSEL + SEQ_RIGHTSEL);
@@ -461,8 +479,9 @@ static int sequencer_de_select_all_exec(bContext *C, wmOperator *op)
     }
   }
 
-  ED_outliner_select_sync_from_sequence_tag(C);
+  SEQ_collection_free(strips);
 
+  ED_outliner_select_sync_from_sequence_tag(C);
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER | NA_SELECTED, scene);
 
   return OPERATOR_FINISHED;
@@ -494,21 +513,15 @@ void SEQUENCER_OT_select_all(struct wmOperatorType *ot)
 static int sequencer_select_inverse_exec(bContext *C, wmOperator *UNUSED(op))
 {
   Scene *scene = CTX_data_scene(C);
-  Editing *ed = SEQ_editing_get(scene);
-  Sequence *seq;
 
-  const bool is_preview = sequencer_view_has_preview_poll(C);
-  if (is_preview) {
-    if (!sequencer_view_preview_only_poll(C)) {
-      return OPERATOR_CANCELLED;
-    }
-    SEQ_query_rendered_strips_to_tag(ed->seqbasep, scene->r.cfra, 0);
+  if (sequencer_view_has_preview_poll(C) && !sequencer_view_preview_only_poll(C)) {
+    return OPERATOR_CANCELLED;
   }
 
-  for (seq = ed->seqbasep->first; seq; seq = seq->next) {
-    if (is_preview && (seq->tmp_tag == false)) {
-      continue;
-    }
+  SeqCollection *strips = all_strips_from_context(C);
+  Sequence *seq;
+
+  SEQ_ITERATOR_FOREACH (seq, strips) {
     if (seq->flag & SELECT) {
       seq->flag &= ~SEQ_ALLSEL;
     }
@@ -518,8 +531,9 @@ static int sequencer_select_inverse_exec(bContext *C, wmOperator *UNUSED(op))
     }
   }
 
-  ED_outliner_select_sync_from_sequence_tag(C);
+  SEQ_collection_free(strips);
 
+  ED_outliner_select_sync_from_sequence_tag(C);
   WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER | NA_SELECTED, scene);
 
   return OPERATOR_FINISHED;
@@ -1784,17 +1798,15 @@ static const EnumPropertyItem sequencer_prop_select_grouped_types[] = {
 
 #define SEQ_CHANNEL_CHECK(_seq, _chan) (ELEM((_chan), 0, (_seq)->machine))
 
-static bool select_grouped_type(ListBase *seqbasep,
-                                const bool is_preview,
+static bool select_grouped_type(SeqCollection *strips,
+                                ListBase *seqbase,
                                 Sequence *actseq,
                                 const int channel)
 {
   bool changed = false;
 
-  LISTBASE_FOREACH (Sequence *, seq, seqbasep) {
-    if (is_preview && (seq->tmp_tag == false)) {
-      continue;
-    }
+  Sequence *seq;
+  SEQ_ITERATOR_FOREACH (seq, strips) {
     if (SEQ_CHANNEL_CHECK(seq, channel) && seq->type == actseq->type) {
       seq->flag |= SELECT;
       changed = true;
@@ -1804,18 +1816,16 @@ static bool select_grouped_type(ListBase *seqbasep,
   return changed;
 }
 
-static bool select_grouped_type_basic(ListBase *seqbase,
-                                      const bool is_preview,
+static bool select_grouped_type_basic(SeqCollection *strips,
+                                      ListBase *seqbase,
                                       Sequence *actseq,
                                       const int channel)
 {
   bool changed = false;
   const bool is_sound = SEQ_IS_SOUND(actseq);
 
-  LISTBASE_FOREACH (Sequence *, seq, seqbase) {
-    if (is_preview && (seq->tmp_tag == false)) {
-      continue;
-    }
+  Sequence *seq;
+  SEQ_ITERATOR_FOREACH (seq, strips) {
     if (SEQ_CHANNEL_CHECK(seq, channel) && (is_sound ? SEQ_IS_SOUND(seq) : !SEQ_IS_SOUND(seq))) {
       seq->flag |= SELECT;
       changed = true;
@@ -1825,18 +1835,16 @@ static bool select_grouped_type_basic(ListBase *seqbase,
   return changed;
 }
 
-static bool select_grouped_type_effect(ListBase *seqbase,
-                                       const bool is_preview,
+static bool select_grouped_type_effect(SeqCollection *strips,
+                                       ListBase *seqbase,
                                        Sequence *actseq,
                                        const int channel)
 {
   bool changed = false;
   const bool is_effect = SEQ_IS_EFFECT(actseq);
 
-  LISTBASE_FOREACH (Sequence *, seq, seqbase) {
-    if (is_preview && (seq->tmp_tag == false)) {
-      continue;
-    }
+  Sequence *seq;
+  SEQ_ITERATOR_FOREACH (seq, strips) {
     if (SEQ_CHANNEL_CHECK(seq, channel) &&
         (is_effect ? SEQ_IS_EFFECT(seq) : !SEQ_IS_EFFECT(seq))) {
       seq->flag |= SELECT;
@@ -1847,8 +1855,8 @@ static bool select_grouped_type_effect(ListBase *seqbase,
   return changed;
 }
 
-static bool select_grouped_data(ListBase *seqbase,
-                                const bool is_preview,
+static bool select_grouped_data(SeqCollection *strips,
+                                ListBase *seqbase,
                                 Sequence *actseq,
                                 const int channel)
 {
@@ -1859,11 +1867,10 @@ static bool select_grouped_data(ListBase *seqbase,
     return changed;
   }
 
+  Sequence *seq;
+
   if (SEQ_HAS_PATH(actseq) && dir) {
-    LISTBASE_FOREACH (Sequence *, seq, seqbase) {
-      if (is_preview && (seq->tmp_tag == false)) {
-        continue;
-      }
+    SEQ_ITERATOR_FOREACH (seq, strips) {
       if (SEQ_CHANNEL_CHECK(seq, channel) && SEQ_HAS_PATH(seq) && seq->strip &&
           STREQ(seq->strip->dir, dir)) {
         seq->flag |= SELECT;
@@ -1873,7 +1880,7 @@ static bool select_grouped_data(ListBase *seqbase,
   }
   else if (actseq->type == SEQ_TYPE_SCENE) {
     Scene *sce = actseq->scene;
-    LISTBASE_FOREACH (Sequence *, seq, seqbase) {
+    SEQ_ITERATOR_FOREACH (seq, strips) {
       if (SEQ_CHANNEL_CHECK(seq, channel) && seq->type == SEQ_TYPE_SCENE && seq->scene == sce) {
         seq->flag |= SELECT;
         changed = true;
@@ -1882,7 +1889,7 @@ static bool select_grouped_data(ListBase *seqbase,
   }
   else if (actseq->type == SEQ_TYPE_MOVIECLIP) {
     MovieClip *clip = actseq->clip;
-    LISTBASE_FOREACH (Sequence *, seq, seqbase) {
+    SEQ_ITERATOR_FOREACH (seq, strips) {
       if (SEQ_CHANNEL_CHECK(seq, channel) && seq->type == SEQ_TYPE_MOVIECLIP &&
           seq->clip == clip) {
         seq->flag |= SELECT;
@@ -1892,7 +1899,7 @@ static bool select_grouped_data(ListBase *seqbase,
   }
   else if (actseq->type == SEQ_TYPE_MASK) {
     struct Mask *mask = actseq->mask;
-    LISTBASE_FOREACH (Sequence *, seq, seqbase) {
+    SEQ_ITERATOR_FOREACH (seq, strips) {
       if (SEQ_CHANNEL_CHECK(seq, channel) && seq->type == SEQ_TYPE_MASK && seq->mask == mask) {
         seq->flag |= SELECT;
         changed = true;
@@ -1903,8 +1910,8 @@ static bool select_grouped_data(ListBase *seqbase,
   return changed;
 }
 
-static bool select_grouped_effect(ListBase *seqbase,
-                                  const bool is_preview,
+static bool select_grouped_effect(SeqCollection *strips,
+                                  ListBase *seqbase,
                                   Sequence *actseq,
                                   const int channel)
 {
@@ -1916,9 +1923,6 @@ static bool select_grouped_effect(ListBase *seqbase,
   }
 
   LISTBASE_FOREACH (Sequence *, seq, seqbase) {
-    if (is_preview && (seq->tmp_tag == false)) {
-      continue;
-    }
     if (SEQ_CHANNEL_CHECK(seq, channel) && (seq->type & SEQ_TYPE_EFFECT) &&
         ELEM(actseq, seq->seq1, seq->seq2, seq->seq3)) {
       effects[seq->type] = true;
@@ -1926,9 +1930,6 @@ static bool select_grouped_effect(ListBase *seqbase,
   }
 
   LISTBASE_FOREACH (Sequence *, seq, seqbase) {
-    if (is_preview && (seq->tmp_tag == false)) {
-      continue;
-    }
     if (SEQ_CHANNEL_CHECK(seq, channel) && effects[seq->type]) {
       if (seq->seq1) {
         seq->seq1->flag |= SELECT;
@@ -1946,14 +1947,11 @@ static bool select_grouped_effect(ListBase *seqbase,
   return changed;
 }
 
-static bool select_grouped_time_overlap(ListBase *seqbase, const bool is_preview, Sequence *actseq)
+static bool select_grouped_time_overlap(SeqCollection *strips, ListBase *seqbase, Sequence *actseq)
 {
   bool changed = false;
 
   LISTBASE_FOREACH (Sequence *, seq, seqbase) {
-    if (is_preview && (seq->tmp_tag == false)) {
-      continue;
-    }
     if (seq->startdisp < actseq->enddisp && seq->enddisp > actseq->startdisp) {
       seq->flag |= SELECT;
       changed = true;
@@ -1982,31 +1980,26 @@ static void query_lower_channel_strips(Sequence *seq_reference,
 
 /* Select all strips within time range and with lower channel of initial selection. Then select
  * effect chains of these strips. */
-static bool select_grouped_effect_link(ListBase *seqbase,
-                                       const bool is_preview,
+static bool select_grouped_effect_link(SeqCollection *strips,
+                                       ListBase *seqbase,
                                        Sequence *UNUSED(actseq),
                                        const int UNUSED(channel))
 {
   /* Get collection of strips. */
-  SeqCollection *collection = SEQ_query_selected_strips(seqbase);
-  const int selected_strip_count = BLI_gset_len(collection->set);
-  SEQ_collection_expand(seqbase, collection, query_lower_channel_strips);
-  SEQ_collection_expand(seqbase, collection, SEQ_query_strip_effect_chain);
+  SEQ_filter_selected_strips(strips);
+  const int selected_strip_count = SEQ_collection_len(strips);
+  SEQ_collection_expand(seqbase, strips, query_lower_channel_strips);
+  SEQ_collection_expand(seqbase, strips, SEQ_query_strip_effect_chain);
 
   /* Check if other strips will be affected. */
-  const bool changed = BLI_gset_len(collection->set) > selected_strip_count;
+  const bool changed = SEQ_collection_len(strips) > selected_strip_count;
 
   /* Actual logic. */
   Sequence *seq;
-  SEQ_ITERATOR_FOREACH (seq, collection) {
-    if (is_preview && (seq->tmp_tag == false)) {
-      continue;
-    }
+  SEQ_ITERATOR_FOREACH (seq, strips) {
     seq->flag |= SELECT;
   }
 
-  SEQ_collection_free(collection);
-
   return changed;
 }
 
@@ -2021,17 +2014,13 @@ static int sequencer_select_grouped_exec(bContext *C, wmOperator *op)
   Sequence *actseq = SEQ_select_active_get(scene);
 
   const bool is_preview = sequencer_view_has_preview_poll(C);
-  if (is_preview) {
-    if (!sequencer_view_preview_only_poll(C)) {
-      return OPERATOR_CANCELLED;
-    }
-    SEQ_query_rendered_strips_to_tag(seqbase, scene->r.cfra, 0);
-    if (actseq && actseq->tmp_tag == false) {
-      actseq = NULL;
-    }
+  if (is_preview && !sequencer_view_preview_only_poll(C)) {
+    return OPERATOR_CANCELLED;
   }
 
-  if (actseq == NULL) {
+  SeqCollection *strips = all_strips_from_context(C);
+
+  if (actseq == NULL || (is_preview && !SEQ_collection_has_strip(actseq, strips))) {
     BKE_report(op->reports, RPT_ERROR, "No active sequence!");
     return OPERATOR_CANCELLED;
   }
@@ -2051,31 +2040,33 @@ static int sequencer_select_grouped_exec(bContext *C, wmOperator *op)
 
   switch (type) {
     case SEQ_SELECT_GROUP_TYPE:
-      changed |= select_grouped_type(seqbase, is_preview, actseq, channel);
+      changed |= select_grouped_type(strips, seqbase, actseq, channel);
       break;
     case SEQ_SELECT_GROUP_TYPE_BASIC:
-      changed |= select_grouped_type_basic(seqbase, is_preview, actseq, channel);
+      changed |= select_grouped_type_basic(strips, seqbase, actseq, channel);
       break;
     case SEQ_SELECT_GROUP_TYPE_EFFECT:
-      changed |= select_grouped_type_effect(seqbase, is_preview, actseq, channel);
+      changed |= select_grouped_type_effect(strips, seqbase, actseq, channel);
       break;
     case SEQ_SELECT_GROUP_DATA:
-      changed |= select_grouped_data(seqbase, is_preview, actseq, channel);
+      changed |= select_grouped_data(strips, seqbase, actseq, channel);
       break;
     case SEQ_SELECT_GROUP_EFFECT:
-      changed |= select_grouped_effect(seqbase, is_preview, actseq, channel);
+      changed |= select_grouped_effect(strips, seqbase, actseq, channel);
       break;
     case SEQ_SELECT_GROUP_EFFECT_LINK:
-      changed |= select_grouped_effect_link(seqbase, is_preview, actseq, channel);
+      changed |= select_grouped_effect_link(strips, seqbase, actseq, channel);
       break;
     case SEQ_SELECT_GROUP_OVERLAP:
-      changed |= select_grouped_time_overlap(seqbase, is_preview, actseq);
+      changed |= select_grouped_time_overlap(strips, seqbase, actseq);
       break;
     default:
       BLI_assert(0);
       break;
   }
 
+  SEQ_collection_free(strips);
+
   if (changed) {
     ED_outliner_select_sync_from_sequence_tag(C);
     WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER | NA_SELECTED, scene);
diff --git a/source/blender/makesdna/DNA_sequence_types.h b/source/blender/makesdna/DNA_sequence_types.h
index 9e6cf907444..e1bba60396a 100644
--- a/source/blender/makesdna/DNA_sequence_types.h
+++ b/source/blender/makesdna/DNA_sequence_types.h
@@ -180,8 +180,7 @@ typedef struct Sequence {
   int startdisp, enddisp;
   float sat;
   float mul;
-  char tmp_tag;
-  char _pad[3];
+  float _pad;
 
   short anim_preseek; /* UNUSED. */
   /** Streamindex for movie or sound files with several streams. */
diff --git a/source/blender/sequencer/SEQ_iterator.h b/source/blender/sequencer/SEQ_iterator.h
index 4de7c09640b..d2a47a13db3 100644
--- a/source/blender/sequencer/SEQ_iterator.h
+++ b/source/blender/sequencer/SEQ_iterator.h
@@ -104,11 +104,6 @@ void SEQ_query_strip_effect_chain(struct Sequence *seq_reference,
                                   SeqCollection *collection);
 void SEQ_filter_selected_strips(SeqCollection *collection);
 
-/* Utilities to access these as tags. */
-int SEQ_query_rendered_strips_to_tag(ListBase *seqbase,
-                                     const int timeline_frame,
-                                     const int displayed_channel);
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/blender/sequencer/intern/iterator.c b/source/blender/sequencer/intern/iterator.c
index 68f632ddb28..a12a5cbdc61 100644
--- a/source/blender/sequencer/intern/iterator.c
+++ b/source/blender/sequencer/intern/iterator.c
@@ -520,29 +520,3 @@ void SEQ_filter_selected_strips(SeqCollection *collection)
     }
   }
 }
-
-static void seq_collection_to_tag(ListBase *seqbase, SeqCollection *collection)
-{
-  LISTBASE_FOREACH (Sequence *, seq, seqbase) {
-    seq->tmp_tag = false;
-  }
-  Sequence *seq;
-  SEQ_ITERATOR_FOREACH (seq, collection) {
-    seq->tmp_tag = true;
-  }
-}
-
-/* Utilities to access these as tags. */
-int SEQ_query_rendered_strips_to_tag(ListBase *seqbase,
-                                     const int timeline_frame,
-                                     const int displayed_channel)
-{
-  SeqCollection *collection = SEQ_query_rendered_strips(
-      seqbase, timeline_frame, displayed_channel);
-
-  seq_collection_to_tag(seqbase, collection);
-
-  const int len = SEQ_collection_len(collection);
-  SEQ_collection_free(collection);
-  return len;
-}