Differential D16551 Diff 58560 source/blender/makesrna/intern/rna_sequencer.cc

Changeset View

Standalone View

source/blender/makesrna/intern/rna_sequencer.cc

This file was moved from source/blender/makesrna/intern/rna_sequencer.c.

Show First 20 Lines • Show All 103 Lines • ▼ Show 20 Lines
typedef struct SequenceSearchData {		typedef struct SequenceSearchData {
Sequence *seq;		Sequence *seq;
void *data;		void *data;
SequenceModifierData *smd;		SequenceModifierData *smd;
} SequenceSearchData;		} SequenceSearchData;

static void rna_SequenceElement_update(Main UNUSED(bmain), Scene UNUSED(scene), PointerRNA *ptr)		static void rna_SequenceElement_update(Main UNUSED(bmain), Scene UNUSED(scene), PointerRNA *ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);

if (ed) {		if (ed) {
StripElem se = (StripElem )ptr->data;		StripElem se = static_cast<StripElem >(ptr->data);
Sequence *seq;		Sequence *seq;

/* slow but we can't avoid! */		/* slow but we can't avoid! */
seq = SEQ_sequence_from_strip_elem(&ed->seqbase, se);		seq = SEQ_sequence_from_strip_elem(&ed->seqbase, se);
if (seq) {		if (seq) {
SEQ_relations_invalidate_cache_raw(scene, seq);		SEQ_relations_invalidate_cache_raw(scene, seq);
}		}
}		}
}		}

static void rna_Sequence_invalidate_raw_update(Main *UNUSED(bmain),		static void rna_Sequence_invalidate_raw_update(Main *UNUSED(bmain),
Scene *UNUSED(scene),		Scene *UNUSED(scene),
PointerRNA *ptr)		PointerRNA *ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);

if (ed) {		if (ed) {
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);

SEQ_relations_invalidate_cache_raw(scene, seq);		SEQ_relations_invalidate_cache_raw(scene, seq);
}		}
}		}

static void rna_Sequence_invalidate_preprocessed_update(Main *UNUSED(bmain),		static void rna_Sequence_invalidate_preprocessed_update(Main *UNUSED(bmain),
Scene *UNUSED(scene),		Scene *UNUSED(scene),
PointerRNA *ptr)		PointerRNA *ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);

if (ed) {		if (ed) {
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);

SEQ_relations_invalidate_cache_preprocessed(scene, seq);		SEQ_relations_invalidate_cache_preprocessed(scene, seq);
}		}
}		}

static void UNUSED_FUNCTION(rna_Sequence_invalidate_composite_update)(Main *UNUSED(bmain),		static void UNUSED_FUNCTION(rna_Sequence_invalidate_composite_update)(Main *UNUSED(bmain),
Scene *UNUSED(scene),		Scene *UNUSED(scene),
PointerRNA *ptr)		PointerRNA *ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);

if (ed) {		if (ed) {
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);

SEQ_relations_invalidate_cache_composite(scene, seq);		SEQ_relations_invalidate_cache_composite(scene, seq);
}		}
}		}

static void rna_Sequence_scene_switch_update(Main bmain, Scene scene, PointerRNA *ptr)		static void rna_Sequence_scene_switch_update(Main bmain, Scene scene, PointerRNA *ptr)
{		{
rna_Sequence_invalidate_raw_update(bmain, scene, ptr);		rna_Sequence_invalidate_raw_update(bmain, scene, ptr);
DEG_id_tag_update(&scene->id, ID_RECALC_AUDIO \| ID_RECALC_SEQUENCER_STRIPS);		DEG_id_tag_update(&scene->id, ID_RECALC_AUDIO \| ID_RECALC_SEQUENCER_STRIPS);
DEG_relations_tag_update(bmain);		DEG_relations_tag_update(bmain);
}		}

static void rna_Sequence_use_sequence(Main bmain, Scene scene, PointerRNA *ptr)		static void rna_Sequence_use_sequence(Main bmain, Scene scene, PointerRNA *ptr)
{		{
/* General update callback. */		/* General update callback. */
rna_Sequence_invalidate_raw_update(bmain, scene, ptr);		rna_Sequence_invalidate_raw_update(bmain, scene, ptr);
/* Changing recursion changes set of IDs which needs to be remapped by the copy-on-write.		/* Changing recursion changes set of IDs which needs to be remapped by the copy-on-write.
* the only way for this currently is to tag the ID for ID_RECALC_COPY_ON_WRITE. */		* the only way for this currently is to tag the ID for ID_RECALC_COPY_ON_WRITE. */
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);
if (ed) {		if (ed) {
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
if (seq->scene != NULL) {		if (seq->scene != NULL) {
DEG_id_tag_update(&seq->scene->id, ID_RECALC_COPY_ON_WRITE);		DEG_id_tag_update(&seq->scene->id, ID_RECALC_COPY_ON_WRITE);
}		}
}		}
/* The sequencer scene is to be updated as well, including new relations from the nested		/* The sequencer scene is to be updated as well, including new relations from the nested
* sequencer. */		* sequencer. */
DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);		DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);
DEG_relations_tag_update(bmain);		DEG_relations_tag_update(bmain);
}		}

static void rna_SequenceEditor_sequences_all_begin(CollectionPropertyIterator *iter,		static void rna_SequenceEditor_sequences_all_begin(CollectionPropertyIterator *iter,
PointerRNA *ptr)		PointerRNA *ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);
SeqCollection *all_strips = SEQ_query_all_strips_recursive(&ed->seqbase);		SeqCollection *all_strips = SEQ_query_all_strips_recursive(&ed->seqbase);

BLI_Iterator *bli_iter = MEM_callocN(sizeof(BLI_Iterator), __func__);		BLI_Iterator bli_iter = static_cast<BLI_Iterator >(
		MEM_callocN(sizeof(BLI_Iterator), __func__));
bli_iter->data = MEM_callocN(sizeof(SeqIterator), __func__);		bli_iter->data = MEM_callocN(sizeof(SeqIterator), __func__);
iter->internal.custom = bli_iter;		iter->internal.custom = bli_iter;

if (!SEQ_iterator_ensure(all_strips, bli_iter->data, (Sequence **)&bli_iter->current)) {		if (!SEQ_iterator_ensure(all_strips,
		static_cast<SeqIterator *>(bli_iter->data),
		static_cast<Sequence **>(bli_iter->current))) {
SEQ_collection_free(all_strips);		SEQ_collection_free(all_strips);
}		}

iter->valid = bli_iter->current != NULL;		iter->valid = bli_iter->current != NULL;
}		}

static void rna_SequenceEditor_sequences_all_next(CollectionPropertyIterator *iter)		static void rna_SequenceEditor_sequences_all_next(CollectionPropertyIterator *iter)
{		{
BLI_Iterator *bli_iter = iter->internal.custom;		BLI_Iterator bli_iter = static_cast<BLI_Iterator >(iter->internal.custom);
bli_iter->current = SEQ_iterator_yield(bli_iter->data);		bli_iter->current = SEQ_iterator_yield(static_cast<SeqIterator *>(bli_iter->data));
iter->valid = bli_iter->current != NULL;		iter->valid = bli_iter->current != NULL;
}		}

static PointerRNA rna_SequenceEditor_sequences_all_get(CollectionPropertyIterator *iter)		static PointerRNA rna_SequenceEditor_sequences_all_get(CollectionPropertyIterator *iter)
{		{
Sequence seq = ((BLI_Iterator )iter->internal.custom)->current;		Sequence seq = static_cast<Sequence >(
		static_cast<BLI_Iterator *>(iter->internal.custom)->current);
return rna_pointer_inherit_refine(&iter->parent, &RNA_Sequence, seq);		return rna_pointer_inherit_refine(&iter->parent, &RNA_Sequence, seq);
}		}

static void rna_SequenceEditor_sequences_all_end(CollectionPropertyIterator *iter)		static void rna_SequenceEditor_sequences_all_end(CollectionPropertyIterator *iter)
{		{
BLI_Iterator *bli_iter = iter->internal.custom;		BLI_Iterator bli_iter = static_cast<BLI_Iterator >(iter->internal.custom);
SeqIterator *seq_iter = bli_iter->data;		SeqIterator seq_iter = static_cast<SeqIterator >(bli_iter->data);
if (seq_iter->collection != NULL) {		if (seq_iter->collection != NULL) {
SEQ_collection_free(seq_iter->collection);		SEQ_collection_free(seq_iter->collection);
}		}
MEM_freeN(seq_iter);		MEM_freeN(seq_iter);
MEM_freeN(bli_iter);		MEM_freeN(bli_iter);
}		}

static int rna_SequenceEditor_sequences_all_lookup_string(PointerRNA *ptr,		static int rna_SequenceEditor_sequences_all_lookup_string(PointerRNA *ptr,
const char *key,		const char *key,
PointerRNA *r_ptr)		PointerRNA *r_ptr)
{		{
ID *id = ptr->owner_id;		ID *id = ptr->owner_id;
Scene scene = (Scene )id;		Scene scene = reinterpret_cast<Scene >(id);

Sequence *seq = SEQ_sequence_lookup_seq_by_name(scene, key);		Sequence *seq = SEQ_sequence_lookup_seq_by_name(scene, key);
if (seq) {		if (seq) {
RNA_pointer_create(ptr->owner_id, &RNA_Sequence, seq, r_ptr);		RNA_pointer_create(ptr->owner_id, &RNA_Sequence, seq, r_ptr);
return true;		return true;
}		}
return false;		return false;
}		}

static void rna_SequenceEditor_update_cache(Main *UNUSED(bmain),		static void rna_SequenceEditor_update_cache(Main *UNUSED(bmain),
Scene *scene,		Scene *scene,
PointerRNA *UNUSED(ptr))		PointerRNA *UNUSED(ptr))
{		{
Editing *ed = scene->ed;		Editing *ed = scene->ed;

SEQ_relations_free_imbuf(scene, &ed->seqbase, false);		SEQ_relations_free_imbuf(scene, &ed->seqbase, false);
SEQ_cache_cleanup(scene);		SEQ_cache_cleanup(scene);
}		}

/* internal use */		/* internal use */
static int rna_SequenceEditor_elements_length(PointerRNA *ptr)		static int rna_SequenceEditor_elements_length(PointerRNA *ptr)
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);

/* Hack? copied from sequencer.c::reload_sequence_new_file() */		/* Hack? copied from sequencer.c::reload_sequence_new_file() */
size_t olen = MEM_allocN_len(seq->strip->stripdata) / sizeof(struct StripElem);		size_t olen = MEM_allocN_len(seq->strip->stripdata) / sizeof(struct StripElem);

/* The problem with seq->strip->len and seq->len is that it's discounted from the offset		/* The problem with seq->strip->len and seq->len is that it's discounted from the offset
* (hard cut trim). */		* (hard cut trim). */
return (int)olen;		return (int)olen;
}		}

static void rna_SequenceEditor_elements_begin(CollectionPropertyIterator iter, PointerRNA ptr)		static void rna_SequenceEditor_elements_begin(CollectionPropertyIterator iter, PointerRNA ptr)
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
rna_iterator_array_begin(iter,		rna_iterator_array_begin(iter,
(void *)seq->strip->stripdata,		static_cast<void *>(seq->strip->stripdata),
sizeof(StripElem),		sizeof(StripElem),
rna_SequenceEditor_elements_length(ptr),		rna_SequenceEditor_elements_length(ptr),
0,		0,
NULL);		NULL);
}		}

static void rna_Sequence_views_format_update(Main bmain, Scene scene, PointerRNA *ptr)		static void rna_Sequence_views_format_update(Main bmain, Scene scene, PointerRNA *ptr)
{		{
Show All 15 Lines

/* A simple wrapper around above func, directly usable as prop update func.		/* A simple wrapper around above func, directly usable as prop update func.
* Also invalidate cache if needed.		* Also invalidate cache if needed.
*/		*/
static void rna_Sequence_frame_change_update(Main *UNUSED(bmain),		static void rna_Sequence_frame_change_update(Main *UNUSED(bmain),
Scene *UNUSED(scene),		Scene *UNUSED(scene),
PointerRNA *ptr)		PointerRNA *ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
do_sequence_frame_change_update(scene, (Sequence *)ptr->data);		do_sequence_frame_change_update(scene, static_cast<Sequence *>(ptr->data));
}		}

static int rna_Sequence_frame_final_start_get(PointerRNA *ptr)		static int rna_Sequence_frame_final_start_get(PointerRNA *ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
return SEQ_time_left_handle_frame_get(scene, (Sequence *)ptr->data);		return SEQ_time_left_handle_frame_get(scene, static_cast<Sequence *>(ptr->data));
}		}

static int rna_Sequence_frame_final_end_get(PointerRNA *ptr)		static int rna_Sequence_frame_final_end_get(PointerRNA *ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
return SEQ_time_right_handle_frame_get(scene, (Sequence *)ptr->data);		return SEQ_time_right_handle_frame_get(scene, static_cast<Sequence *>(ptr->data));
}		}

static void rna_Sequence_start_frame_final_set(PointerRNA *ptr, int value)		static void rna_Sequence_start_frame_final_set(PointerRNA *ptr, int value)
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);

SEQ_time_left_handle_frame_set(scene, seq, value);		SEQ_time_left_handle_frame_set(scene, seq, value);
do_sequence_frame_change_update(scene, seq);		do_sequence_frame_change_update(scene, seq);
SEQ_relations_invalidate_cache_composite(scene, seq);		SEQ_relations_invalidate_cache_composite(scene, seq);
}		}

static void rna_Sequence_end_frame_final_set(PointerRNA *ptr, int value)		static void rna_Sequence_end_frame_final_set(PointerRNA *ptr, int value)
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);

SEQ_time_right_handle_frame_set(scene, seq, value);		SEQ_time_right_handle_frame_set(scene, seq, value);
do_sequence_frame_change_update(scene, seq);		do_sequence_frame_change_update(scene, seq);
SEQ_relations_invalidate_cache_composite(scene, seq);		SEQ_relations_invalidate_cache_composite(scene, seq);
}		}

static void rna_Sequence_start_frame_set(PointerRNA *ptr, float value)		static void rna_Sequence_start_frame_set(PointerRNA *ptr, float value)
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);

SEQ_transform_translate_sequence(scene, seq, value - seq->start);		SEQ_transform_translate_sequence(scene, seq, value - seq->start);
do_sequence_frame_change_update(scene, seq);		do_sequence_frame_change_update(scene, seq);
SEQ_relations_invalidate_cache_composite(scene, seq);		SEQ_relations_invalidate_cache_composite(scene, seq);
}		}

static void rna_Sequence_frame_offset_start_set(PointerRNA *ptr, float value)		static void rna_Sequence_frame_offset_start_set(PointerRNA *ptr, float value)
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);

SEQ_relations_invalidate_cache_composite(scene, seq);		SEQ_relations_invalidate_cache_composite(scene, seq);
seq->startofs = value;		seq->startofs = value;
}		}

static void rna_Sequence_frame_offset_end_set(PointerRNA *ptr, float value)		static void rna_Sequence_frame_offset_end_set(PointerRNA *ptr, float value)
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);

SEQ_relations_invalidate_cache_composite(scene, seq);		SEQ_relations_invalidate_cache_composite(scene, seq);
seq->endofs = value;		seq->endofs = value;
}		}

static void rna_Sequence_anim_startofs_final_set(PointerRNA *ptr, int value)		static void rna_Sequence_anim_startofs_final_set(PointerRNA *ptr, int value)
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);

seq->anim_startofs = MIN2(value, seq->len + seq->anim_startofs);		seq->anim_startofs = MIN2(value, seq->len + seq->anim_startofs);

SEQ_add_reload_new_file(G.main, scene, seq, false);		SEQ_add_reload_new_file(G.main, scene, seq, false);
do_sequence_frame_change_update(scene, seq);		do_sequence_frame_change_update(scene, seq);
}		}

static void rna_Sequence_anim_endofs_final_set(PointerRNA *ptr, int value)		static void rna_Sequence_anim_endofs_final_set(PointerRNA *ptr, int value)
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);

seq->anim_endofs = MIN2(value, seq->len + seq->anim_endofs);		seq->anim_endofs = MIN2(value, seq->len + seq->anim_endofs);

SEQ_add_reload_new_file(G.main, scene, seq, false);		SEQ_add_reload_new_file(G.main, scene, seq, false);
do_sequence_frame_change_update(scene, seq);		do_sequence_frame_change_update(scene, seq);
}		}

static void rna_Sequence_anim_endofs_final_range(		static void rna_Sequence_anim_endofs_final_range(
PointerRNA ptr, int min, int max, int UNUSED(softmin), int *UNUSED(softmax))		PointerRNA ptr, int min, int max, int UNUSED(softmin), int *UNUSED(softmax))
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);

*min = 0;		*min = 0;
*max = seq->len + seq->anim_endofs - seq->startofs - seq->endofs - 1;		*max = seq->len + seq->anim_endofs - seq->startofs - seq->endofs - 1;
}		}

static void rna_Sequence_anim_startofs_final_range(		static void rna_Sequence_anim_startofs_final_range(
PointerRNA ptr, int min, int max, int UNUSED(softmin), int *UNUSED(softmax))		PointerRNA ptr, int min, int max, int UNUSED(softmin), int *UNUSED(softmax))
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);

*min = 0;		*min = 0;
*max = seq->len + seq->anim_startofs - seq->startofs - seq->endofs - 1;		*max = seq->len + seq->anim_startofs - seq->startofs - seq->endofs - 1;
}		}

static void rna_Sequence_frame_offset_start_range(		static void rna_Sequence_frame_offset_start_range(
PointerRNA ptr, float min, float max, float UNUSED(softmin), float *UNUSED(softmax))		PointerRNA ptr, float min, float max, float UNUSED(softmin), float *UNUSED(softmax))
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
*min = ELEM(seq->type, SEQ_TYPE_SOUND_RAM, SEQ_TYPE_SOUND_HD) ? 0 : INT_MIN;		*min = ELEM(seq->type, SEQ_TYPE_SOUND_RAM, SEQ_TYPE_SOUND_HD) ? 0 : INT_MIN;
*max = seq->len - seq->endofs - 1;		*max = seq->len - seq->endofs - 1;
}		}

static void rna_Sequence_frame_offset_end_range(		static void rna_Sequence_frame_offset_end_range(
PointerRNA ptr, float min, float max, float UNUSED(softmin), float *UNUSED(softmax))		PointerRNA ptr, float min, float max, float UNUSED(softmin), float *UNUSED(softmax))
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
*min = ELEM(seq->type, SEQ_TYPE_SOUND_RAM, SEQ_TYPE_SOUND_HD) ? 0 : INT_MIN;		*min = ELEM(seq->type, SEQ_TYPE_SOUND_RAM, SEQ_TYPE_SOUND_HD) ? 0 : INT_MIN;
*max = seq->len - seq->startofs - 1;		*max = seq->len - seq->startofs - 1;
}		}

static void rna_Sequence_frame_length_set(PointerRNA *ptr, int value)		static void rna_Sequence_frame_length_set(PointerRNA *ptr, int value)
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);

SEQ_time_right_handle_frame_set(scene, seq, SEQ_time_left_handle_frame_get(scene, seq) + value);		SEQ_time_right_handle_frame_set(scene, seq, SEQ_time_left_handle_frame_get(scene, seq) + value);
do_sequence_frame_change_update(scene, seq);		do_sequence_frame_change_update(scene, seq);
SEQ_relations_invalidate_cache_composite(scene, seq);		SEQ_relations_invalidate_cache_composite(scene, seq);
}		}

static int rna_Sequence_frame_length_get(PointerRNA *ptr)		static int rna_Sequence_frame_length_get(PointerRNA *ptr)
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
return SEQ_time_right_handle_frame_get(scene, seq) - SEQ_time_left_handle_frame_get(scene, seq);		return SEQ_time_right_handle_frame_get(scene, seq) - SEQ_time_left_handle_frame_get(scene, seq);
}		}

static int rna_Sequence_frame_editable(PointerRNA ptr, const char *UNUSED(r_info))		static int rna_Sequence_frame_editable(PointerRNA ptr, const char *UNUSED(r_info))
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
/* Effect sequences' start frame and length must be readonly! */		/* Effect sequences' start frame and length must be readonly! */
return (SEQ_effect_get_num_inputs(seq->type)) ? 0 : PROP_EDITABLE;		return (SEQ_effect_get_num_inputs(seq->type)) ? PropertyFlag(0) : PROP_EDITABLE;
}		}

static void rna_Sequence_channel_set(PointerRNA *ptr, int value)		static void rna_Sequence_channel_set(PointerRNA *ptr, int value)
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
ListBase *seqbase = SEQ_get_seqbase_by_seq(scene, seq);		ListBase *seqbase = SEQ_get_seqbase_by_seq(scene, seq);

/* check channel increment or decrement */		/* check channel increment or decrement */
const int channel_delta = (value >= seq->machine) ? 1 : -1;		const int channel_delta = (value >= seq->machine) ? 1 : -1;
seq->machine = value;		seq->machine = value;

if (SEQ_transform_test_overlap(scene, seqbase, seq)) {		if (SEQ_transform_test_overlap(scene, seqbase, seq)) {
SEQ_transform_seqbase_shuffle_ex(seqbase, seq, scene, channel_delta);		SEQ_transform_seqbase_shuffle_ex(seqbase, seq, scene, channel_delta);
}		}
SEQ_relations_invalidate_cache_composite(scene, seq);		SEQ_relations_invalidate_cache_composite(scene, seq);
}		}

static void rna_Sequence_use_proxy_set(PointerRNA *ptr, bool value)		static void rna_Sequence_use_proxy_set(PointerRNA *ptr, bool value)
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
SEQ_proxy_set(seq, value != 0);		SEQ_proxy_set(seq, value != 0);
}		}

static bool transform_seq_cmp_fn(Sequence seq, void arg_pt)		static bool transform_seq_cmp_fn(Sequence seq, void arg_pt)
{		{
SequenceSearchData *data = arg_pt;		SequenceSearchData data = static_cast<SequenceSearchData >(arg_pt);

if (seq->strip && seq->strip->transform == data->data) {		if (seq->strip && seq->strip->transform == data->data) {
data->seq = seq;		data->seq = seq;
return false; /* done so bail out */		return false; /* done so bail out */
}		}
return true;		return true;
}		}

static Sequence sequence_get_by_transform(Editing ed, StripTransform *transform)		static Sequence sequence_get_by_transform(Editing ed, StripTransform *transform)
{		{
SequenceSearchData data;		SequenceSearchData data;

data.seq = NULL;		data.seq = NULL;
data.data = transform;		data.data = transform;

/* irritating we need to search for our sequence! */		/* irritating we need to search for our sequence! */
SEQ_for_each_callback(&ed->seqbase, transform_seq_cmp_fn, &data);		SEQ_for_each_callback(&ed->seqbase, transform_seq_cmp_fn, &data);

return data.seq;		return data.seq;
}		}

static char rna_SequenceTransform_path(const PointerRNA ptr)		static char rna_SequenceTransform_path(const PointerRNA ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);
Sequence *seq = sequence_get_by_transform(ed, ptr->data);		Sequence seq = sequence_get_by_transform(ed, static_cast<StripTransform >(ptr->data));

if (seq) {		if (seq) {
char name_esc[(sizeof(seq->name) - 2) * 2];		char name_esc[(sizeof(seq->name) - 2) * 2];

BLI_str_escape(name_esc, seq->name + 2, sizeof(name_esc));		BLI_str_escape(name_esc, seq->name + 2, sizeof(name_esc));
return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"].transform", name_esc);		return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"].transform", name_esc);
}		}
else {		else {
return BLI_strdup("");		return BLI_strdup("");
}		}
}		}

static void rna_SequenceTransform_update(Main *UNUSED(bmain),		static void rna_SequenceTransform_update(Main *UNUSED(bmain),
Scene *UNUSED(scene),		Scene *UNUSED(scene),
PointerRNA *ptr)		PointerRNA *ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);
Sequence *seq = sequence_get_by_transform(ed, ptr->data);		Sequence seq = sequence_get_by_transform(ed, static_cast<StripTransform >(ptr->data));

SEQ_relations_invalidate_cache_preprocessed(scene, seq);		SEQ_relations_invalidate_cache_preprocessed(scene, seq);
}		}

static bool crop_seq_cmp_fn(Sequence seq, void arg_pt)		static bool crop_seq_cmp_fn(Sequence seq, void arg_pt)
{		{
SequenceSearchData *data = arg_pt;		SequenceSearchData data = static_cast<SequenceSearchData >(arg_pt);

if (seq->strip && seq->strip->crop == data->data) {		if (seq->strip && seq->strip->crop == data->data) {
data->seq = seq;		data->seq = seq;
return false; /* done so bail out */		return false; /* done so bail out */
}		}
return true;		return true;
}		}

static Sequence sequence_get_by_crop(Editing ed, StripCrop *crop)		static Sequence sequence_get_by_crop(Editing ed, StripCrop *crop)
{		{
SequenceSearchData data;		SequenceSearchData data;

data.seq = NULL;		data.seq = NULL;
data.data = crop;		data.data = crop;

/* irritating we need to search for our sequence! */		/* irritating we need to search for our sequence! */
SEQ_for_each_callback(&ed->seqbase, crop_seq_cmp_fn, &data);		SEQ_for_each_callback(&ed->seqbase, crop_seq_cmp_fn, &data);

return data.seq;		return data.seq;
}		}

static char rna_SequenceCrop_path(const PointerRNA ptr)		static char rna_SequenceCrop_path(const PointerRNA ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);
Sequence *seq = sequence_get_by_crop(ed, ptr->data);		Sequence seq = sequence_get_by_crop(ed, static_cast<StripCrop >(ptr->data));

if (seq) {		if (seq) {
char name_esc[(sizeof(seq->name) - 2) * 2];		char name_esc[(sizeof(seq->name) - 2) * 2];

BLI_str_escape(name_esc, seq->name + 2, sizeof(name_esc));		BLI_str_escape(name_esc, seq->name + 2, sizeof(name_esc));
return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"].crop", name_esc);		return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"].crop", name_esc);
}		}
else {		else {
return BLI_strdup("");		return BLI_strdup("");
}		}
}		}

static void rna_SequenceCrop_update(Main UNUSED(bmain), Scene UNUSED(scene), PointerRNA *ptr)		static void rna_SequenceCrop_update(Main UNUSED(bmain), Scene UNUSED(scene), PointerRNA *ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);
Sequence *seq = sequence_get_by_crop(ed, ptr->data);		Sequence seq = sequence_get_by_crop(ed, static_cast<StripCrop >(ptr->data));

SEQ_relations_invalidate_cache_preprocessed(scene, seq);		SEQ_relations_invalidate_cache_preprocessed(scene, seq);
}		}

static void rna_Sequence_text_font_set(PointerRNA *ptr,		static void rna_Sequence_text_font_set(PointerRNA *ptr,
PointerRNA ptr_value,		PointerRNA ptr_value,
struct ReportList *UNUSED(reports))		struct ReportList *UNUSED(reports))
{		{
Sequence *seq = ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
TextVars *data = seq->effectdata;		TextVars data = static_cast<TextVars >(seq->effectdata);
VFont *value = ptr_value.data;		VFont value = static_cast<VFont >(ptr_value.data);

SEQ_effect_text_font_unload(data, true);		SEQ_effect_text_font_unload(data, true);

id_us_plus(&value->id);		id_us_plus(&value->id);
data->text_blf_id = SEQ_FONT_NOT_LOADED;		data->text_blf_id = SEQ_FONT_NOT_LOADED;
data->text_font = value;		data->text_font = value;
}		}

/* name functions that ignore the first two characters */		/* name functions that ignore the first two characters */
static void rna_Sequence_name_get(PointerRNA ptr, char value)		static void rna_Sequence_name_get(PointerRNA ptr, char value)
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
BLI_strncpy(value, seq->name + 2, sizeof(seq->name) - 2);		BLI_strncpy(value, seq->name + 2, sizeof(seq->name) - 2);
}		}

static int rna_Sequence_name_length(PointerRNA *ptr)		static int rna_Sequence_name_length(PointerRNA *ptr)
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
return strlen(seq->name + 2);		return strlen(seq->name + 2);
}		}

static void rna_Sequence_name_set(PointerRNA ptr, const char value)		static void rna_Sequence_name_set(PointerRNA ptr, const char value)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
char oldname[sizeof(seq->name)];		char oldname[sizeof(seq->name)];
AnimData *adt;		AnimData *adt;

SEQ_prefetch_stop(scene);		SEQ_prefetch_stop(scene);

/* make a copy of the old name first */		/* make a copy of the old name first */
BLI_strncpy(oldname, seq->name + 2, sizeof(seq->name) - 2);		BLI_strncpy(oldname, seq->name + 2, sizeof(seq->name) - 2);

Show All 12 Lines	# endif
if (adt) {		if (adt) {
BKE_animdata_fix_paths_rename(		BKE_animdata_fix_paths_rename(
&scene->id, adt, NULL, "sequence_editor.sequences_all", oldname, seq->name + 2, 0, 0, 1);		&scene->id, adt, NULL, "sequence_editor.sequences_all", oldname, seq->name + 2, 0, 0, 1);
}		}
}		}

static StructRNA rna_Sequence_refine(struct PointerRNA ptr)		static StructRNA rna_Sequence_refine(struct PointerRNA ptr)
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);

switch (seq->type) {		switch (seq->type) {
case SEQ_TYPE_IMAGE:		case SEQ_TYPE_IMAGE:
return &RNA_ImageSequence;		return &RNA_ImageSequence;
case SEQ_TYPE_META:		case SEQ_TYPE_META:
return &RNA_MetaSequence;		return &RNA_MetaSequence;
case SEQ_TYPE_SCENE:		case SEQ_TYPE_SCENE:
return &RNA_SceneSequence;		return &RNA_SceneSequence;
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines	case SEQ_TYPE_COLORMIX:
return &RNA_ColorMixSequence;		return &RNA_ColorMixSequence;
default:		default:
return &RNA_Sequence;		return &RNA_Sequence;
}		}
}		}

static char rna_Sequence_path(const PointerRNA ptr)		static char rna_Sequence_path(const PointerRNA ptr)
{		{
const Sequence seq = (Sequence )ptr->data;		const Sequence seq = static_cast<Sequence >(ptr->data);

/* sequencer data comes from scene...		/* sequencer data comes from scene...
* TODO: would be nice to make SequenceEditor data a data-block of its own (for shorter paths)		* TODO: would be nice to make SequenceEditor data a data-block of its own (for shorter paths)
*/		*/
char name_esc[(sizeof(seq->name) - 2) * 2];		char name_esc[(sizeof(seq->name) - 2) * 2];

BLI_str_escape(name_esc, seq->name + 2, sizeof(name_esc));		BLI_str_escape(name_esc, seq->name + 2, sizeof(name_esc));
return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"]", name_esc);		return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"]", name_esc);
}		}

static IDProperty *rna_Sequence_idprops(PointerRNA ptr)		static IDProperty *rna_Sequence_idprops(PointerRNA ptr)
{		{
Sequence *seq = ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
return &seq->prop;		return &seq->prop;
}		}

static bool rna_MovieSequence_reload_if_needed(ID scene_id, Sequence seq, Main *bmain)		static bool rna_MovieSequence_reload_if_needed(ID scene_id, Sequence seq, Main *bmain)
{		{
Scene scene = (Scene )scene_id;		Scene scene = reinterpret_cast<Scene >(scene_id);

bool has_reloaded;		bool has_reloaded;
bool can_produce_frames;		bool can_produce_frames;

SEQ_add_movie_reload_if_needed(bmain, scene, seq, &has_reloaded, &can_produce_frames);		SEQ_add_movie_reload_if_needed(bmain, scene, seq, &has_reloaded, &can_produce_frames);

if (has_reloaded && can_produce_frames) {		if (has_reloaded && can_produce_frames) {
SEQ_relations_invalidate_cache_raw(scene, seq);		SEQ_relations_invalidate_cache_raw(scene, seq);

DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);		DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);
WM_main_add_notifier(NC_SCENE \| ND_SEQUENCER, scene);		WM_main_add_notifier(NC_SCENE \| ND_SEQUENCER, scene);
}		}

return can_produce_frames;		return can_produce_frames;
}		}

static PointerRNA rna_MovieSequence_metadata_get(Sequence *seq)		static PointerRNA rna_MovieSequence_metadata_get(Sequence *seq)
{		{
if (seq == NULL \|\| seq->anims.first == NULL) {		if (seq == NULL \|\| seq->anims.first == NULL) {
return PointerRNA_NULL;		return PointerRNA_NULL;
}		}

StripAnim *sanim = seq->anims.first;		StripAnim sanim = static_cast<StripAnim >(seq->anims.first);
if (sanim->anim == NULL) {		if (sanim->anim == NULL) {
return PointerRNA_NULL;		return PointerRNA_NULL;
}		}

IDProperty *metadata = IMB_anim_load_metadata(sanim->anim);		IDProperty *metadata = IMB_anim_load_metadata(sanim->anim);
if (metadata == NULL) {		if (metadata == NULL) {
return PointerRNA_NULL;		return PointerRNA_NULL;
}		}

PointerRNA ptr;		PointerRNA ptr;
RNA_pointer_create(NULL, &RNA_IDPropertyWrapPtr, metadata, &ptr);		RNA_pointer_create(NULL, &RNA_IDPropertyWrapPtr, metadata, &ptr);
return ptr;		return ptr;
}		}

static PointerRNA rna_SequenceEditor_meta_stack_get(CollectionPropertyIterator *iter)		static PointerRNA rna_SequenceEditor_meta_stack_get(CollectionPropertyIterator *iter)
{		{
ListBaseIterator *internal = &iter->internal.listbase;		ListBaseIterator *internal = &iter->internal.listbase;
MetaStack ms = (MetaStack )internal->link;		MetaStack ms = reinterpret_cast<MetaStack >(internal->link);

return rna_pointer_inherit_refine(&iter->parent, &RNA_Sequence, ms->parseq);		return rna_pointer_inherit_refine(&iter->parent, &RNA_Sequence, ms->parseq);
}		}

/* TODO: expose seq path setting as a higher level sequencer BKE function. */		/* TODO: expose seq path setting as a higher level sequencer BKE function. */
static void rna_Sequence_filepath_set(PointerRNA ptr, const char value)		static void rna_Sequence_filepath_set(PointerRNA ptr, const char value)
{		{
Sequence seq = (Sequence )(ptr->data);		Sequence seq = static_cast<Sequence >(ptr->data);
BLI_split_dirfile(value,		BLI_split_dirfile(value,
seq->strip->dir,		seq->strip->dir,
seq->strip->stripdata->name,		seq->strip->stripdata->name,
sizeof(seq->strip->dir),		sizeof(seq->strip->dir),
sizeof(seq->strip->stripdata->name));		sizeof(seq->strip->stripdata->name));
}		}

static void rna_Sequence_filepath_get(PointerRNA ptr, char value)		static void rna_Sequence_filepath_get(PointerRNA ptr, char value)
{		{
Sequence seq = (Sequence )(ptr->data);		Sequence seq = static_cast<Sequence >(ptr->data);

BLI_path_join(value, FILE_MAX, seq->strip->dir, seq->strip->stripdata->name);		BLI_path_join(value, FILE_MAX, seq->strip->dir, seq->strip->stripdata->name);
}		}

static int rna_Sequence_filepath_length(PointerRNA *ptr)		static int rna_Sequence_filepath_length(PointerRNA *ptr)
{		{
Sequence seq = (Sequence )(ptr->data);		Sequence seq = static_cast<Sequence >(ptr->data);
char path[FILE_MAX];		char path[FILE_MAX];

BLI_path_join(path, sizeof(path), seq->strip->dir, seq->strip->stripdata->name);		BLI_path_join(path, sizeof(path), seq->strip->dir, seq->strip->stripdata->name);
return strlen(path);		return strlen(path);
}		}

static void rna_Sequence_proxy_filepath_set(PointerRNA ptr, const char value)		static void rna_Sequence_proxy_filepath_set(PointerRNA ptr, const char value)
{		{
StripProxy proxy = (StripProxy )(ptr->data);		StripProxy proxy = static_cast<StripProxy >(ptr->data);
BLI_split_dirfile(value, proxy->dir, proxy->file, sizeof(proxy->dir), sizeof(proxy->file));		BLI_split_dirfile(value, proxy->dir, proxy->file, sizeof(proxy->dir), sizeof(proxy->file));
if (proxy->anim) {		if (proxy->anim) {
IMB_free_anim(proxy->anim);		IMB_free_anim(proxy->anim);
proxy->anim = NULL;		proxy->anim = NULL;
}		}
}		}

static void rna_Sequence_proxy_filepath_get(PointerRNA ptr, char value)		static void rna_Sequence_proxy_filepath_get(PointerRNA ptr, char value)
{		{
StripProxy proxy = (StripProxy )(ptr->data);		StripProxy proxy = static_cast<StripProxy >(ptr->data);

BLI_path_join(value, FILE_MAX, proxy->dir, proxy->file);		BLI_path_join(value, FILE_MAX, proxy->dir, proxy->file);
}		}

static int rna_Sequence_proxy_filepath_length(PointerRNA *ptr)		static int rna_Sequence_proxy_filepath_length(PointerRNA *ptr)
{		{
StripProxy proxy = (StripProxy )(ptr->data);		StripProxy proxy = static_cast<StripProxy >(ptr->data);
char path[FILE_MAX];		char path[FILE_MAX];

BLI_path_join(path, sizeof(path), proxy->dir, proxy->file);		BLI_path_join(path, sizeof(path), proxy->dir, proxy->file);
return strlen(path);		return strlen(path);
}		}

static void rna_Sequence_audio_update(Main UNUSED(bmain), Scene UNUSED(scene), PointerRNA *ptr)		static void rna_Sequence_audio_update(Main UNUSED(bmain), Scene UNUSED(scene), PointerRNA *ptr)
{		{
DEG_id_tag_update(ptr->owner_id, ID_RECALC_SEQUENCER_STRIPS \| ID_RECALC_AUDIO);		DEG_id_tag_update(ptr->owner_id, ID_RECALC_SEQUENCER_STRIPS \| ID_RECALC_AUDIO);
}		}

static void rna_Sequence_speed_factor_update(Main bmain, Scene scene, PointerRNA *ptr)		static void rna_Sequence_speed_factor_update(Main bmain, Scene scene, PointerRNA *ptr)
{		{
SEQ_cache_cleanup(scene);		SEQ_cache_cleanup(scene);
rna_Sequence_audio_update(bmain, scene, ptr);		rna_Sequence_audio_update(bmain, scene, ptr);
}		}

static void rna_Sequence_speed_factor_set(PointerRNA *ptr, float value)		static void rna_Sequence_speed_factor_set(PointerRNA *ptr, float value)
{		{
Sequence seq = (Sequence )ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
SEQ_time_speed_factor_set(scene, seq, value);		SEQ_time_speed_factor_set(scene, seq, value);
}		}

static void rna_Sequence_pan_range(		static void rna_Sequence_pan_range(
PointerRNA ptr, float min, float max, float softmin, float *softmax)		PointerRNA ptr, float min, float max, float softmin, float *softmax)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);

*min = -FLT_MAX;		*min = -FLT_MAX;
*max = FLT_MAX;		*max = FLT_MAX;
*softmax = 1 + (int)(scene->r.ffcodecdata.audio_channels > 2);		*softmax = 1 + (int)(scene->r.ffcodecdata.audio_channels > 2);
softmin = -softmax;		softmin = -softmax;
}		}

static int rna_Sequence_input_count_get(PointerRNA *ptr)		static int rna_Sequence_input_count_get(PointerRNA *ptr)
{		{
Sequence seq = (Sequence )(ptr->data);		Sequence seq = static_cast<Sequence >(ptr->data);

return SEQ_effect_get_num_inputs(seq->type);		return SEQ_effect_get_num_inputs(seq->type);
}		}

static void rna_Sequence_input_set(PointerRNA *ptr,		static void rna_Sequence_input_set(PointerRNA *ptr,
PointerRNA ptr_value,		PointerRNA ptr_value,
struct ReportList *reports,		struct ReportList *reports,
int input_num)		int input_num)
{		{

Sequence *seq = ptr->data;		Sequence seq = static_cast<Sequence >(ptr->data);
Sequence *input = ptr_value.data;		Sequence input = static_cast<Sequence >(ptr_value.data);

if (SEQ_relations_render_loop_check(input, seq)) {		if (SEQ_relations_render_loop_check(input, seq)) {
BKE_report(reports, RPT_ERROR, "Cannot reassign inputs: recursion detected");		BKE_report(reports, RPT_ERROR, "Cannot reassign inputs: recursion detected");
return;		return;
}		}

switch (input_num) {		switch (input_num) {
case 1:		case 1:
Show All 16 Lines	static void rna_Sequence_input_2_set(PointerRNA *ptr,
PointerRNA ptr_value,		PointerRNA ptr_value,
struct ReportList *reports)		struct ReportList *reports)
{		{
rna_Sequence_input_set(ptr, ptr_value, reports, 2);		rna_Sequence_input_set(ptr, ptr_value, reports, 2);
}		}
# if 0		# if 0
static void rna_SoundSequence_filename_set(PointerRNA ptr, const char value)		static void rna_SoundSequence_filename_set(PointerRNA ptr, const char value)
{		{
Sequence seq = (Sequence )(ptr->data);		Sequence seq = static_cast<Sequence >(ptr->data);
BLI_split_dirfile(value,		BLI_split_dirfile(value,
seq->strip->dir,		seq->strip->dir,
seq->strip->stripdata->name,		seq->strip->stripdata->name,
sizeof(seq->strip->dir),		sizeof(seq->strip->dir),
sizeof(seq->strip->stripdata->name));		sizeof(seq->strip->stripdata->name));
}		}

static void rna_SequenceElement_filename_set(PointerRNA ptr, const char value)		static void rna_SequenceElement_filename_set(PointerRNA ptr, const char value)
{		{
StripElem elem = (StripElem )(ptr->data);		StripElem elem = static_cast<StripElem >(ptr->data);
BLI_split_file_part(value, elem->name, sizeof(elem->name));		BLI_split_file_part(value, elem->name, sizeof(elem->name));
}		}
# endif		# endif

static void rna_Sequence_reopen_files_update(Main bmain, Scene UNUSED(scene), PointerRNA *ptr)		static void rna_Sequence_reopen_files_update(Main bmain, Scene UNUSED(scene), PointerRNA *ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);

SEQ_relations_free_imbuf(scene, &ed->seqbase, false);		SEQ_relations_free_imbuf(scene, &ed->seqbase, false);
rna_Sequence_invalidate_raw_update(bmain, scene, ptr);		rna_Sequence_invalidate_raw_update(bmain, scene, ptr);

if (RNA_struct_is_a(ptr->type, &RNA_SoundSequence)) {		if (RNA_struct_is_a(ptr->type, &RNA_SoundSequence)) {
SEQ_sound_update_bounds(scene, ptr->data);		SEQ_sound_update_bounds(scene, static_cast<Sequence *>(ptr->data));
}		}
}		}

static void rna_Sequence_filepath_update(Main bmain, Scene UNUSED(scene), PointerRNA *ptr)		static void rna_Sequence_filepath_update(Main bmain, Scene UNUSED(scene), PointerRNA *ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Sequence seq = (Sequence )(ptr->data);		Sequence seq = static_cast<Sequence >(ptr->data);
SEQ_add_reload_new_file(bmain, scene, seq, true);		SEQ_add_reload_new_file(bmain, scene, seq, true);
rna_Sequence_invalidate_raw_update(bmain, scene, ptr);		rna_Sequence_invalidate_raw_update(bmain, scene, ptr);
}		}

static void rna_Sequence_sound_update(Main bmain, Scene UNUSED(active_scene), PointerRNA *ptr)		static void rna_Sequence_sound_update(Main bmain, Scene UNUSED(active_scene), PointerRNA *ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS \| ID_RECALC_AUDIO);		DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS \| ID_RECALC_AUDIO);
DEG_relations_tag_update(bmain);		DEG_relations_tag_update(bmain);
}		}

static bool seqproxy_seq_cmp_fn(Sequence seq, void arg_pt)		static bool seqproxy_seq_cmp_fn(Sequence seq, void arg_pt)
{		{
SequenceSearchData *data = arg_pt;		SequenceSearchData data = static_cast<SequenceSearchData >(arg_pt);

if (seq->strip && seq->strip->proxy == data->data) {		if (seq->strip && seq->strip->proxy == data->data) {
data->seq = seq;		data->seq = seq;
return false; /* done so bail out */		return false; /* done so bail out */
}		}
return true;		return true;
}		}

static Sequence sequence_get_by_proxy(Editing ed, StripProxy *proxy)		static Sequence sequence_get_by_proxy(Editing ed, StripProxy *proxy)
{		{
SequenceSearchData data;		SequenceSearchData data;

data.seq = NULL;		data.seq = NULL;
data.data = proxy;		data.data = proxy;

SEQ_for_each_callback(&ed->seqbase, seqproxy_seq_cmp_fn, &data);		SEQ_for_each_callback(&ed->seqbase, seqproxy_seq_cmp_fn, &data);
return data.seq;		return data.seq;
}		}

static void rna_Sequence_tcindex_update(Main bmain, Scene UNUSED(scene), PointerRNA *ptr)		static void rna_Sequence_tcindex_update(Main bmain, Scene UNUSED(scene), PointerRNA *ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);
Sequence *seq = sequence_get_by_proxy(ed, ptr->data);		Sequence seq = sequence_get_by_proxy(ed, static_cast<StripProxy >(ptr->data));

SEQ_add_reload_new_file(bmain, scene, seq, false);		SEQ_add_reload_new_file(bmain, scene, seq, false);
do_sequence_frame_change_update(scene, seq);		do_sequence_frame_change_update(scene, seq);
}		}

static void rna_SequenceProxy_update(Main UNUSED(bmain), Scene UNUSED(scene), PointerRNA *ptr)		static void rna_SequenceProxy_update(Main UNUSED(bmain), Scene UNUSED(scene), PointerRNA *ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);
Sequence *seq = sequence_get_by_proxy(ed, ptr->data);		Sequence seq = sequence_get_by_proxy(ed, static_cast<StripProxy >(ptr->data));
SEQ_relations_invalidate_cache_preprocessed(scene, seq);		SEQ_relations_invalidate_cache_preprocessed(scene, seq);
}		}

/* do_versions? */		/* do_versions? */
static float rna_Sequence_opacity_get(PointerRNA *ptr)		static float rna_Sequence_opacity_get(PointerRNA *ptr)
{		{
Sequence seq = (Sequence )(ptr->data);		Sequence seq = static_cast<Sequence >(ptr->data);
return seq->blend_opacity / 100.0f;		return seq->blend_opacity / 100.0f;
}		}
static void rna_Sequence_opacity_set(PointerRNA *ptr, float value)		static void rna_Sequence_opacity_set(PointerRNA *ptr, float value)
{		{
Sequence seq = (Sequence )(ptr->data);		Sequence seq = static_cast<Sequence >(ptr->data);
CLAMP(value, 0.0f, 1.0f);		CLAMP(value, 0.0f, 1.0f);
seq->blend_opacity = value * 100.0f;		seq->blend_opacity = value * 100.0f;
}		}

static int rna_Sequence_color_tag_get(PointerRNA *ptr)		static int rna_Sequence_color_tag_get(PointerRNA *ptr)
{		{
Sequence seq = (Sequence )(ptr->data);		Sequence seq = static_cast<Sequence >(ptr->data);
return seq->color_tag;		return seq->color_tag;
}		}

static void rna_Sequence_color_tag_set(PointerRNA *ptr, int value)		static void rna_Sequence_color_tag_set(PointerRNA *ptr, int value)
{		{
Sequence seq = (Sequence )(ptr->data);		Sequence seq = static_cast<Sequence >(ptr->data);
seq->color_tag = value;		seq->color_tag = value;
}		}

static bool colbalance_seq_cmp_fn(Sequence seq, void arg_pt)		static bool colbalance_seq_cmp_fn(Sequence seq, void arg_pt)
{		{
SequenceSearchData *data = arg_pt;		SequenceSearchData data = static_cast<SequenceSearchData >(arg_pt);

for (SequenceModifierData *smd = seq->modifiers.first; smd; smd = smd->next) {		for (SequenceModifierData smd = static_cast<SequenceModifierData >(seq->modifiers.first); smd;
		smd = smd->next) {
if (smd->type == seqModifierType_ColorBalance) {		if (smd->type == seqModifierType_ColorBalance) {
ColorBalanceModifierData cbmd = (ColorBalanceModifierData )smd;		ColorBalanceModifierData cbmd = reinterpret_cast<ColorBalanceModifierData >(smd);

if (&cbmd->color_balance == data->data) {		if (&cbmd->color_balance == data->data) {
data->seq = seq;		data->seq = seq;
data->smd = smd;		data->smd = smd;
return false; /* done so bail out */		return false; /* done so bail out */
}		}
}		}
}		}
Show All 16 Lines	static Sequence sequence_get_by_colorbalance(Editing ed,

*r_smd = data.smd;		*r_smd = data.smd;

return data.seq;		return data.seq;
}		}

static char rna_SequenceColorBalance_path(const PointerRNA ptr)		static char rna_SequenceColorBalance_path(const PointerRNA ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
SequenceModifierData *smd;		SequenceModifierData *smd;
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);
Sequence *seq = sequence_get_by_colorbalance(ed, ptr->data, &smd);		Sequence *seq = sequence_get_by_colorbalance(
		ed, static_cast<StripColorBalance *>(ptr->data), &smd);

if (seq) {		if (seq) {
char name_esc[(sizeof(seq->name) - 2) * 2];		char name_esc[(sizeof(seq->name) - 2) * 2];

BLI_str_escape(name_esc, seq->name + 2, sizeof(name_esc));		BLI_str_escape(name_esc, seq->name + 2, sizeof(name_esc));

if (!smd) {		if (!smd) {
/* path to old filter color balance */		/* path to old filter color balance */
Show All 13 Lines	else {
return BLI_strdup("");		return BLI_strdup("");
}		}
}		}

static void rna_SequenceColorBalance_update(Main *UNUSED(bmain),		static void rna_SequenceColorBalance_update(Main *UNUSED(bmain),
Scene *UNUSED(scene),		Scene *UNUSED(scene),
PointerRNA *ptr)		PointerRNA *ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);
SequenceModifierData *smd;		SequenceModifierData *smd;
Sequence *seq = sequence_get_by_colorbalance(ed, ptr->data, &smd);		Sequence *seq = sequence_get_by_colorbalance(
		ed, static_cast<StripColorBalance *>(ptr->data), &smd);

SEQ_relations_invalidate_cache_preprocessed(scene, seq);		SEQ_relations_invalidate_cache_preprocessed(scene, seq);
}		}

static void rna_SequenceEditor_overlay_lock_set(PointerRNA *ptr, bool value)		static void rna_SequenceEditor_overlay_lock_set(PointerRNA *ptr, bool value)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);

if (ed == NULL) {		if (ed == NULL) {
return;		return;
}		}

/* convert from abs to relative and back */		/* convert from abs to relative and back */
if ((ed->overlay_frame_flag & SEQ_EDIT_OVERLAY_FRAME_ABS) == 0 && value) {		if ((ed->overlay_frame_flag & SEQ_EDIT_OVERLAY_FRAME_ABS) == 0 && value) {
ed->overlay_frame_abs = scene->r.cfra + ed->overlay_frame_ofs;		ed->overlay_frame_abs = scene->r.cfra + ed->overlay_frame_ofs;
ed->overlay_frame_flag \|= SEQ_EDIT_OVERLAY_FRAME_ABS;		ed->overlay_frame_flag \|= SEQ_EDIT_OVERLAY_FRAME_ABS;
}		}
else if ((ed->overlay_frame_flag & SEQ_EDIT_OVERLAY_FRAME_ABS) && !value) {		else if ((ed->overlay_frame_flag & SEQ_EDIT_OVERLAY_FRAME_ABS) && !value) {
ed->overlay_frame_ofs = ed->overlay_frame_abs - scene->r.cfra;		ed->overlay_frame_ofs = ed->overlay_frame_abs - scene->r.cfra;
ed->overlay_frame_flag &= ~SEQ_EDIT_OVERLAY_FRAME_ABS;		ed->overlay_frame_flag &= ~SEQ_EDIT_OVERLAY_FRAME_ABS;
}		}
}		}

static int rna_SequenceEditor_overlay_frame_get(PointerRNA *ptr)		static int rna_SequenceEditor_overlay_frame_get(PointerRNA *ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);

if (ed == NULL) {		if (ed == NULL) {
return scene->r.cfra;		return scene->r.cfra;
}		}

if (ed->overlay_frame_flag & SEQ_EDIT_OVERLAY_FRAME_ABS) {		if (ed->overlay_frame_flag & SEQ_EDIT_OVERLAY_FRAME_ABS) {
return ed->overlay_frame_abs - scene->r.cfra;		return ed->overlay_frame_abs - scene->r.cfra;
}		}
else {		else {
return ed->overlay_frame_ofs;		return ed->overlay_frame_ofs;
}		}
}		}

static void rna_SequenceEditor_overlay_frame_set(PointerRNA *ptr, int value)		static void rna_SequenceEditor_overlay_frame_set(PointerRNA *ptr, int value)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);

if (ed == NULL) {		if (ed == NULL) {
return;		return;
}		}

if (ed->overlay_frame_flag & SEQ_EDIT_OVERLAY_FRAME_ABS) {		if (ed->overlay_frame_flag & SEQ_EDIT_OVERLAY_FRAME_ABS) {
ed->overlay_frame_abs = (scene->r.cfra + value);		ed->overlay_frame_abs = (scene->r.cfra + value);
Show All 10 Lines
{		{
/* Check for non-meta sequence */		/* Check for non-meta sequence */
if (seqm != NULL && seqm->type != SEQ_TYPE_META && SEQ_exists_in_seqbase(seqm, &ed->seqbase)) {		if (seqm != NULL && seqm->type != SEQ_TYPE_META && SEQ_exists_in_seqbase(seqm, &ed->seqbase)) {
BKE_report(reports, RPT_ERROR, "Sequence type must be 'META'");		BKE_report(reports, RPT_ERROR, "Sequence type must be 'META'");
return;		return;
}		}

/* Get editing base of meta sequence */		/* Get editing base of meta sequence */
Scene scene = (Scene )id;		Scene scene = reinterpret_cast<Scene >(id);
SEQ_meta_stack_set(scene, seqm);		SEQ_meta_stack_set(scene, seqm);
/* De-activate strip. This is to prevent strip from different timeline being drawn. */		/* De-activate strip. This is to prevent strip from different timeline being drawn. */
SEQ_select_active_set(scene, NULL);		SEQ_select_active_set(scene, NULL);

WM_main_add_notifier(NC_SCENE \| ND_SEQUENCER, scene);		WM_main_add_notifier(NC_SCENE \| ND_SEQUENCER, scene);
}		}

static bool modifier_seq_cmp_fn(Sequence seq, void arg_pt)		static bool modifier_seq_cmp_fn(Sequence seq, void arg_pt)
{		{
SequenceSearchData *data = arg_pt;		SequenceSearchData data = static_cast<SequenceSearchData >(arg_pt);

if (BLI_findindex(&seq->modifiers, data->data) != -1) {		if (BLI_findindex(&seq->modifiers, data->data) != -1) {
data->seq = seq;		data->seq = seq;
return false; /* done so bail out */		return false; /* done so bail out */
}		}

return true;		return true;
}		}

static Sequence sequence_get_by_modifier(Editing ed, SequenceModifierData *smd)		static Sequence sequence_get_by_modifier(Editing ed, SequenceModifierData *smd)
{		{
SequenceSearchData data;		SequenceSearchData data;

data.seq = NULL;		data.seq = NULL;
data.data = smd;		data.data = smd;

/* irritating we need to search for our sequence! */		/* irritating we need to search for our sequence! */
SEQ_for_each_callback(&ed->seqbase, modifier_seq_cmp_fn, &data);		SEQ_for_each_callback(&ed->seqbase, modifier_seq_cmp_fn, &data);

return data.seq;		return data.seq;
}		}

static StructRNA rna_SequenceModifier_refine(struct PointerRNA ptr)		static StructRNA rna_SequenceModifier_refine(struct PointerRNA ptr)
{		{
SequenceModifierData smd = (SequenceModifierData )ptr->data;		SequenceModifierData smd = static_cast<SequenceModifierData >(ptr->data);

switch (smd->type) {		switch (smd->type) {
case seqModifierType_ColorBalance:		case seqModifierType_ColorBalance:
return &RNA_ColorBalanceModifier;		return &RNA_ColorBalanceModifier;
case seqModifierType_Curves:		case seqModifierType_Curves:
return &RNA_CurvesModifier;		return &RNA_CurvesModifier;
case seqModifierType_HueCorrect:		case seqModifierType_HueCorrect:
return &RNA_HueCorrectModifier;		return &RNA_HueCorrectModifier;
case seqModifierType_BrightContrast:		case seqModifierType_BrightContrast:
return &RNA_BrightContrastModifier;		return &RNA_BrightContrastModifier;
case seqModifierType_WhiteBalance:		case seqModifierType_WhiteBalance:
return &RNA_WhiteBalanceModifier;		return &RNA_WhiteBalanceModifier;
case seqModifierType_Tonemap:		case seqModifierType_Tonemap:
return &RNA_SequencerTonemapModifierData;		return &RNA_SequencerTonemapModifierData;
default:		default:
return &RNA_SequenceModifier;		return &RNA_SequenceModifier;
}		}
}		}

static char rna_SequenceModifier_path(const PointerRNA ptr)		static char rna_SequenceModifier_path(const PointerRNA ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);
SequenceModifierData *smd = ptr->data;		SequenceModifierData smd = static_cast<SequenceModifierData >(ptr->data);
Sequence *seq = sequence_get_by_modifier(ed, smd);		Sequence *seq = sequence_get_by_modifier(ed, smd);

if (seq) {		if (seq) {
char name_esc[(sizeof(seq->name) - 2) * 2];		char name_esc[(sizeof(seq->name) - 2) * 2];
char name_esc_smd[sizeof(smd->name) * 2];		char name_esc_smd[sizeof(smd->name) * 2];

BLI_str_escape(name_esc, seq->name + 2, sizeof(name_esc));		BLI_str_escape(name_esc, seq->name + 2, sizeof(name_esc));
BLI_str_escape(name_esc_smd, smd->name, sizeof(name_esc_smd));		BLI_str_escape(name_esc_smd, smd->name, sizeof(name_esc_smd));
return BLI_sprintfN(		return BLI_sprintfN(
"sequence_editor.sequences_all[\"%s\"].modifiers[\"%s\"]", name_esc, name_esc_smd);		"sequence_editor.sequences_all[\"%s\"].modifiers[\"%s\"]", name_esc, name_esc_smd);
}		}
else {		else {
return BLI_strdup("");		return BLI_strdup("");
}		}
}		}

static void rna_SequenceModifier_name_set(PointerRNA ptr, const char value)		static void rna_SequenceModifier_name_set(PointerRNA ptr, const char value)
{		{
SequenceModifierData *smd = ptr->data;		SequenceModifierData smd = static_cast<SequenceModifierData >(ptr->data);
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);
Sequence *seq = sequence_get_by_modifier(ed, smd);		Sequence *seq = sequence_get_by_modifier(ed, smd);
AnimData *adt;		AnimData *adt;
char oldname[sizeof(smd->name)];		char oldname[sizeof(smd->name)];

/* make a copy of the old name first */		/* make a copy of the old name first */
BLI_strncpy(oldname, smd->name, sizeof(smd->name));		BLI_strncpy(oldname, smd->name, sizeof(smd->name));

Show All 15 Lines	BLI_snprintf(
path, sizeof(path), "sequence_editor.sequences_all[\"%s\"].modifiers", seq_name_esc);		path, sizeof(path), "sequence_editor.sequences_all[\"%s\"].modifiers", seq_name_esc);
BKE_animdata_fix_paths_rename(&scene->id, adt, NULL, path, oldname, smd->name, 0, 0, 1);		BKE_animdata_fix_paths_rename(&scene->id, adt, NULL, path, oldname, smd->name, 0, 0, 1);
}		}
}		}

static void rna_SequenceModifier_update(Main UNUSED(bmain), Scene UNUSED(scene), PointerRNA *ptr)		static void rna_SequenceModifier_update(Main UNUSED(bmain), Scene UNUSED(scene), PointerRNA *ptr)
{		{
/* strip from other scenes could be modified, so using active scene is not reliable */		/* strip from other scenes could be modified, so using active scene is not reliable */
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);
Sequence *seq = sequence_get_by_modifier(ed, ptr->data);		Sequence seq = sequence_get_by_modifier(ed, static_cast<SequenceModifierData >(ptr->data));

SEQ_relations_invalidate_cache_preprocessed(scene, seq);		SEQ_relations_invalidate_cache_preprocessed(scene, seq);
}		}

static bool rna_SequenceModifier_otherSequence_poll(PointerRNA *ptr, PointerRNA value)		static bool rna_SequenceModifier_otherSequence_poll(PointerRNA *ptr, PointerRNA value)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);
Sequence *seq = sequence_get_by_modifier(ed, ptr->data);		Sequence seq = sequence_get_by_modifier(ed, static_cast<SequenceModifierData >(ptr->data));
Sequence cur = (Sequence )value.data;		Sequence cur = static_cast<Sequence >(value.data);

if ((seq == cur) \|\| (cur->type == SEQ_TYPE_SOUND_RAM)) {		if ((seq == cur) \|\| (cur->type == SEQ_TYPE_SOUND_RAM)) {
return false;		return false;
}		}

return true;		return true;
}		}

Show All 19 Lines	static SequenceModifierData *rna_Sequence_modifier_new(
}		}
}		}

static void rna_Sequence_modifier_remove(Sequence *seq,		static void rna_Sequence_modifier_remove(Sequence *seq,
bContext *C,		bContext *C,
ReportList *reports,		ReportList *reports,
PointerRNA *smd_ptr)		PointerRNA *smd_ptr)
{		{
SequenceModifierData *smd = smd_ptr->data;		SequenceModifierData smd = static_cast<SequenceModifierData >(smd_ptr->data);
Scene *scene = CTX_data_scene(C);		Scene *scene = CTX_data_scene(C);

if (SEQ_modifier_remove(seq, smd) == false) {		if (SEQ_modifier_remove(seq, smd) == false) {
BKE_report(reports, RPT_ERROR, "Modifier was not found in the stack");		BKE_report(reports, RPT_ERROR, "Modifier was not found in the stack");
return;		return;
}		}

RNA_POINTER_INVALIDATE(smd_ptr);		RNA_POINTER_INVALIDATE(smd_ptr);
Show All 12 Lines	static void rna_Sequence_modifier_clear(Sequence seq, bContext C)

WM_main_add_notifier(NC_SCENE \| ND_SEQUENCER, NULL);		WM_main_add_notifier(NC_SCENE \| ND_SEQUENCER, NULL);
}		}

static void rna_SequenceModifier_strip_set(PointerRNA *ptr,		static void rna_SequenceModifier_strip_set(PointerRNA *ptr,
PointerRNA value,		PointerRNA value,
struct ReportList *reports)		struct ReportList *reports)
{		{
SequenceModifierData *smd = ptr->data;		SequenceModifierData smd = static_cast<SequenceModifierData >(ptr->data);
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);
Sequence *seq = sequence_get_by_modifier(ed, smd);		Sequence *seq = sequence_get_by_modifier(ed, smd);
Sequence target = (Sequence )value.data;		Sequence target = static_cast<Sequence >(value.data);

if (target != NULL && SEQ_relations_render_loop_check(target, seq)) {		if (target != NULL && SEQ_relations_render_loop_check(target, seq)) {
BKE_report(reports, RPT_ERROR, "Recursion detected, can not use this strip");		BKE_report(reports, RPT_ERROR, "Recursion detected, can not use this strip");
return;		return;
}		}

smd->mask_sequence = target;		smd->mask_sequence = target;
}		}

static float rna_Sequence_fps_get(PointerRNA *ptr)		static float rna_Sequence_fps_get(PointerRNA *ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Sequence seq = (Sequence )(ptr->data);		Sequence seq = static_cast<Sequence >(ptr->data);
return SEQ_time_sequence_get_fps(scene, seq);		return SEQ_time_sequence_get_fps(scene, seq);
}		}

static void rna_Sequence_separate(ID id, Sequence seqm, Main *bmain)		static void rna_Sequence_separate(ID id, Sequence seqm, Main *bmain)
{		{
Scene scene = (Scene )id;		Scene scene = reinterpret_cast<Scene >(id);

/* Find the appropriate seqbase */		/* Find the appropriate seqbase */
ListBase *seqbase = SEQ_get_seqbase_by_seq(scene, seqm);		ListBase *seqbase = SEQ_get_seqbase_by_seq(scene, seqm);

LISTBASE_FOREACH_MUTABLE (Sequence *, seq, &seqm->seqbase) {		LISTBASE_FOREACH_MUTABLE (Sequence *, seq, &seqm->seqbase) {
SEQ_edit_move_strip_to_seqbase(scene, &seqm->seqbase, seq, seqbase);		SEQ_edit_move_strip_to_seqbase(scene, &seqm->seqbase, seq, seqbase);
}		}

Show All 24 Lines	static Sequence rna_SeqTimelineChannel_owner_get(Editing ed, SeqTimelineChannel *channel)
}		}

SEQ_collection_free(strips);		SEQ_collection_free(strips);
return channel_owner;		return channel_owner;
}		}

static void rna_SequenceTimelineChannel_name_set(PointerRNA ptr, const char value)		static void rna_SequenceTimelineChannel_name_set(PointerRNA ptr, const char value)
{		{
SeqTimelineChannel channel = (SeqTimelineChannel )ptr->data;		SeqTimelineChannel channel = static_cast<SeqTimelineChannel >(ptr->data);
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);

Sequence *channel_owner = rna_SeqTimelineChannel_owner_get(ed, channel);		Sequence *channel_owner = rna_SeqTimelineChannel_owner_get(ed, channel);
ListBase *channels_base = &ed->channels;		ListBase *channels_base = &ed->channels;

if (channel_owner != NULL) {		if (channel_owner != NULL) {
channels_base = &channel_owner->channels;		channels_base = &channel_owner->channels;
}		}

BLI_strncpy_utf8(channel->name, value, sizeof(channel->name));		BLI_strncpy_utf8(channel->name, value, sizeof(channel->name));
BLI_uniquename(channels_base,		BLI_uniquename(channels_base,
channel,		channel,
"Channel",		"Channel",
'.',		'.',
offsetof(SeqTimelineChannel, name),		offsetof(SeqTimelineChannel, name),
sizeof(channel->name));		sizeof(channel->name));
}		}

static char rna_SeqTimelineChannel_path(const PointerRNA ptr)		static char rna_SeqTimelineChannel_path(const PointerRNA ptr)
{		{
Scene scene = (Scene )ptr->owner_id;		Scene scene = reinterpret_cast<Scene >(ptr->owner_id);
Editing *ed = SEQ_editing_get(scene);		Editing *ed = SEQ_editing_get(scene);
SeqTimelineChannel channel = (SeqTimelineChannel )ptr->data;		SeqTimelineChannel channel = static_cast<SeqTimelineChannel >(ptr->data);

Sequence *channel_owner = rna_SeqTimelineChannel_owner_get(ed, channel);		Sequence *channel_owner = rna_SeqTimelineChannel_owner_get(ed, channel);

char channel_name_esc[(sizeof(channel->name)) * 2];		char channel_name_esc[(sizeof(channel->name)) * 2];
BLI_str_escape(channel_name_esc, channel->name, sizeof(channel_name_esc));		BLI_str_escape(channel_name_esc, channel->name, sizeof(channel_name_esc));

if (channel_owner == NULL) {		if (channel_owner == NULL) {
return BLI_sprintfN("sequence_editor.channels[\"%s\"]", channel_name_esc);		return BLI_sprintfN("sequence_editor.channels[\"%s\"]", channel_name_esc);
▲ Show 20 Lines • Show All 413 Lines • ▼ Show 20 Lines	static void rna_def_sequence_modifiers(BlenderRNA brna, PropertyRNA cprop)
RNA_def_struct_sdna(srna, "Sequence");		RNA_def_struct_sdna(srna, "Sequence");
RNA_def_struct_ui_text(srna, "Strip Modifiers", "Collection of strip modifiers");		RNA_def_struct_ui_text(srna, "Strip Modifiers", "Collection of strip modifiers");

/* add modifier */		/* add modifier */
func = RNA_def_function(srna, "new", "rna_Sequence_modifier_new");		func = RNA_def_function(srna, "new", "rna_Sequence_modifier_new");
RNA_def_function_flag(func, FUNC_USE_CONTEXT \| FUNC_USE_REPORTS);		RNA_def_function_flag(func, FUNC_USE_CONTEXT \| FUNC_USE_REPORTS);
RNA_def_function_ui_description(func, "Add a new modifier");		RNA_def_function_ui_description(func, "Add a new modifier");
parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the modifier");		parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the modifier");
RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);		RNA_def_parameter_flags(parm, PropertyFlag(0), PARM_REQUIRED);
/* modifier to add */		/* modifier to add */
parm = RNA_def_enum(func,		parm = RNA_def_enum(func,
"type",		"type",
rna_enum_sequence_modifier_type_items,		rna_enum_sequence_modifier_type_items,
seqModifierType_ColorBalance,		seqModifierType_ColorBalance,
"",		"",
"Modifier type to add");		"Modifier type to add");
RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);		RNA_def_parameter_flags(parm, PropertyFlag(0), PARM_REQUIRED);
/* return type */		/* return type */
parm = RNA_def_pointer(func, "modifier", "SequenceModifier", "", "Newly created modifier");		parm = RNA_def_pointer(func, "modifier", "SequenceModifier", "", "Newly created modifier");
RNA_def_function_return(func, parm);		RNA_def_function_return(func, parm);

/* remove modifier */		/* remove modifier */
func = RNA_def_function(srna, "remove", "rna_Sequence_modifier_remove");		func = RNA_def_function(srna, "remove", "rna_Sequence_modifier_remove");
RNA_def_function_flag(func, FUNC_USE_CONTEXT \| FUNC_USE_REPORTS);		RNA_def_function_flag(func, FUNC_USE_CONTEXT \| FUNC_USE_REPORTS);
RNA_def_function_ui_description(func, "Remove an existing modifier from the sequence");		RNA_def_function_ui_description(func, "Remove an existing modifier from the sequence");
/* modifier to remove */		/* modifier to remove */
parm = RNA_def_pointer(func, "modifier", "SequenceModifier", "", "Modifier to remove");		parm = RNA_def_pointer(func, "modifier", "SequenceModifier", "", "Modifier to remove");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED \| PARM_RNAPTR);		RNA_def_parameter_flags(parm, PROP_NEVER_NULL, ParameterFlag(PARM_REQUIRED \| PARM_RNAPTR));
RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);		RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, ParameterFlag(0));

/* clear all modifiers */		/* clear all modifiers */
func = RNA_def_function(srna, "clear", "rna_Sequence_modifier_clear");		func = RNA_def_function(srna, "clear", "rna_Sequence_modifier_clear");
RNA_def_function_flag(func, FUNC_USE_CONTEXT);		RNA_def_function_flag(func, FUNC_USE_CONTEXT);
RNA_def_function_ui_description(func, "Remove all modifiers from the sequence");		RNA_def_function_ui_description(func, "Remove all modifiers from the sequence");
}		}

static void rna_def_sequence(BlenderRNA *brna)		static void rna_def_sequence(BlenderRNA *brna)
Show All 34 Lines	static void rna_def_sequence(BlenderRNA *brna)
RNA_def_struct_ui_text(srna, "Sequence", "Sequence strip in the sequence editor");		RNA_def_struct_ui_text(srna, "Sequence", "Sequence strip in the sequence editor");
RNA_def_struct_refine_func(srna, "rna_Sequence_refine");		RNA_def_struct_refine_func(srna, "rna_Sequence_refine");
RNA_def_struct_path_func(srna, "rna_Sequence_path");		RNA_def_struct_path_func(srna, "rna_Sequence_path");
RNA_def_struct_idprops_func(srna, "rna_Sequence_idprops");		RNA_def_struct_idprops_func(srna, "rna_Sequence_idprops");

prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);		prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
RNA_def_property_string_funcs(		RNA_def_property_string_funcs(
prop, "rna_Sequence_name_get", "rna_Sequence_name_length", "rna_Sequence_name_set");		prop, "rna_Sequence_name_get", "rna_Sequence_name_length", "rna_Sequence_name_set");
RNA_def_property_string_maxlength(prop, sizeof(((Sequence *)NULL)->name) - 2);		RNA_def_property_string_maxlength(prop, sizeof((static_cast<Sequence *>(NULL))->name) - 2);
RNA_def_property_ui_text(prop, "Name", "");		RNA_def_property_ui_text(prop, "Name", "");
RNA_def_struct_name_property(srna, prop);		RNA_def_struct_name_property(srna, prop);
RNA_def_property_update(prop, NC_SCENE \| ND_SEQUENCER, NULL);		RNA_def_property_update(prop, NC_SCENE \| ND_SEQUENCER, NULL);

prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);		prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
RNA_def_property_clear_flag(prop, PROP_EDITABLE);		RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_enum_items(prop, seq_type_items);		RNA_def_property_enum_items(prop, seq_type_items);
RNA_def_property_ui_text(prop, "Type", "");		RNA_def_property_ui_text(prop, "Type", "");
Show All 40 Lines	static void rna_def_sequence(BlenderRNA *brna)
RNA_def_property_int_funcs(		RNA_def_property_int_funcs(
prop, "rna_Sequence_frame_length_get", "rna_Sequence_frame_length_set", NULL);		prop, "rna_Sequence_frame_length_get", "rna_Sequence_frame_length_set", NULL);
RNA_def_property_editable_func(prop, "rna_Sequence_frame_editable");		RNA_def_property_editable_func(prop, "rna_Sequence_frame_editable");
RNA_def_property_update(		RNA_def_property_update(
prop, NC_SCENE \| ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");		prop, NC_SCENE \| ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");

prop = RNA_def_property(srna, "frame_duration", PROP_INT, PROP_TIME);		prop = RNA_def_property(srna, "frame_duration", PROP_INT, PROP_TIME);
RNA_def_property_int_sdna(prop, NULL, "len");		RNA_def_property_int_sdna(prop, NULL, "len");
RNA_def_property_clear_flag(prop, PROP_EDITABLE \| PROP_ANIMATABLE);		RNA_def_property_clear_flag(prop, PropertyFlag(PROP_EDITABLE \| PROP_ANIMATABLE));
RNA_def_property_range(prop, 1, MAXFRAME);		RNA_def_property_range(prop, 1, MAXFRAME);
RNA_def_property_ui_text(		RNA_def_property_ui_text(
prop, "Length", "The length of the contents of this strip before the handles are applied");		prop, "Length", "The length of the contents of this strip before the handles are applied");

prop = RNA_def_property(srna, "frame_start", PROP_FLOAT, PROP_TIME);		prop = RNA_def_property(srna, "frame_start", PROP_FLOAT, PROP_TIME);
RNA_def_property_float_sdna(prop, NULL, "start");		RNA_def_property_float_sdna(prop, NULL, "start");
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);		RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_ui_text(prop, "Start Frame", "X position where the strip begins");		RNA_def_property_ui_text(prop, "Start Frame", "X position where the strip begins");
▲ Show 20 Lines • Show All 151 Lines • ▼ Show 20 Lines	static void rna_def_channel(BlenderRNA *brna)
PropertyRNA *prop;		PropertyRNA *prop;

srna = RNA_def_struct(brna, "SequenceTimelineChannel", NULL);		srna = RNA_def_struct(brna, "SequenceTimelineChannel", NULL);
RNA_def_struct_sdna(srna, "SeqTimelineChannel");		RNA_def_struct_sdna(srna, "SeqTimelineChannel");
RNA_def_struct_path_func(srna, "rna_SeqTimelineChannel_path");		RNA_def_struct_path_func(srna, "rna_SeqTimelineChannel_path");
RNA_def_struct_ui_text(srna, "Channel", "");		RNA_def_struct_ui_text(srna, "Channel", "");

prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);		prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
RNA_def_property_string_maxlength(prop, sizeof(((SeqTimelineChannel *)NULL)->name));		RNA_def_property_string_maxlength(prop, sizeof((static_cast<SeqTimelineChannel *>(NULL))->name));
RNA_def_property_ui_text(prop, "Name", "");		RNA_def_property_ui_text(prop, "Name", "");
RNA_def_struct_name_property(srna, prop);		RNA_def_struct_name_property(srna, prop);
RNA_def_property_string_funcs(prop, NULL, NULL, "rna_SequenceTimelineChannel_name_set");		RNA_def_property_string_funcs(prop, NULL, NULL, "rna_SequenceTimelineChannel_name_set");
RNA_def_property_update(prop, NC_SCENE \| ND_SEQUENCER, NULL);		RNA_def_property_update(prop, NC_SCENE \| ND_SEQUENCER, NULL);

prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);		prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_CHANNEL_LOCK);		RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_CHANNEL_LOCK);
RNA_def_property_ui_text(prop, "Lock channel", "");		RNA_def_property_ui_text(prop, "Lock channel", "");
▲ Show 20 Lines • Show All 157 Lines • ▼ Show 20 Lines	static void rna_def_editor(BlenderRNA *brna)

/* functions */		/* functions */

func = RNA_def_function(srna, "display_stack", "rna_SequenceEditor_display_stack");		func = RNA_def_function(srna, "display_stack", "rna_SequenceEditor_display_stack");
RNA_def_function_flag(func, FUNC_USE_SELF_ID \| FUNC_USE_REPORTS);		RNA_def_function_flag(func, FUNC_USE_SELF_ID \| FUNC_USE_REPORTS);
RNA_def_function_ui_description(func, "Display sequences stack");		RNA_def_function_ui_description(func, "Display sequences stack");
parm = RNA_def_pointer(		parm = RNA_def_pointer(
func, "meta_sequence", "Sequence", "Meta Sequence", "Meta to display its stack");		func, "meta_sequence", "Sequence", "Meta Sequence", "Meta to display its stack");
RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);		RNA_def_parameter_flags(parm, PropertyFlag(0), PARM_REQUIRED);
}		}

static void rna_def_speed_factor(StructRNA *srna)		static void rna_def_speed_factor(StructRNA *srna)
{		{
PropertyRNA *prop = RNA_def_property(srna, "speed_factor", PROP_FLOAT, PROP_NONE);		PropertyRNA *prop = RNA_def_property(srna, "speed_factor", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "speed_factor");		RNA_def_property_float_sdna(prop, NULL, "speed_factor");
RNA_def_property_float_default(prop, 1.0f);		RNA_def_property_float_default(prop, 1.0f);
RNA_def_property_range(prop, 0.1f, FLT_MAX);		RNA_def_property_range(prop, 0.1f, FLT_MAX);
▲ Show 20 Lines • Show All 136 Lines • ▼ Show 20 Lines	static void rna_def_effect_inputs(StructRNA *srna, int count)

prop = RNA_def_property(srna, "input_count", PROP_INT, PROP_UNSIGNED);		prop = RNA_def_property(srna, "input_count", PROP_INT, PROP_UNSIGNED);
RNA_def_property_clear_flag(prop, PROP_EDITABLE);		RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_int_funcs(prop, "rna_Sequence_input_count_get", NULL, NULL);		RNA_def_property_int_funcs(prop, "rna_Sequence_input_count_get", NULL, NULL);

if (count >= 1) {		if (count >= 1) {
prop = RNA_def_property(srna, "input_1", PROP_POINTER, PROP_NONE);		prop = RNA_def_property(srna, "input_1", PROP_POINTER, PROP_NONE);
RNA_def_property_pointer_sdna(prop, NULL, "seq1");		RNA_def_property_pointer_sdna(prop, NULL, "seq1");
RNA_def_property_flag(prop, PROP_EDITABLE \| PROP_NEVER_NULL);		RNA_def_property_flag(prop, PropertyFlag(PROP_EDITABLE \| PROP_NEVER_NULL));
RNA_def_property_pointer_funcs(prop, NULL, "rna_Sequence_input_1_set", NULL, NULL);		RNA_def_property_pointer_funcs(prop, NULL, "rna_Sequence_input_1_set", NULL, NULL);
RNA_def_property_ui_text(prop, "Input 1", "First input for the effect strip");		RNA_def_property_ui_text(prop, "Input 1", "First input for the effect strip");
}		}

if (count >= 2) {		if (count >= 2) {
prop = RNA_def_property(srna, "input_2", PROP_POINTER, PROP_NONE);		prop = RNA_def_property(srna, "input_2", PROP_POINTER, PROP_NONE);
RNA_def_property_pointer_sdna(prop, NULL, "seq2");		RNA_def_property_pointer_sdna(prop, NULL, "seq2");
RNA_def_property_flag(prop, PROP_EDITABLE \| PROP_NEVER_NULL);		RNA_def_property_flag(prop, PropertyFlag(PROP_EDITABLE \| PROP_NEVER_NULL));
RNA_def_property_pointer_funcs(prop, NULL, "rna_Sequence_input_2_set", NULL, NULL);		RNA_def_property_pointer_funcs(prop, NULL, "rna_Sequence_input_2_set", NULL, NULL);
RNA_def_property_ui_text(prop, "Input 2", "Second input for the effect strip");		RNA_def_property_ui_text(prop, "Input 2", "Second input for the effect strip");
}		}

# if 0		# if 0
if (count == 3) {		if (count == 3) {
/* Not used by any effects (perhaps one day plugins?). */		/* Not used by any effects (perhaps one day plugins?). */
prop = RNA_def_property(srna, "input_3", PROP_POINTER, PROP_NONE);		prop = RNA_def_property(srna, "input_3", PROP_POINTER, PROP_NONE);
▲ Show 20 Lines • Show All 126 Lines • ▼ Show 20 Lines	static void rna_def_scene(BlenderRNA *brna)
};		};

srna = RNA_def_struct(brna, "SceneSequence", "Sequence");		srna = RNA_def_struct(brna, "SceneSequence", "Sequence");
RNA_def_struct_ui_text(		RNA_def_struct_ui_text(
srna, "Scene Sequence", "Sequence strip to used the rendered image of a scene");		srna, "Scene Sequence", "Sequence strip to used the rendered image of a scene");
RNA_def_struct_sdna(srna, "Sequence");		RNA_def_struct_sdna(srna, "Sequence");

prop = RNA_def_property(srna, "scene", PROP_POINTER, PROP_NONE);		prop = RNA_def_property(srna, "scene", PROP_POINTER, PROP_NONE);
RNA_def_property_flag(prop, PROP_EDITABLE \| PROP_ID_SELF_CHECK);		RNA_def_property_flag(prop, PropertyFlag(PROP_EDITABLE \| PROP_ID_SELF_CHECK));
RNA_def_property_ui_text(prop, "Scene", "Scene that this sequence uses");		RNA_def_property_ui_text(prop, "Scene", "Scene that this sequence uses");
RNA_def_property_update(prop, NC_SCENE \| ND_SEQUENCER, "rna_Sequence_scene_switch_update");		RNA_def_property_update(prop, NC_SCENE \| ND_SEQUENCER, "rna_Sequence_scene_switch_update");

prop = RNA_def_property(srna, "scene_camera", PROP_POINTER, PROP_NONE);		prop = RNA_def_property(srna, "scene_camera", PROP_POINTER, PROP_NONE);
RNA_def_property_flag(prop, PROP_EDITABLE);		RNA_def_property_flag(prop, PROP_EDITABLE);
RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, "rna_Camera_object_poll");		RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, "rna_Camera_object_poll");
RNA_def_property_ui_text(prop, "Camera Override", "Override the scenes active camera");		RNA_def_property_ui_text(prop, "Camera Override", "Override the scenes active camera");
RNA_def_property_update(prop, NC_SCENE \| ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");		RNA_def_property_update(prop, NC_SCENE \| ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines	static void rna_def_movie(BlenderRNA *brna)
RNA_def_function_return(func, parm);		RNA_def_function_return(func, parm);

/* metadata */		/* metadata */
func = RNA_def_function(srna, "metadata", "rna_MovieSequence_metadata_get");		func = RNA_def_function(srna, "metadata", "rna_MovieSequence_metadata_get");
RNA_def_function_ui_description(func, "Retrieve metadata of the movie file");		RNA_def_function_ui_description(func, "Retrieve metadata of the movie file");
/* return type */		/* return type */
parm = RNA_def_pointer(		parm = RNA_def_pointer(
func, "metadata", "IDPropertyWrapPtr", "", "Dict-like object containing the metadata");		func, "metadata", "IDPropertyWrapPtr", "", "Dict-like object containing the metadata");
RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);		RNA_def_parameter_flags(parm, PropertyFlag(0), PARM_RNAPTR);
RNA_def_function_return(func, parm);		RNA_def_function_return(func, parm);

/* multiview */		/* multiview */
prop = RNA_def_property(srna, "use_multiview", PROP_BOOLEAN, PROP_NONE);		prop = RNA_def_property(srna, "use_multiview", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_VIEWS);		RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_VIEWS);
RNA_def_property_ui_text(prop, "Use Multi-View", "Use Multiple Views (when available)");		RNA_def_property_ui_text(prop, "Use Multi-View", "Use Multiple Views (when available)");
RNA_def_property_update(prop, NC_SCENE \| ND_SEQUENCER, "rna_Sequence_views_format_update");		RNA_def_property_update(prop, NC_SCENE \| ND_SEQUENCER, "rna_Sequence_views_format_update");

▲ Show 20 Lines • Show All 889 Lines • Show Last 20 Lines