griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Cleanup: VSE: Rename uses of "sequence" in outliner code

Browse Source 
Renames some internal names to reflect the new naming
of `Sequence` -> `Strip`.

Pull Request: https://projects.blender.org/blender/blender/pulls/132701
This commit is contained in:
Falk David
2025-01-06 18:17:47 +01:00
committed by Falk David
parent 0f8cf1a0e9
commit 4edf250a65
12 changed files with 127 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
source/blender/editors/space_outliner/outliner_draw.cc
View File

@@ -2777,9 +2777,9 @@ TreeElementIcon tree_element_get_icon(TreeStoreElem *tselem, TreeElement *te)
case TSE_BONE_COLLECTION:
data.icon = ICON_GROUP_BONE;
break;
case TSE_SEQUENCE: {
const TreeElementSequence *te_seq = tree_element_cast<TreeElementSequence>(te);
switch (te_seq->get_sequence_type()) {
case TSE_STRIP: {
const TreeElementStrip *te_strip = tree_element_cast<TreeElementStrip>(te);
switch (te_strip->get_strip_type()) {
case SEQ_TYPE_SCENE:
data.icon = ICON_SCENE_DATA;
break;
@@ -2833,10 +2833,10 @@ TreeElementIcon tree_element_get_icon(TreeStoreElem *tselem, TreeElement *te)
}
break;
}
case TSE_SEQ_STRIP:
case TSE_STRIP_DATA:
data.icon = ICON_LIBRARY_DATA_DIRECT;
break;
case TSE_SEQUENCE_DUP:
case TSE_STRIP_DUP:
data.icon = ICON_SEQ_STRIP_DUPLICATE;
break;
case TSE_RNA_STRUCT: {

4
source/blender/editors/space_outliner/outliner_edit.cc
View File

@@ -341,8 +341,8 @@ static void do_item_rename(ARegion *region,
{
BKE_report(reports, RPT_INFO, "Not an editable name");
}
else if (ELEM(tselem->type, TSE_SEQUENCE, TSE_SEQ_STRIP, TSE_SEQUENCE_DUP)) {
BKE_report(reports, RPT_INFO, "Sequence names are not editable from the Outliner");
else if (ELEM(tselem->type, TSE_STRIP, TSE_STRIP_DATA, TSE_STRIP_DUP)) {
BKE_report(reports, RPT_INFO, "Strip names are not editable from the Outliner");
}
else if (TSE_IS_REAL_ID(tselem) && !ID_IS_EDITABLE(tselem->id)) {
BKE_report(reports, RPT_INFO, "External library data is not editable");

49
source/blender/editors/space_outliner/outliner_select.cc
View File

@@ -730,13 +730,13 @@ static void tree_element_constraint_activate(bContext *C,
WM_event_add_notifier(C, NC_OBJECT | ND_CONSTRAINT, ob);
}
static void tree_element_sequence_activate(bContext *C,
Scene *scene,
TreeElement *te,
const eOLSetState set)
static void tree_element_strip_activate(bContext *C,
Scene *scene,
TreeElement *te,
const eOLSetState set)
{
const TreeElementSequence *te_seq = tree_element_cast<TreeElementSequence>(te);
Strip *seq = &te_seq->get_sequence();
const TreeElementStrip *te_strip = tree_element_cast<TreeElementStrip>(te);
Strip *seq = &te_strip->get_strip();
Editing *ed = SEQ_editing_get(scene);
if (BLI_findindex(ed->seqbasep, seq) != -1) {
@@ -757,7 +757,7 @@ static void tree_element_sequence_activate(bContext *C,
WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER | NA_SELECTED, scene);
}
static void tree_element_sequence_dup_activate(Scene *scene, TreeElement * /*te*/)
static void tree_element_strip_dup_activate(Scene *scene, TreeElement * /*te*/)
{
Editing *ed = SEQ_editing_get(scene);
@@ -882,11 +882,11 @@ void tree_element_type_active_set(bContext *C,
case TSE_BONE_COLLECTION:
tree_element_bonecollection_activate(C, te, tselem);
break;
case TSE_SEQUENCE:
tree_element_sequence_activate(C, tvc.scene, te, set);
case TSE_STRIP:
tree_element_strip_activate(C, tvc.scene, te, set);
break;
case TSE_SEQUENCE_DUP:
tree_element_sequence_dup_activate(tvc.scene, te);
case TSE_STRIP_DUP:
tree_element_strip_dup_activate(tvc.scene, te);
break;
case TSE_GP_LAYER:
tree_element_gplayer_activate(C, te, tselem);
@@ -1020,10 +1020,10 @@ static eOLDrawState tree_element_bone_collection_state_get(const TreeElement *te
return OL_DRAWSEL_NONE;
}
static eOLDrawState tree_element_sequence_state_get(const Scene *scene, const TreeElement *te)
static eOLDrawState tree_element_strip_state_get(const Scene *scene, const TreeElement *te)
{
const TreeElementSequence *te_seq = tree_element_cast<TreeElementSequence>(te);
const Strip *seq = &te_seq->get_sequence();
const TreeElementStrip *te_strip = tree_element_cast<TreeElementStrip>(te);
const Strip *seq = &te_strip->get_strip();
const Editing *ed = scene->ed;
if (ed && ed->act_seq == seq && seq->flag & SELECT) {
@@ -1032,11 +1032,10 @@ static eOLDrawState tree_element_sequence_state_get(const Scene *scene, const Tr
return OL_DRAWSEL_NONE;
}
static eOLDrawState tree_element_sequence_dup_state_get(const TreeElement *te)
static eOLDrawState tree_element_strip_dup_state_get(const TreeElement *te)
{
const TreeElementSequenceStripDuplicate *te_dup =
tree_element_cast<TreeElementSequenceStripDuplicate>(te);
const Strip *seq = &te_dup->get_sequence();
const TreeElementStripDuplicate *te_dup = tree_element_cast<TreeElementStripDuplicate>(te);
const Strip *seq = &te_dup->get_strip();
if (seq->flag & SELECT) {
return OL_DRAWSEL_NORMAL;
}
@@ -1195,10 +1194,10 @@ eOLDrawState tree_element_type_active_state_get(const TreeViewContext &tvc,
return OL_DRAWSEL_NONE;
case TSE_R_LAYER:
return tree_element_viewlayer_state_get(tvc.view_layer, te);
case TSE_SEQUENCE:
return tree_element_sequence_state_get(tvc.scene, te);
case TSE_SEQUENCE_DUP:
return tree_element_sequence_dup_state_get(te);
case TSE_STRIP:
return tree_element_strip_state_get(tvc.scene, te);
case TSE_STRIP_DUP:
return tree_element_strip_dup_state_get(te);
case TSE_GP_LAYER:
return tree_element_gplayer_state_get(te);
case TSE_GREASE_PENCIL_NODE:
@@ -1449,9 +1448,9 @@ static void do_outliner_item_activate_tree_element(bContext *C,
{
/* Always makes active object, except for some specific types. */
if (ELEM(tselem->type,
TSE_SEQUENCE,
TSE_SEQ_STRIP,
TSE_SEQUENCE_DUP,
TSE_STRIP,
TSE_STRIP_DATA,
TSE_STRIP_DUP,
TSE_EBONE,
TSE_LINKED_NODE_TREE,
TSE_LAYER_COLLECTION))

48
source/blender/editors/space_outliner/outliner_sync.cc
View File

@@ -111,7 +111,7 @@ struct SyncSelectTypes {
bool object;
bool edit_bone;
bool pose_bone;
bool sequence;
bool seq_strip;
};
/**
@@ -130,7 +130,7 @@ static void outliner_sync_select_from_outliner_set_types(bContext *C,
sync_types->object = !sequence_view;
sync_types->edit_bone = !sequence_view && (tvc.ob_edit && tvc.ob_edit->type == OB_ARMATURE);
sync_types->pose_bone = !sequence_view && (tvc.ob_pose && tvc.ob_pose->mode == OB_MODE_POSE);
sync_types->sequence = sequence_view;
sync_types->seq_strip = sequence_view;
}
/**
@@ -152,11 +152,11 @@ static bool outliner_sync_select_to_outliner_set_types(const TreeViewContext &tv
sync_types->pose_bone = !sequence_view && (tvc.ob_pose && tvc.ob_pose->mode == OB_MODE_POSE) &&
(space_outliner->sync_select_dirty &
WM_OUTLINER_SYNC_SELECT_FROM_POSE_BONE);
sync_types->sequence = sequence_view && (space_outliner->sync_select_dirty &
WM_OUTLINER_SYNC_SELECT_FROM_SEQUENCE);
sync_types->seq_strip = sequence_view && (space_outliner->sync_select_dirty &
WM_OUTLINER_SYNC_SELECT_FROM_SEQUENCE);
return sync_types->object || sync_types->edit_bone || sync_types->pose_bone ||
sync_types->sequence;
sync_types->seq_strip;
}
/**
@@ -250,12 +250,12 @@ static void outliner_select_sync_to_pose_bone(TreeElement *te,
}
}
static void outliner_select_sync_to_sequence(Scene *scene, const TreeElement *te)
static void outliner_select_sync_to_strip(Scene *scene, const TreeElement *te)
{
const TreeStoreElem *tselem = TREESTORE(te);
const TreeElementSequence *te_sequence = tree_element_cast<TreeElementSequence>(te);
Strip *seq = &te_sequence->get_sequence();
const TreeElementStrip *te_strip = tree_element_cast<TreeElementStrip>(te);
Strip *seq = &te_strip->get_strip();
if (tselem->flag & TSE_ACTIVE) {
SEQ_select_active_set(scene, seq);
@@ -296,9 +296,9 @@ static void outliner_sync_selection_from_outliner(Scene *scene,
outliner_select_sync_to_pose_bone(te, tselem, selected_items->pose_bones);
}
}
else if (tselem->type == TSE_SEQUENCE) {
if (sync_types->sequence) {
outliner_select_sync_to_sequence(scene, te);
else if (tselem->type == TSE_STRIP) {
if (sync_types->seq_strip) {
outliner_select_sync_to_strip(scene, te);
}
}
@@ -346,7 +346,7 @@ void ED_outliner_select_sync_from_outliner(bContext *C, SpaceOutliner *space_out
else if (sync_types.pose_bone) {
space_outliner->sync_select_dirty &= ~WM_OUTLINER_SYNC_SELECT_FROM_POSE_BONE;
}
if (sync_types.sequence) {
if (sync_types.seq_strip) {
space_outliner->sync_select_dirty &= ~WM_OUTLINER_SYNC_SELECT_FROM_SEQUENCE;
WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER | NA_SELECTED, scene);
}
@@ -424,14 +424,14 @@ static void outliner_select_sync_from_pose_bone(bPoseChannel *pchan_active,
}
}
static void outliner_select_sync_from_sequence(Strip *sequence_active, const TreeElement *te)
static void outliner_select_sync_from_strip(Strip *strip_active, const TreeElement *te)
{
TreeStoreElem *tselem = TREESTORE(te);
const TreeElementSequence *te_sequence = tree_element_cast<TreeElementSequence>(te);
const Strip *seq = &te_sequence->get_sequence();
const TreeElementStrip *te_strip = tree_element_cast<TreeElementStrip>(te);
const Strip *seq = &te_strip->get_strip();
if (seq == sequence_active) {
if (seq == strip_active) {
tselem->flag |= TSE_ACTIVE;
}
else {
@@ -447,14 +447,14 @@ static void outliner_select_sync_from_sequence(Strip *sequence_active, const Tre
}
/**
* Contains active object, bones, and sequence for syncing to prevent getting active data
* Contains active object, bones, and strip for syncing to prevent getting active data
* repeatedly throughout syncing to the outliner.
*/
struct SyncSelectActiveData {
Object *object;
EditBone *edit_bone;
bPoseChannel *pose_channel;
Strip *sequence;
Strip *strip;
};
/** Sync select and active flags from active view layer, bones, and sequences to the outliner. */
@@ -483,9 +483,9 @@ static void outliner_sync_selection_to_outliner(const Scene *scene,
outliner_select_sync_from_pose_bone(active_data->pose_channel, te, tselem);
}
}
else if (tselem->type == TSE_SEQUENCE) {
if (sync_types->sequence) {
outliner_select_sync_from_sequence(active_data->sequence, te);
else if (tselem->type == TSE_STRIP) {
if (sync_types->seq_strip) {
outliner_select_sync_from_strip(active_data->strip, te);
}
}
else {
@@ -507,7 +507,7 @@ static void get_sync_select_active_data(const bContext *C, SyncSelectActiveData
active_data->object = BKE_view_layer_active_object_get(view_layer);
active_data->edit_bone = CTX_data_active_bone(C);
active_data->pose_channel = CTX_data_active_pose_bone(C);
active_data->sequence = SEQ_select_active_get(scene);
active_data->strip = SEQ_select_active_get(scene);
}
void outliner_sync_selection(const bContext *C,
@@ -520,7 +520,7 @@ void outliner_sync_selection(const bContext *C,
tvc, space_outliner, &sync_types);
if (sync_required) {
/* Store active object, bones, and sequence */
/* Store active object, bones, and strip */
SyncSelectActiveData active_data;
get_sync_select_active_data(C, &active_data);
@@ -541,7 +541,7 @@ void outliner_sync_selection(const bContext *C,
if (sync_types.pose_bone) {
space_outliner->sync_select_dirty &= ~WM_OUTLINER_SYNC_SELECT_FROM_POSE_BONE;
}
if (sync_types.sequence) {
if (sync_types.seq_strip) {
space_outliner->sync_select_dirty &= ~WM_OUTLINER_SYNC_SELECT_FROM_SEQUENCE;
}
}

15
source/blender/editors/space_outliner/outliner_tools.cc
View File

@@ -2149,8 +2149,8 @@ static void ebone_fn(int event, TreeElement *te, TreeStoreElem * /*tselem*/, voi
static void sequence_fn(int event, TreeElement *te, TreeStoreElem * /*tselem*/, void *scene_ptr)
{
TreeElementSequence *te_seq = tree_element_cast<TreeElementSequence>(te);
Strip *seq = &te_seq->get_sequence();
TreeElementStrip *te_strip = tree_element_cast<TreeElementStrip>(te);
Strip *seq = &te_strip->get_strip();
Scene *scene = (Scene *)scene_ptr;
Editing *ed = SEQ_editing_get(scene);
if (BLI_findindex(ed->seqbasep, seq) != -1) {
@@ -3485,13 +3485,8 @@ static bool outliner_data_operation_poll(bContext *C)
int scenelevel = 0, objectlevel = 0, idlevel = 0, datalevel = 0;
get_element_operation_type(te, &scenelevel, &objectlevel, &idlevel, &datalevel);
return ELEM(datalevel,
TSE_POSE_CHANNEL,
TSE_BONE,
TSE_EBONE,
TSE_SEQUENCE,
TSE_GP_LAYER,
TSE_RNA_STRUCT);
return ELEM(
datalevel, TSE_POSE_CHANNEL, TSE_BONE, TSE_EBONE, TSE_STRIP, TSE_GP_LAYER, TSE_RNA_STRUCT);
}
static int outliner_data_operation_exec(bContext *C, wmOperator *op)
@@ -3524,7 +3519,7 @@ static int outliner_data_operation_exec(bContext *C, wmOperator *op)
break;
}
case TSE_SEQUENCE: {
case TSE_STRIP: {
Scene *scene = CTX_data_scene(C);
outliner_do_data_operation(space_outliner, datalevel, event, sequence_fn, scene);
WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER | NA_SELECTED, scene);

2
source/blender/editors/space_outliner/outliner_tree.cc
View File

@@ -300,7 +300,7 @@ TreeElement *AbstractTreeDisplay::add_element(ListBase *lb,
te->abstract_element->display_ = this;
}
if (ELEM(type, TSE_SEQUENCE, TSE_SEQ_STRIP, TSE_SEQUENCE_DUP)) {
if (ELEM(type, TSE_STRIP, TSE_STRIP_DATA, TSE_STRIP_DUP)) {
/* pass */
}
else if (ELEM(type, TSE_RNA_STRUCT, TSE_RNA_PROPERTY, TSE_RNA_ARRAY_ELEM)) {

10
source/blender/editors/space_outliner/tree/tree_display.hh
View File

@@ -217,11 +217,7 @@ class TreeDisplayOverrideLibraryHierarchies final : public AbstractTreeDisplay {
/* -------------------------------------------------------------------- */
/* Video Sequencer Tree-Display */
enum SequenceAddOp {
SEQUENCE_DUPLICATE_NOOP = 0,
SEQUENCE_DUPLICATE_ADD,
SEQUENCE_DUPLICATE_NONE
};
enum class StripAddOp : int8_t { Noop = 0, Add, None };
/**
* \brief Tree-Display for the Video Sequencer display mode
@@ -237,8 +233,8 @@ class TreeDisplaySequencer final : public AbstractTreeDisplay {
/**
* Helped function to put duplicate sequence in the same tree.
*/
SequenceAddOp need_add_seq_dup(Strip *seq) const;
void add_seq_dup(Strip *seq, TreeElement *te, short index);
StripAddOp need_add_strip_dup(Strip *seq) const;
void add_strip_dup(Strip *seq, TreeElement *te, short index);
};
/* -------------------------------------------------------------------- */

26
source/blender/editors/space_outliner/tree/tree_display_sequencer.cc
View File

@@ -39,23 +39,23 @@ ListBase TreeDisplaySequencer::build_tree(const TreeSourceData &source_data)
}
for (Strip *seq : List<Strip>(ed->seqbasep)) {
SequenceAddOp op = need_add_seq_dup(seq);
if (op == SEQUENCE_DUPLICATE_NONE) {
add_element(&tree, nullptr, seq, nullptr, TSE_SEQUENCE, 0);
StripAddOp op = need_add_strip_dup(seq);
if (op == StripAddOp::None) {
add_element(&tree, nullptr, seq, nullptr, TSE_STRIP, 0);
}
else if (op == SEQUENCE_DUPLICATE_ADD) {
TreeElement *te = add_element(&tree, nullptr, seq, nullptr, TSE_SEQUENCE_DUP, 0);
add_seq_dup(seq, te, 0);
else if (op == StripAddOp::Add) {
TreeElement *te = add_element(&tree, nullptr, seq, nullptr, TSE_STRIP_DUP, 0);
add_strip_dup(seq, te, 0);
}
}
return tree;
}
SequenceAddOp TreeDisplaySequencer::need_add_seq_dup(Strip *seq) const
StripAddOp TreeDisplaySequencer::need_add_strip_dup(Strip *seq) const
{
if ((!seq->data) || (!seq->data->stripdata)) {
return SEQUENCE_DUPLICATE_NONE;
return StripAddOp::None;
}
/*
@@ -70,7 +70,7 @@ SequenceAddOp TreeDisplaySequencer::need_add_seq_dup(Strip *seq) const
}
if (STREQ(p->data->stripdata->filename, seq->data->stripdata->filename)) {
return SEQUENCE_DUPLICATE_NOOP;
return StripAddOp::Noop;
}
p = p->prev;
}
@@ -83,15 +83,15 @@ SequenceAddOp TreeDisplaySequencer::need_add_seq_dup(Strip *seq) const
}
if (STREQ(p->data->stripdata->filename, seq->data->stripdata->filename)) {
return SEQUENCE_DUPLICATE_ADD;
return StripAddOp::Add;
}
p = p->next;
}
return SEQUENCE_DUPLICATE_NONE;
return StripAddOp::None;
}
void TreeDisplaySequencer::add_seq_dup(Strip *seq, TreeElement *te, short index)
void TreeDisplaySequencer::add_strip_dup(Strip *seq, TreeElement *te, short index)
{
Strip *p = seq;
while (p) {
@@ -101,7 +101,7 @@ void TreeDisplaySequencer::add_seq_dup(Strip *seq, TreeElement *te, short index)
}
if (STREQ(p->data->stripdata->filename, seq->data->stripdata->filename)) {
add_element(&te->subtree, nullptr, (void *)p, te, TSE_SEQUENCE, index);
add_element(&te->subtree, nullptr, (void *)p, te, TSE_STRIP, index);
}
p = p->next;
}

16
source/blender/editors/space_outliner/tree/tree_element.cc
View File

@@ -126,14 +126,14 @@ std::unique_ptr<AbstractTreeElement> AbstractTreeElement::create_from_type(const
case TSE_RNA_ARRAY_ELEM:
return std::make_unique<TreeElementRNAArrayElement>(
legacy_te, *static_cast<PointerRNA *>(create_data), legacy_te.index);
case TSE_SEQUENCE:
return std::make_unique<TreeElementSequence>(legacy_te, *static_cast<Strip *>(create_data));
case TSE_SEQ_STRIP:
return std::make_unique<TreeElementSequenceStrip>(legacy_te,
*static_cast<StripData *>(create_data));
case TSE_SEQUENCE_DUP:
return std::make_unique<TreeElementSequenceStripDuplicate>(
legacy_te, *static_cast<Strip *>(create_data));
case TSE_STRIP:
return std::make_unique<TreeElementStrip>(legacy_te, *static_cast<Strip *>(create_data));
case TSE_STRIP_DATA:
return std::make_unique<TreeElementStripData>(legacy_te,
*static_cast<StripData *>(create_data));
case TSE_STRIP_DUP:
return std::make_unique<TreeElementStripDuplicate>(legacy_te,
*static_cast<Strip *>(create_data));
case TSE_BONE:
return std::make_unique<TreeElementBone>(
legacy_te, *owner_id, *static_cast<Bone *>(create_data));

51
source/blender/editors/space_outliner/tree/tree_element_seq.cc
View File

@@ -18,53 +18,53 @@
namespace blender::ed::outliner {
TreeElementSequence::TreeElementSequence(TreeElement &legacy_te, Strip &sequence)
: AbstractTreeElement(legacy_te), sequence_(sequence)
TreeElementStrip::TreeElementStrip(TreeElement &legacy_te, Strip &strip)
: AbstractTreeElement(legacy_te), strip_(strip)
{
BLI_assert(legacy_te.store_elem->type == TSE_SEQUENCE);
legacy_te.name = sequence_.name + 2;
BLI_assert(legacy_te.store_elem->type == TSE_STRIP);
legacy_te.name = strip_.name + 2;
}
bool TreeElementSequence::expand_poll(const SpaceOutliner & /*space_outliner*/) const
bool TreeElementStrip::expand_poll(const SpaceOutliner & /*space_outliner*/) const
{
return !(sequence_.type & SEQ_TYPE_EFFECT);
return !(strip_.type & SEQ_TYPE_EFFECT);
}
void TreeElementSequence::expand(SpaceOutliner & /*space_outliner*/) const
void TreeElementStrip::expand(SpaceOutliner & /*space_outliner*/) const
{
/*
* This work like the sequence.
* If the sequence have a name (not default name)
* This work like the strip.
* If the strip have a name (not default name)
* show it, in other case put the filename.
*/
if (sequence_.type == SEQ_TYPE_META) {
LISTBASE_FOREACH (Strip *, child, &sequence_.seqbase) {
add_element(&legacy_te_.subtree, nullptr, child, &legacy_te_, TSE_SEQUENCE, 0);
if (strip_.type == SEQ_TYPE_META) {
LISTBASE_FOREACH (Strip *, child, &strip_.seqbase) {
add_element(&legacy_te_.subtree, nullptr, child, &legacy_te_, TSE_STRIP, 0);
}
}
else {
add_element(&legacy_te_.subtree, nullptr, sequence_.data, &legacy_te_, TSE_SEQ_STRIP, 0);
add_element(&legacy_te_.subtree, nullptr, strip_.data, &legacy_te_, TSE_STRIP_DATA, 0);
}
}
Strip &TreeElementSequence::get_sequence() const
Strip &TreeElementStrip::get_strip() const
{
return sequence_;
return strip_;
}
SequenceType TreeElementSequence::get_sequence_type() const
SequenceType TreeElementStrip::get_strip_type() const
{
return SequenceType(sequence_.type);
return SequenceType(strip_.type);
}
/* -------------------------------------------------------------------- */
/* Strip */
TreeElementSequenceStrip::TreeElementSequenceStrip(TreeElement &legacy_te, StripData &data)
TreeElementStripData::TreeElementStripData(TreeElement &legacy_te, StripData &data)
: AbstractTreeElement(legacy_te)
{
BLI_assert(legacy_te.store_elem->type == TSE_SEQ_STRIP);
BLI_assert(legacy_te.store_elem->type == TSE_STRIP_DATA);
if (data.dirpath[0] != '\0') {
legacy_te_.name = data.dirpath;
@@ -77,17 +77,16 @@ TreeElementSequenceStrip::TreeElementSequenceStrip(TreeElement &legacy_te, Strip
/* -------------------------------------------------------------------- */
/* Strip Duplicate */
TreeElementSequenceStripDuplicate::TreeElementSequenceStripDuplicate(TreeElement &legacy_te,
Strip &sequence)
: AbstractTreeElement(legacy_te), sequence_(sequence)
TreeElementStripDuplicate::TreeElementStripDuplicate(TreeElement &legacy_te, Strip &strip)
: AbstractTreeElement(legacy_te), strip_(strip)
{
BLI_assert(legacy_te.store_elem->type == TSE_SEQUENCE_DUP);
legacy_te_.name = sequence.data->stripdata->filename;
BLI_assert(legacy_te.store_elem->type == TSE_STRIP_DUP);
legacy_te_.name = strip.data->stripdata->filename;
}
Strip &TreeElementSequenceStripDuplicate::get_sequence() const
Strip &TreeElementStripDuplicate::get_strip() const
{
return sequence_;
return strip_;
}
} // namespace blender::ed::outliner

22
source/blender/editors/space_outliner/tree/tree_element_seq.hh
View File

@@ -17,35 +17,35 @@ struct StripData;
namespace blender::ed::outliner {
class TreeElementSequence : public AbstractTreeElement {
Strip &sequence_;
class TreeElementStrip : public AbstractTreeElement {
Strip &strip_;
public:
TreeElementSequence(TreeElement &legacy_te, Strip &sequence);
TreeElementStrip(TreeElement &legacy_te, Strip &strip);
bool expand_poll(const SpaceOutliner &) const override;
void expand(SpaceOutliner &) const override;
Strip &get_sequence() const;
SequenceType get_sequence_type() const;
Strip &get_strip() const;
SequenceType get_strip_type() const;
};
/* -------------------------------------------------------------------- */
class TreeElementSequenceStrip : public AbstractTreeElement {
class TreeElementStripData : public AbstractTreeElement {
public:
TreeElementSequenceStrip(TreeElement &legacy_te, StripData &strip);
TreeElementStripData(TreeElement &legacy_te, StripData &strip);
};
/* -------------------------------------------------------------------- */
class TreeElementSequenceStripDuplicate : public AbstractTreeElement {
Strip &sequence_;
class TreeElementStripDuplicate : public AbstractTreeElement {
Strip &strip_;
public:
TreeElementSequenceStripDuplicate(TreeElement &legacy_te, Strip &sequence);
TreeElementStripDuplicate(TreeElement &legacy_te, Strip &strip);
Strip &get_sequence() const;
Strip &get_strip() const;
};
} // namespace blender::ed::outliner

12
source/blender/makesdna/DNA_outliner_types.h
View File

@@ -91,9 +91,9 @@ typedef enum eTreeStoreElemType {
/* TSE_LINKED_LAMP = 23, */
TSE_BONE_COLLECTION_BASE = 24,
TSE_BONE_COLLECTION = 25,
TSE_SEQUENCE = 26, /* NO ID */
TSE_SEQ_STRIP = 27, /* NO ID */
TSE_SEQUENCE_DUP = 28, /* NO ID */
TSE_STRIP = 26, /* NO ID */
TSE_STRIP_DATA = 27, /* NO ID */
TSE_STRIP_DUP = 28, /* NO ID */
TSE_LINKED_PSYS = 29,
TSE_RNA_STRUCT = 30, /* NO ID */
TSE_RNA_PROPERTY = 31, /* NO ID */
@@ -123,9 +123,9 @@ typedef enum eTreeStoreElemType {
TSE_NLA, \
TSE_NLA_TRACK, \
TSE_DRIVER_BASE, \
TSE_SEQUENCE, \
TSE_SEQ_STRIP, \
TSE_SEQUENCE_DUP, \
TSE_STRIP, \
TSE_STRIP_DATA, \
TSE_STRIP_DUP, \
TSE_RNA_STRUCT, \
TSE_RNA_PROPERTY, \
TSE_RNA_ARRAY_ELEM, \