Sequencer: initial support of refreshing only changed sequences
[blender.git] / source / blender / makesrna / intern / rna_sequencer.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Blender Foundation (2008)
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/makesrna/intern/rna_sequencer.c
24  *  \ingroup RNA
25  */
26
27
28 #include <stdlib.h>
29 #include <limits.h>
30
31 #include "RNA_access.h"
32 #include "RNA_define.h"
33
34 #include "rna_internal.h"
35
36 #include "DNA_anim_types.h"
37 #include "DNA_object_types.h"
38 #include "DNA_scene_types.h"
39 #include "DNA_sequence_types.h"
40 #include "DNA_movieclip_types.h"
41
42 #include "BKE_animsys.h"
43 #include "BKE_global.h"
44 #include "BKE_sequencer.h"
45 #include "BKE_sound.h"
46
47 #include "MEM_guardedalloc.h"
48
49 #include "WM_types.h"
50 #include "BLI_math.h"
51
52 typedef struct EffectInfo {
53         const char *struct_name;
54         const char *ui_name;
55         const char *ui_desc;
56         void (*func)(StructRNA *);
57         int inputs;
58 } EffectInfo;
59
60 #ifdef RNA_RUNTIME
61
62 typedef struct SequenceSearchData {
63         Sequence *seq;
64         void *data;
65 } SequenceSearchData;
66
67 /* build a temp reference to the parent */
68 static void meta_tmp_ref(Sequence *seq_par, Sequence *seq)
69 {
70         for (; seq; seq = seq->next) {
71                 seq->tmp = seq_par;
72                 if (seq->type == SEQ_TYPE_META) {
73                         meta_tmp_ref(seq, seq->seqbase.first);
74                 }
75         }
76 }
77
78 static void rna_SequenceEditor_sequences_all_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
79 {
80         Scene *scene = (Scene *)ptr->id.data;
81         Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
82
83         meta_tmp_ref(NULL, ed->seqbase.first);
84
85         rna_iterator_listbase_begin(iter, &ed->seqbase, NULL);
86 }
87
88 static void rna_SequenceEditor_sequences_all_next(CollectionPropertyIterator *iter)
89 {
90         ListBaseIterator *internal = iter->internal;
91         Sequence *seq = (Sequence *)internal->link;
92
93         if (seq->seqbase.first)
94                 internal->link = (Link *)seq->seqbase.first;
95         else if (seq->next)
96                 internal->link = (Link *)seq->next;
97         else {
98                 internal->link = NULL;
99
100                 do {
101                         seq = seq->tmp; /* XXX - seq's don't reference their parents! */
102                         if (seq && seq->next) {
103                                 internal->link = (Link *)seq->next;
104                                 break;
105                         }
106                 } while (seq);
107         }
108
109         iter->valid = (internal->link != NULL);
110 }
111
112 /* internal use */
113 static int rna_SequenceEditor_elements_length(PointerRNA *ptr)
114 {
115         Sequence *seq = (Sequence *)ptr->data;
116
117         /* Hack? copied from sequencer.c::reload_sequence_new_file() */
118         size_t olen = MEM_allocN_len(seq->strip->stripdata) / sizeof(struct StripElem);
119         
120         /* the problem with seq->strip->len and seq->len is that it's discounted from the offset (hard cut trim) */
121         return (int) olen;
122 }
123
124 static void rna_SequenceEditor_elements_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
125 {
126         Sequence *seq = (Sequence *)ptr->data;
127         rna_iterator_array_begin(iter, (void *)seq->strip->stripdata, sizeof(StripElem),
128                                  rna_SequenceEditor_elements_length(ptr), 0, NULL);
129 }
130
131 static void rna_Sequence_frame_change_update(Scene *scene, Sequence *seq)
132 {
133         Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
134         ListBase *seqbase = BKE_sequence_seqbase(&ed->seqbase, seq);
135         BKE_sequence_calc_disp(scene, seq);
136
137         if (BKE_sequence_test_overlap(seqbase, seq)) {
138                 BKE_sequence_base_shuffle(seqbase, seq, scene); /* XXX - BROKEN!, uses context seqbasep */
139         }
140         BKE_sequencer_sort(scene);
141 }
142
143 static void rna_Sequence_start_frame_set(PointerRNA *ptr, int value)
144 {
145         Sequence *seq = (Sequence *)ptr->data;
146         Scene *scene = (Scene *)ptr->id.data;
147         
148         BKE_sequence_translate(scene, seq, value - seq->start);
149         rna_Sequence_frame_change_update(scene, seq);
150 }
151
152 static void rna_Sequence_start_frame_final_set(PointerRNA *ptr, int value)
153 {
154         Sequence *seq = (Sequence *)ptr->data;
155         Scene *scene = (Scene *)ptr->id.data;
156
157         BKE_sequence_tx_set_final_left(seq, value);
158         BKE_sequence_single_fix(seq);
159         rna_Sequence_frame_change_update(scene, seq);
160 }
161
162 static void rna_Sequence_end_frame_final_set(PointerRNA *ptr, int value)
163 {
164         Sequence *seq = (Sequence *)ptr->data;
165         Scene *scene = (Scene *)ptr->id.data;
166
167         BKE_sequence_tx_set_final_right(seq, value);
168         BKE_sequence_single_fix(seq);
169         rna_Sequence_frame_change_update(scene, seq);
170 }
171
172 static void rna_Sequence_anim_startofs_final_set(PointerRNA *ptr, int value)
173 {
174         Sequence *seq = (Sequence *)ptr->data;
175         Scene *scene = (Scene *)ptr->id.data;
176
177         seq->anim_startofs = MIN2(value, seq->len + seq->anim_startofs);
178
179         BKE_sequence_reload_new_file(scene, seq, FALSE);
180         rna_Sequence_frame_change_update(scene, seq);
181 }
182
183 static void rna_Sequence_anim_endofs_final_set(PointerRNA *ptr, int value)
184 {
185         Sequence *seq = (Sequence *)ptr->data;
186         Scene *scene = (Scene *)ptr->id.data;
187
188         seq->anim_endofs = MIN2(value, seq->len + seq->anim_endofs);
189
190         BKE_sequence_reload_new_file(scene, seq, FALSE);
191         rna_Sequence_frame_change_update(scene, seq);
192 }
193
194 static void rna_Sequence_frame_length_set(PointerRNA *ptr, int value)
195 {
196         Sequence *seq = (Sequence *)ptr->data;
197         Scene *scene = (Scene *)ptr->id.data;
198         
199         BKE_sequence_tx_set_final_right(seq, seq->start + value);
200         rna_Sequence_frame_change_update(scene, seq);
201 }
202
203 static int rna_Sequence_frame_length_get(PointerRNA *ptr)
204 {
205         Sequence *seq = (Sequence *)ptr->data;
206         return BKE_sequence_tx_get_final_right(seq, 0) - BKE_sequence_tx_get_final_left(seq, 0);
207 }
208
209 static int rna_Sequence_frame_editable(PointerRNA *ptr)
210 {
211         Sequence *seq = (Sequence *)ptr->data;
212         /* Effect sequences' start frame and length must be readonly! */
213         return (BKE_sequence_effect_get_num_inputs(seq->type)) ? 0 : PROP_EDITABLE;
214 }
215
216 static void rna_Sequence_channel_set(PointerRNA *ptr, int value)
217 {
218         Sequence *seq = (Sequence *)ptr->data;
219         Scene *scene = (Scene *)ptr->id.data;
220         Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
221         ListBase *seqbase = BKE_sequence_seqbase(&ed->seqbase, seq);
222
223         seq->machine = value;
224         
225         if (BKE_sequence_test_overlap(seqbase, seq) ) {
226                 BKE_sequence_base_shuffle(seqbase, seq, scene);  /* XXX - BROKEN!, uses context seqbasep */
227         }
228         BKE_sequencer_sort(scene);
229 }
230
231 /* properties that need to allocate structs */
232 static void rna_Sequence_use_color_balance_set(PointerRNA *ptr, int value)
233 {
234         Sequence *seq = (Sequence *)ptr->data;
235         int c;
236         
237         if (value) {
238                 seq->flag |= SEQ_USE_COLOR_BALANCE;
239                 if (seq->strip->color_balance == NULL) {
240                         seq->strip->color_balance = MEM_callocN(sizeof(struct StripColorBalance), "StripColorBalance");
241                         for (c = 0; c < 3; c++) {
242                                 seq->strip->color_balance->lift[c] = 1.0f;
243                                 seq->strip->color_balance->gamma[c] = 1.0f;
244                                 seq->strip->color_balance->gain[c] = 1.0f;
245                         }
246                 }
247         }
248         else {
249                 seq->flag ^= SEQ_USE_COLOR_BALANCE;
250         }
251 }
252
253 static void rna_Sequence_use_proxy_set(PointerRNA *ptr, int value)
254 {
255         Sequence *seq = (Sequence *)ptr->data;
256         if (value) {
257                 seq->flag |= SEQ_USE_PROXY;
258                 if (seq->strip->proxy == NULL) {
259                         seq->strip->proxy = MEM_callocN(sizeof(struct StripProxy), "StripProxy");
260                         seq->strip->proxy->quality = 90;
261                         seq->strip->proxy->build_tc_flags = SEQ_PROXY_TC_ALL;
262                         seq->strip->proxy->build_size_flags = SEQ_PROXY_IMAGE_SIZE_25;
263                 }
264         }
265         else {
266                 seq->flag ^= SEQ_USE_PROXY;
267         }
268 }
269
270 static void rna_Sequence_use_translation_set(PointerRNA *ptr, int value)
271 {
272         Sequence *seq = (Sequence *)ptr->data;
273         if (value) {
274                 seq->flag |= SEQ_USE_TRANSFORM;
275                 if (seq->strip->transform == NULL) {
276                         seq->strip->transform = MEM_callocN(sizeof(struct StripTransform), "StripTransform");
277                 }
278         }
279         else {
280                 seq->flag ^= SEQ_USE_TRANSFORM;
281         }
282 }
283
284 static void rna_Sequence_use_crop_set(PointerRNA *ptr, int value)
285 {
286         Sequence *seq = (Sequence *)ptr->data;
287         if (value) {
288                 seq->flag |= SEQ_USE_CROP;
289                 if (seq->strip->crop == NULL) {
290                         seq->strip->crop = MEM_callocN(sizeof(struct StripCrop), "StripCrop");
291                 }
292         }
293         else {
294                 seq->flag ^= SEQ_USE_CROP;
295         }
296 }
297
298 static int transform_seq_cmp_cb(Sequence *seq, void *arg_pt)
299 {
300         SequenceSearchData *data = arg_pt;
301
302         if (seq->strip && seq->strip->transform == data->data) {
303                 data->seq = seq;
304                 return -1; /* done so bail out */
305         }
306         return 1;
307 }
308
309 static Sequence *sequence_get_by_transform(Editing *ed, StripTransform *transform)
310 {
311         SequenceSearchData data;
312
313         data.seq = NULL;
314         data.data = transform;
315
316         /* irritating we need to search for our sequence! */
317         BKE_sequencer_base_recursive_apply(&ed->seqbase, transform_seq_cmp_cb, &data);
318
319         return data.seq;
320 }
321
322 static char *rna_SequenceTransform_path(PointerRNA *ptr)
323 {
324         Scene *scene = ptr->id.data;
325         Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
326         Sequence *seq = sequence_get_by_transform(ed, ptr->data);
327
328         if (seq && seq->name + 2)
329                 return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"].transform", seq->name + 2);
330         else
331                 return BLI_strdup("");
332 }
333
334 static void rna_SequenceTransform_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
335 {
336         Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
337         Sequence *seq = sequence_get_by_transform(ed, ptr->data);
338
339         BKE_sequence_invalidate_cache(scene, seq);
340 }
341
342 static int crop_seq_cmp_cb(Sequence *seq, void *arg_pt)
343 {
344         SequenceSearchData *data = arg_pt;
345
346         if (seq->strip && seq->strip->crop == data->data) {
347                 data->seq = seq;
348                 return -1; /* done so bail out */
349         }
350         return 1;
351 }
352
353 static Sequence *sequence_get_by_crop(Editing *ed, StripCrop *crop)
354 {
355         SequenceSearchData data;
356
357         data.seq = NULL;
358         data.data = crop;
359
360         /* irritating we need to search for our sequence! */
361         BKE_sequencer_base_recursive_apply(&ed->seqbase, crop_seq_cmp_cb, &data);
362
363         return data.seq;
364 }
365
366 static char *rna_SequenceCrop_path(PointerRNA *ptr)
367 {
368         Scene *scene = ptr->id.data;
369         Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
370         Sequence *seq = sequence_get_by_crop(ed, ptr->data);
371
372         if (seq && seq->name + 2)
373                 return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"].crop", seq->name + 2);
374         else
375                 return BLI_strdup("");
376 }
377
378 static void rna_SequenceCrop_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
379 {
380         Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
381         Sequence *seq = sequence_get_by_crop(ed, ptr->data);
382
383         BKE_sequence_invalidate_cache(scene, seq);
384 }
385
386 /* name functions that ignore the first two characters */
387 static void rna_Sequence_name_get(PointerRNA *ptr, char *value)
388 {
389         Sequence *seq = (Sequence *)ptr->data;
390         BLI_strncpy(value, seq->name + 2, sizeof(seq->name) - 2);
391 }
392
393 static int rna_Sequence_name_length(PointerRNA *ptr)
394 {
395         Sequence *seq = (Sequence *)ptr->data;
396         return strlen(seq->name + 2);
397 }
398
399 static void rna_Sequence_name_set(PointerRNA *ptr, const char *value)
400 {
401         Scene *scene = (Scene *)ptr->id.data;
402         Sequence *seq = (Sequence *)ptr->data;
403         char oldname[sizeof(seq->name)];
404         AnimData *adt;
405         
406         /* make a copy of the old name first */
407         BLI_strncpy(oldname, seq->name + 2, sizeof(seq->name) - 2);
408         
409         /* copy the new name into the name slot */
410         BLI_strncpy_utf8(seq->name + 2, value, sizeof(seq->name) - 2);
411         
412         /* make sure the name is unique */
413         BKE_seqence_base_unique_name_recursive(&scene->ed->seqbase, seq);
414         
415         /* fix all the animation data which may link to this */
416
417         /* don't rename everywhere because these are per scene */
418         /* BKE_all_animdata_fix_paths_rename(NULL, "sequence_editor.sequences_all", oldname, seq->name+2); */
419         adt = BKE_animdata_from_id(&scene->id);
420         if (adt)
421                 BKE_animdata_fix_paths_rename(&scene->id, adt, NULL, "sequence_editor.sequences_all", oldname, seq->name + 2, 0, 0, 1);
422 }
423
424 static StructRNA *rna_Sequence_refine(struct PointerRNA *ptr)
425 {
426         Sequence *seq = (Sequence *)ptr->data;
427
428         switch (seq->type) {
429                 case SEQ_TYPE_IMAGE:
430                         return &RNA_ImageSequence;
431                 case SEQ_TYPE_META:
432                         return &RNA_MetaSequence;
433                 case SEQ_TYPE_SCENE:
434                         return &RNA_SceneSequence;
435                 case SEQ_TYPE_MOVIE:
436                         return &RNA_MovieSequence;
437                 case SEQ_TYPE_MOVIECLIP:
438                         return &RNA_MovieClipSequence;
439                 case SEQ_TYPE_MASK:
440                         return &RNA_MaskSequence;
441                 case SEQ_TYPE_SOUND_RAM:
442                         return &RNA_SoundSequence;
443                 case SEQ_TYPE_CROSS:
444                         return &RNA_CrossSequence;
445                 case SEQ_TYPE_ADD:
446                         return &RNA_AddSequence;
447                 case SEQ_TYPE_SUB:
448                         return &RNA_SubtractSequence;
449                 case SEQ_TYPE_ALPHAOVER:
450                         return &RNA_AlphaOverSequence;
451                 case SEQ_TYPE_ALPHAUNDER:
452                         return &RNA_AlphaUnderSequence;
453                 case SEQ_TYPE_GAMCROSS:
454                         return &RNA_GammaCrossSequence;
455                 case SEQ_TYPE_MUL:
456                         return &RNA_MultiplySequence;
457                 case SEQ_TYPE_OVERDROP:
458                         return &RNA_OverDropSequence;
459                 case SEQ_TYPE_MULTICAM:
460                         return &RNA_MulticamSequence;
461                 case SEQ_TYPE_ADJUSTMENT:
462                         return &RNA_AdjustmentSequence;
463                 case SEQ_TYPE_WIPE:
464                         return &RNA_WipeSequence;
465                 case SEQ_TYPE_GLOW:
466                         return &RNA_GlowSequence;
467                 case SEQ_TYPE_TRANSFORM:
468                         return &RNA_TransformSequence;
469                 case SEQ_TYPE_COLOR:
470                         return &RNA_ColorSequence;
471                 case SEQ_TYPE_SPEED:
472                         return &RNA_SpeedControlSequence;
473                 default:
474                         return &RNA_Sequence;
475         }
476 }
477
478 static char *rna_Sequence_path(PointerRNA *ptr)
479 {
480         Sequence *seq = (Sequence *)ptr->data;
481         
482         /* sequencer data comes from scene...
483          * TODO: would be nice to make SequenceEditor data a datablock of its own (for shorter paths)
484          */
485         if (seq->name + 2)
486                 return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"]", seq->name + 2);
487         else
488                 return BLI_strdup("");
489 }
490
491 static PointerRNA rna_SequenceEditor_meta_stack_get(CollectionPropertyIterator *iter)
492 {
493         ListBaseIterator *internal = iter->internal;
494         MetaStack *ms = (MetaStack *)internal->link;
495
496         return rna_pointer_inherit_refine(&iter->parent, &RNA_Sequence, ms->parseq);
497 }
498
499 /* TODO, expose seq path setting as a higher level sequencer BKE function */
500 static void rna_Sequence_filepath_set(PointerRNA *ptr, const char *value)
501 {
502         Sequence *seq = (Sequence *)(ptr->data);
503
504         if (seq->type == SEQ_TYPE_SOUND_RAM && seq->sound) {
505                 /* for sound strips we need to update the sound as well.
506                  * arguably, this could load in a new sound rather than modify an existing one.
507                  * but while using the sequencer its most likely your not using the sound in the game engine too.
508                  */
509                 PointerRNA id_ptr;
510                 RNA_id_pointer_create((ID *)seq->sound, &id_ptr);
511                 RNA_string_set(&id_ptr, "filepath", value);
512                 sound_load(G.main, seq->sound);
513                 sound_update_scene_sound(seq->scene_sound, seq->sound);
514         }
515
516         BLI_split_dirfile(value, seq->strip->dir, seq->strip->stripdata->name, sizeof(seq->strip->dir),
517                           sizeof(seq->strip->stripdata->name));
518 }
519
520 static void rna_Sequence_filepath_get(PointerRNA *ptr, char *value)
521 {
522         Sequence *seq = (Sequence *)(ptr->data);
523
524         BLI_join_dirfile(value, FILE_MAX, seq->strip->dir, seq->strip->stripdata->name);
525 }
526
527 static int rna_Sequence_filepath_length(PointerRNA *ptr)
528 {
529         Sequence *seq = (Sequence *)(ptr->data);
530         char path[FILE_MAX];
531
532         BLI_join_dirfile(path, sizeof(path), seq->strip->dir, seq->strip->stripdata->name);
533         return strlen(path);
534 }
535
536 static void rna_Sequence_proxy_filepath_set(PointerRNA *ptr, const char *value)
537 {
538         StripProxy *proxy = (StripProxy *)(ptr->data);
539         BLI_split_dirfile(value, proxy->dir, proxy->file, sizeof(proxy->dir), sizeof(proxy->file));
540 }
541
542 static void rna_Sequence_proxy_filepath_get(PointerRNA *ptr, char *value)
543 {
544         StripProxy *proxy = (StripProxy *)(ptr->data);
545
546         BLI_join_dirfile(value, FILE_MAX, proxy->dir, proxy->file);
547 }
548
549 static int rna_Sequence_proxy_filepath_length(PointerRNA *ptr)
550 {
551         StripProxy *proxy = (StripProxy *)(ptr->data);
552         char path[FILE_MAX];
553
554         BLI_join_dirfile(path, sizeof(path), proxy->dir, proxy->file);
555         return strlen(path);
556 }
557
558 static void rna_Sequence_volume_set(PointerRNA *ptr, float value)
559 {
560         Sequence *seq = (Sequence *)(ptr->data);
561
562         seq->volume = value;
563         if (seq->scene_sound)
564                 sound_set_scene_sound_volume(seq->scene_sound, value, (seq->flag & SEQ_AUDIO_VOLUME_ANIMATED) != 0);
565 }
566
567 static void rna_Sequence_pitch_set(PointerRNA *ptr, float value)
568 {
569         Sequence *seq = (Sequence *)(ptr->data);
570
571         seq->pitch = value;
572         if (seq->scene_sound)
573                 sound_set_scene_sound_pitch(seq->scene_sound, value, (seq->flag & SEQ_AUDIO_PITCH_ANIMATED) != 0);
574 }
575
576 static void rna_Sequence_pan_set(PointerRNA *ptr, float value)
577 {
578         Sequence *seq = (Sequence *)(ptr->data);
579
580         seq->pan = value;
581         if (seq->scene_sound)
582                 sound_set_scene_sound_pan(seq->scene_sound, value, (seq->flag & SEQ_AUDIO_PAN_ANIMATED) != 0);
583 }
584
585
586 static int rna_Sequence_input_count_get(PointerRNA *ptr)
587 {
588         Sequence *seq = (Sequence *)(ptr->data);
589
590         return BKE_sequence_effect_get_num_inputs(seq->type);
591 }
592
593 #if 0
594 static void rna_SoundSequence_filename_set(PointerRNA *ptr, const char *value)
595 {
596         Sequence *seq = (Sequence *)(ptr->data);
597         BLI_split_dirfile(value, seq->strip->dir, seq->strip->stripdata->name, sizeof(seq->strip->dir),
598                           sizeof(seq->strip->stripdata->name));
599 }
600
601 static void rna_SequenceElement_filename_set(PointerRNA *ptr, const char *value)
602 {
603         StripElem *elem = (StripElem *)(ptr->data);
604         BLI_split_file_part(value, elem->name, sizeof(elem->name));
605 }
606 #endif
607
608 static void rna_Sequence_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
609 {
610         Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
611
612         if (ed) {
613                 Sequence *seq = (Sequence *) ptr->data;
614
615                 BKE_sequence_invalidate_cache(scene, seq);
616         }
617 }
618
619 static void rna_Sequence_update_reopen_files(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
620 {
621         Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
622
623         BKE_sequencer_free_imbuf(scene, &ed->seqbase, FALSE, FALSE);
624
625         if (RNA_struct_is_a(ptr->type, &RNA_SoundSequence))
626                 BKE_sequencer_update_sound_bounds(scene, ptr->data);
627 }
628
629 static void rna_Sequence_mute_update(Main *bmain, Scene *scene, PointerRNA *ptr)
630 {
631         Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
632
633         BKE_sequencer_update_muting(ed);
634         rna_Sequence_update(bmain, scene, ptr);
635 }
636
637 static void rna_Sequence_filepath_update(Main *bmain, Scene *scene, PointerRNA *ptr)
638 {
639         Sequence *seq = (Sequence *)(ptr->data);
640         BKE_sequence_reload_new_file(scene, seq, TRUE);
641         BKE_sequence_calc(scene, seq);
642         rna_Sequence_update(bmain, scene, ptr);
643 }
644
645 static int seqproxy_seq_cmp_cb(Sequence *seq, void *arg_pt)
646 {
647         SequenceSearchData *data = arg_pt;
648
649         if (seq->strip && seq->strip->proxy == data->data) {
650                 data->seq = seq;
651                 return -1; /* done so bail out */
652         }
653         return 1;
654 }
655
656 static Sequence *sequence_get_by_proxy(Editing *ed, StripProxy *proxy)
657 {
658         SequenceSearchData data;
659
660         data.seq = NULL;
661         data.data = proxy;
662
663         BKE_sequencer_base_recursive_apply(&ed->seqbase, seqproxy_seq_cmp_cb, &data);
664         return data.seq;
665 }
666
667 static void rna_Sequence_tcindex_update(Main *bmain, Scene *scene, PointerRNA *ptr)
668 {
669         Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
670         Sequence *seq = sequence_get_by_proxy(ed, ptr->data);
671
672         BKE_sequence_reload_new_file(scene, seq, FALSE);
673         rna_Sequence_frame_change_update(scene, seq);
674 }
675
676 static void rna_SequenceProxy_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
677 {
678         Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
679         Sequence *seq = sequence_get_by_proxy(ed, ptr->data);
680
681         BKE_sequence_invalidate_cache(scene, seq);
682 }
683
684 /* do_versions? */
685 static float rna_Sequence_opacity_get(PointerRNA *ptr)
686 {
687         Sequence *seq = (Sequence *)(ptr->data);
688         return seq->blend_opacity / 100.0f;
689 }
690 static void rna_Sequence_opacity_set(PointerRNA *ptr, float value)
691 {
692         Sequence *seq = (Sequence *)(ptr->data);
693         CLAMP(value, 0.0f, 1.0f);
694         seq->blend_opacity = value * 100.0f;
695 }
696
697 static int colbalance_seq_cmp_cb(Sequence *seq, void *arg_pt)
698 {
699         SequenceSearchData *data = arg_pt;
700
701         if (seq->strip && seq->strip->color_balance == data->data) {
702                 data->seq = seq;
703                 return -1; /* done so bail out */
704         }
705         return 1;
706 }
707
708 static Sequence *sequence_get_by_colorbalance(Editing *ed, StripColorBalance *cb)
709 {
710         SequenceSearchData data;
711
712         data.seq = NULL;
713         data.data = cb;
714
715         /* irritating we need to search for our sequence! */
716         BKE_sequencer_base_recursive_apply(&ed->seqbase, colbalance_seq_cmp_cb, &data);
717
718         return data.seq;
719 }
720
721 static char *rna_SequenceColorBalance_path(PointerRNA *ptr)
722 {
723         Scene *scene = ptr->id.data;
724         Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
725         Sequence *seq = sequence_get_by_colorbalance(ed, ptr->data);
726
727         if (seq && seq->name + 2)
728                 return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"].color_balance", seq->name + 2);
729         else
730                 return BLI_strdup("");
731 }
732
733 static void rna_SequenceColorBalance_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
734 {
735         Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
736         Sequence *seq = sequence_get_by_colorbalance(ed, ptr->data);
737
738         BKE_sequence_invalidate_cache(scene, seq);
739 }
740
741 static void rna_SequenceEditor_overlay_lock_set(PointerRNA *ptr, int value)
742 {
743         Scene *scene = ptr->id.data;
744         Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
745
746         if (ed == NULL)
747                 return;
748
749         /* convert from abs to relative and back */
750         if ((ed->over_flag & SEQ_EDIT_OVERLAY_ABS) == 0 && value) {
751                 ed->over_cfra = scene->r.cfra + ed->over_ofs;
752                 ed->over_flag |= SEQ_EDIT_OVERLAY_ABS;
753         }
754         else if ((ed->over_flag & SEQ_EDIT_OVERLAY_ABS) && !value) {
755                 ed->over_ofs = ed->over_cfra - scene->r.cfra;
756                 ed->over_flag &= ~SEQ_EDIT_OVERLAY_ABS;
757         }
758 }
759
760 static int rna_SequenceEditor_overlay_frame_get(PointerRNA *ptr)
761 {
762         Scene *scene = (Scene *)ptr->id.data;
763         Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
764
765         if (ed == NULL)
766                 return scene->r.cfra;
767
768         if (ed->over_flag & SEQ_EDIT_OVERLAY_ABS)
769                 return ed->over_cfra - scene->r.cfra;
770         else
771                 return ed->over_ofs;
772
773 }
774
775 static void rna_SequenceEditor_overlay_frame_set(PointerRNA *ptr, int value)
776 {
777         Scene *scene = (Scene *)ptr->id.data;
778         Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
779
780         if (ed == NULL)
781                 return;
782
783
784         if (ed->over_flag & SEQ_EDIT_OVERLAY_ABS)
785                 ed->over_cfra = (scene->r.cfra + value);
786         else
787                 ed->over_ofs = value;
788 }
789
790
791 static void rna_WipeSequence_angle_set(PointerRNA *ptr, float value)
792 {
793         Sequence *seq = (Sequence *)(ptr->data);
794         value = RAD2DEGF(value);
795         CLAMP(value, -90.0f, 90.0f);
796         ((WipeVars *)seq->effectdata)->angle = value;
797 }
798
799 static float rna_WipeSequence_angle_get(PointerRNA *ptr)
800 {
801         Sequence *seq = (Sequence *)(ptr->data);
802
803         return DEG2RADF(((WipeVars *)seq->effectdata)->angle);
804 }
805
806
807 #else
808
809 static void rna_def_strip_element(BlenderRNA *brna)
810 {
811         StructRNA *srna;
812         PropertyRNA *prop;
813         
814         srna = RNA_def_struct(brna, "SequenceElement", NULL);
815         RNA_def_struct_ui_text(srna, "Sequence Element", "Sequence strip data for a single frame");
816         RNA_def_struct_sdna(srna, "StripElem");
817         
818         prop = RNA_def_property(srna, "filename", PROP_STRING, PROP_FILENAME);
819         RNA_def_property_string_sdna(prop, NULL, "name");
820         RNA_def_property_ui_text(prop, "Filename", "");
821         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
822
823         prop = RNA_def_property(srna, "orig_width", PROP_INT, PROP_NONE);
824         RNA_def_property_int_sdna(prop, NULL, "orig_width");
825         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
826         RNA_def_property_ui_text(prop, "Orig Width", "Original image width");
827
828         prop = RNA_def_property(srna, "orig_height", PROP_INT, PROP_NONE);
829         RNA_def_property_int_sdna(prop, NULL, "orig_height");
830         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
831         RNA_def_property_ui_text(prop, "Orig Height", "Original image height");
832 }
833
834 static void rna_def_strip_crop(BlenderRNA *brna)
835 {
836         StructRNA *srna;
837         PropertyRNA *prop;
838         
839         srna = RNA_def_struct(brna, "SequenceCrop", NULL);
840         RNA_def_struct_ui_text(srna, "Sequence Crop", "Cropping parameters for a sequence strip");
841         RNA_def_struct_sdna(srna, "StripCrop");
842
843         prop = RNA_def_property(srna, "max_y", PROP_INT, PROP_UNSIGNED);
844         RNA_def_property_int_sdna(prop, NULL, "top");
845         RNA_def_property_ui_text(prop, "Top", "");
846         RNA_def_property_ui_range(prop, 0, 4096, 1, 0);
847         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceCrop_update");
848         
849         prop = RNA_def_property(srna, "min_y", PROP_INT, PROP_UNSIGNED);
850         RNA_def_property_int_sdna(prop, NULL, "bottom");
851         RNA_def_property_ui_text(prop, "Bottom", "");
852         RNA_def_property_ui_range(prop, 0, 4096, 1, 0);
853         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceCrop_update");
854         
855         prop = RNA_def_property(srna, "min_x", PROP_INT, PROP_UNSIGNED);
856         RNA_def_property_int_sdna(prop, NULL, "left");
857         RNA_def_property_ui_text(prop, "Left", "");
858         RNA_def_property_ui_range(prop, 0, 4096, 1, 0);
859         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceCrop_update");
860
861         prop = RNA_def_property(srna, "max_x", PROP_INT, PROP_UNSIGNED);
862         RNA_def_property_int_sdna(prop, NULL, "right");
863         RNA_def_property_ui_text(prop, "Right", "");
864         RNA_def_property_ui_range(prop, 0, 4096, 1, 0);
865         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceCrop_update");
866
867         RNA_def_struct_path_func(srna, "rna_SequenceCrop_path");
868 }
869
870 static void rna_def_strip_transform(BlenderRNA *brna)
871 {
872         StructRNA *srna;
873         PropertyRNA *prop;
874         
875         srna = RNA_def_struct(brna, "SequenceTransform", NULL);
876         RNA_def_struct_ui_text(srna, "Sequence Transform", "Transform parameters for a sequence strip");
877         RNA_def_struct_sdna(srna, "StripTransform");
878
879         prop = RNA_def_property(srna, "offset_x", PROP_INT, PROP_NONE);
880         RNA_def_property_int_sdna(prop, NULL, "xofs");
881         RNA_def_property_ui_text(prop, "Offset X", "");
882         RNA_def_property_ui_range(prop, -4096, 4096, 1, 0);
883         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceTransform_update");
884
885         prop = RNA_def_property(srna, "offset_y", PROP_INT, PROP_NONE);
886         RNA_def_property_int_sdna(prop, NULL, "yofs");
887         RNA_def_property_ui_text(prop, "Offset Y", "");
888         RNA_def_property_ui_range(prop, -4096, 4096, 1, 0);
889         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceTransform_update");
890
891         RNA_def_struct_path_func(srna, "rna_SequenceTransform_path");
892
893 }
894
895 static void rna_def_strip_proxy(BlenderRNA *brna)
896 {
897         StructRNA *srna;
898         PropertyRNA *prop;
899
900         static const EnumPropertyItem seq_tc_items[] = {
901                 {SEQ_PROXY_TC_NONE, "NONE", 0, "No TC in use", ""},
902                 {SEQ_PROXY_TC_RECORD_RUN, "RECORD_RUN", 0, "Record Run",
903                                           "Use images in the order as they are recorded"},
904                 {SEQ_PROXY_TC_FREE_RUN, "FREE_RUN", 0, "Free Run",
905                                         "Use global timestamp written by recording device"},
906                 {SEQ_PROXY_TC_INTERP_REC_DATE_FREE_RUN, "FREE_RUN_REC_DATE", 0, "Free Run (rec date)",
907                                                         "Interpolate a global timestamp using the "
908                                                         "record date and time written by recording device"},
909                 {SEQ_PROXY_TC_RECORD_RUN_NO_GAPS, "RECORD_RUN_NO_GAPS", 0, "Record Run No Gaps",
910                                                         "Like record run, but ignore timecode, "
911                                                         "changes in framerate or dropouts"},
912                 {0, NULL, 0, NULL, NULL}
913         };
914         
915         srna = RNA_def_struct(brna, "SequenceProxy", NULL);
916         RNA_def_struct_ui_text(srna, "Sequence Proxy", "Proxy parameters for a sequence strip");
917         RNA_def_struct_sdna(srna, "StripProxy");
918         
919         prop = RNA_def_property(srna, "directory", PROP_STRING, PROP_DIRPATH);
920         RNA_def_property_string_sdna(prop, NULL, "dir");
921         RNA_def_property_ui_text(prop, "Directory", "Location to store the proxy files");
922         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceProxy_update");
923         
924         prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
925         RNA_def_property_ui_text(prop, "Path", "Location of custom proxy file");
926         RNA_def_property_string_funcs(prop, "rna_Sequence_proxy_filepath_get", "rna_Sequence_proxy_filepath_length",
927                                       "rna_Sequence_proxy_filepath_set");
928
929         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceProxy_update");
930
931         prop = RNA_def_property(srna, "build_25", PROP_BOOLEAN, PROP_NONE);
932         RNA_def_property_boolean_sdna(prop, NULL, "build_size_flags", SEQ_PROXY_IMAGE_SIZE_25);
933         RNA_def_property_ui_text(prop, "25%", "Build 25% proxy resolution");
934
935         prop = RNA_def_property(srna, "build_50", PROP_BOOLEAN, PROP_NONE);
936         RNA_def_property_boolean_sdna(prop, NULL, "build_size_flags", SEQ_PROXY_IMAGE_SIZE_50);
937         RNA_def_property_ui_text(prop, "50%", "Build 50% proxy resolution");
938
939         prop = RNA_def_property(srna, "build_75", PROP_BOOLEAN, PROP_NONE);
940         RNA_def_property_boolean_sdna(prop, NULL, "build_size_flags", SEQ_PROXY_IMAGE_SIZE_75);
941         RNA_def_property_ui_text(prop, "75%", "Build 75% proxy resolution");
942
943         prop = RNA_def_property(srna, "build_100", PROP_BOOLEAN, PROP_NONE);
944         RNA_def_property_boolean_sdna(prop, NULL, "build_size_flags", SEQ_PROXY_IMAGE_SIZE_100);
945         RNA_def_property_ui_text(prop, "100%", "Build 100% proxy resolution");
946
947         prop = RNA_def_property(srna, "build_record_run", PROP_BOOLEAN, PROP_NONE);
948         RNA_def_property_boolean_sdna(prop, NULL, "build_tc_flags", SEQ_PROXY_TC_RECORD_RUN);
949         RNA_def_property_ui_text(prop, "Rec Run", "Build record run time code index");
950
951         prop = RNA_def_property(srna, "build_free_run", PROP_BOOLEAN, PROP_NONE);
952         RNA_def_property_boolean_sdna(prop, NULL, "build_tc_flags", SEQ_PROXY_TC_FREE_RUN);
953         RNA_def_property_ui_text(prop, "Free Run", "Build free run time code index");
954
955         prop = RNA_def_property(srna, "build_free_run_rec_date", PROP_BOOLEAN, PROP_NONE);
956         RNA_def_property_boolean_sdna(prop, NULL, "build_tc_flags", SEQ_PROXY_TC_INTERP_REC_DATE_FREE_RUN);
957         RNA_def_property_ui_text(prop, "Free Run (Rec Date)", "Build free run time code index using Record Date/Time");
958
959         prop = RNA_def_property(srna, "quality", PROP_INT, PROP_UNSIGNED);
960         RNA_def_property_int_sdna(prop, NULL, "quality");
961         RNA_def_property_ui_text(prop, "Quality", "JPEG Quality of proxies to build");
962         RNA_def_property_ui_range(prop, 1, 100, 1, 0);
963
964         prop = RNA_def_property(srna, "timecode", PROP_ENUM, PROP_NONE);
965         RNA_def_property_enum_sdna(prop, NULL, "tc");
966         RNA_def_property_enum_items(prop, seq_tc_items);
967         RNA_def_property_ui_text(prop, "Timecode", "");
968         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_tcindex_update");
969
970 }
971
972 static void rna_def_strip_color_balance(BlenderRNA *brna)
973 {
974         StructRNA *srna;
975         PropertyRNA *prop;
976
977         srna = RNA_def_struct(brna, "SequenceColorBalance", NULL);
978         RNA_def_struct_ui_text(srna, "Sequence Color Balance", "Color balance parameters for a sequence strip");
979         RNA_def_struct_sdna(srna, "StripColorBalance");
980
981         prop = RNA_def_property(srna, "lift", PROP_FLOAT, PROP_COLOR);
982         RNA_def_property_ui_text(prop, "Lift", "Color balance lift (shadows)");
983         RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
984         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceColorBalance_update");
985         
986         prop = RNA_def_property(srna, "gamma", PROP_FLOAT, PROP_COLOR);
987         RNA_def_property_ui_text(prop, "Gamma", "Color balance gamma (midtones)");
988         RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
989         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceColorBalance_update");
990         
991         prop = RNA_def_property(srna, "gain", PROP_FLOAT, PROP_COLOR);
992         RNA_def_property_ui_text(prop, "Gain", "Color balance gain (highlights)");
993         RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
994         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceColorBalance_update");
995         
996         prop = RNA_def_property(srna, "invert_gain", PROP_BOOLEAN, PROP_NONE);
997         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_COLOR_BALANCE_INVERSE_GAIN);
998         RNA_def_property_ui_text(prop, "Inverse Gain", "");
999         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceColorBalance_update");
1000
1001         prop = RNA_def_property(srna, "invert_gamma", PROP_BOOLEAN, PROP_NONE);
1002         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_COLOR_BALANCE_INVERSE_GAMMA);
1003         RNA_def_property_ui_text(prop, "Inverse Gamma", "");
1004         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceColorBalance_update");
1005
1006         prop = RNA_def_property(srna, "invert_lift", PROP_BOOLEAN, PROP_NONE);
1007         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_COLOR_BALANCE_INVERSE_LIFT);
1008         RNA_def_property_ui_text(prop, "Inverse Lift", "");
1009         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceColorBalance_update");
1010
1011         RNA_def_struct_path_func(srna, "rna_SequenceColorBalance_path");
1012
1013         /* not yet used */
1014 #if 0
1015         prop = RNA_def_property(srna, "exposure", PROP_FLOAT, PROP_NONE);
1016         RNA_def_property_range(prop, 0.0f, 1.0f);
1017         RNA_def_property_ui_text(prop, "Exposure", "");
1018         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_ColorBabalnce_update");
1019         
1020         prop = RNA_def_property(srna, "saturation", PROP_FLOAT, PROP_NONE);
1021         RNA_def_property_range(prop, 0.0f, 1.0f);
1022         RNA_def_property_ui_text(prop, "Saturation", "");
1023         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_ColorBabalnce_update");
1024 #endif
1025 }
1026
1027 EnumPropertyItem blend_mode_items[] = {
1028         {SEQ_BLEND_REPLACE, "REPLACE", 0, "Replace", ""},
1029         {SEQ_TYPE_CROSS, "CROSS", 0, "Cross", ""},
1030         {SEQ_TYPE_ADD, "ADD", 0, "Add", ""},
1031         {SEQ_TYPE_SUB, "SUBTRACT", 0, "Subtract", ""},
1032         {SEQ_TYPE_ALPHAOVER, "ALPHA_OVER", 0, "Alpha Over", ""},
1033         {SEQ_TYPE_ALPHAUNDER, "ALPHA_UNDER", 0, "Alpha Under", ""},
1034         {SEQ_TYPE_GAMCROSS, "GAMMA_CROSS", 0, "Gamma Cross", ""},
1035         {SEQ_TYPE_MUL, "MULTIPLY", 0, "Multiply", ""},
1036         {SEQ_TYPE_OVERDROP, "OVER_DROP", 0, "Over Drop", ""},
1037         {0, NULL, 0, NULL, NULL}
1038 };
1039
1040 static void rna_def_sequence(BlenderRNA *brna)
1041 {
1042         StructRNA *srna;
1043         PropertyRNA *prop;
1044
1045         static const EnumPropertyItem seq_type_items[] = {
1046                 {SEQ_TYPE_IMAGE, "IMAGE", 0, "Image", ""},
1047                 {SEQ_TYPE_META, "META", 0, "Meta", ""},
1048                 {SEQ_TYPE_SCENE, "SCENE", 0, "Scene", ""},
1049                 {SEQ_TYPE_MOVIE, "MOVIE", 0, "Movie", ""},
1050                 {SEQ_TYPE_MOVIECLIP, "MOVIECLIP", 0, "Clip", ""},
1051                 {SEQ_TYPE_MASK, "MASK", 0, "Mask", ""},
1052                 {SEQ_TYPE_SOUND_RAM, "SOUND", 0, "Sound", ""},
1053                 {SEQ_TYPE_CROSS, "CROSS", 0, "Cross", ""},
1054                 {SEQ_TYPE_ADD, "ADD", 0, "Add", ""},
1055                 {SEQ_TYPE_SUB, "SUBTRACT", 0, "Subtract", ""},
1056                 {SEQ_TYPE_ALPHAOVER, "ALPHA_OVER", 0, "Alpha Over", ""},
1057                 {SEQ_TYPE_ALPHAUNDER, "ALPHA_UNDER", 0, "Alpha Under", ""},
1058                 {SEQ_TYPE_GAMCROSS, "GAMMA_CROSS", 0, "Gamma Cross", ""},
1059                 {SEQ_TYPE_MUL, "MULTIPLY", 0, "Multiply", ""},
1060                 {SEQ_TYPE_OVERDROP, "OVER_DROP", 0, "Over Drop", ""},
1061                 {SEQ_TYPE_WIPE, "WIPE", 0, "Wipe", ""},
1062                 {SEQ_TYPE_GLOW, "GLOW", 0, "Glow", ""},
1063                 {SEQ_TYPE_TRANSFORM, "TRANSFORM", 0, "Transform", ""},
1064                 {SEQ_TYPE_COLOR, "COLOR", 0, "Color", ""},
1065                 {SEQ_TYPE_SPEED, "SPEED", 0, "Speed", ""},
1066                 {SEQ_TYPE_MULTICAM, "MULTICAM", 0, "Multicam Selector", ""},
1067                 {SEQ_TYPE_ADJUSTMENT, "ADJUSTMENT", 0, "Adjustment Layer", ""},
1068                 {0, NULL, 0, NULL, NULL}
1069         };
1070         
1071         srna = RNA_def_struct(brna, "Sequence", NULL);
1072         RNA_def_struct_ui_text(srna, "Sequence", "Sequence strip in the sequence editor");
1073         RNA_def_struct_refine_func(srna, "rna_Sequence_refine");
1074         RNA_def_struct_path_func(srna, "rna_Sequence_path");
1075
1076         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1077         RNA_def_property_string_funcs(prop, "rna_Sequence_name_get", "rna_Sequence_name_length", "rna_Sequence_name_set");
1078         RNA_def_property_string_maxlength(prop, sizeof(((Sequence *)NULL)->name) - 2);
1079         RNA_def_property_ui_text(prop, "Name", "");
1080         RNA_def_struct_name_property(srna, prop);
1081         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
1082
1083         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1084         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1085         RNA_def_property_enum_items(prop, seq_type_items);
1086         RNA_def_property_ui_text(prop, "Type", "");
1087         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1088
1089
1090         /* flags */
1091         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1092         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
1093         RNA_def_property_ui_text(prop, "Select", "");
1094         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER | NA_SELECTED, NULL);
1095
1096         prop = RNA_def_property(srna, "select_left_handle", PROP_BOOLEAN, PROP_NONE);
1097         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_LEFTSEL);
1098         RNA_def_property_ui_text(prop, "Left Handle Selected", "");
1099         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER | NA_SELECTED, NULL);
1100
1101         prop = RNA_def_property(srna, "select_right_handle", PROP_BOOLEAN, PROP_NONE);
1102         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_RIGHTSEL);
1103         RNA_def_property_ui_text(prop, "Right Handle Selected", "");
1104         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER | NA_SELECTED, NULL);
1105
1106         prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
1107         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_MUTE);
1108         RNA_def_property_ui_text(prop, "Mute", "");
1109         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_mute_update");
1110
1111         prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
1112         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_LOCK);
1113         RNA_def_property_ui_text(prop, "Lock", "Lock strip so that it can't be transformed");
1114         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
1115
1116         /* strip positioning */
1117         prop = RNA_def_property(srna, "frame_final_duration", PROP_INT, PROP_TIME);
1118         RNA_def_property_range(prop, 1, MAXFRAME);
1119         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1120         RNA_def_property_ui_text(prop, "Length", "The length of the contents of this strip after the handles are applied");
1121         RNA_def_property_int_funcs(prop, "rna_Sequence_frame_length_get", "rna_Sequence_frame_length_set", NULL);
1122         RNA_def_property_editable_func(prop, "rna_Sequence_frame_editable");
1123         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1124
1125         prop = RNA_def_property(srna, "frame_duration", PROP_INT, PROP_TIME);
1126         RNA_def_property_int_sdna(prop, NULL, "len");
1127         RNA_def_property_clear_flag(prop, PROP_EDITABLE | PROP_ANIMATABLE);
1128         RNA_def_property_range(prop, 1, MAXFRAME);
1129         RNA_def_property_ui_text(prop, "Length",
1130                                  "The length of the contents of this strip before the handles are applied");
1131         
1132         prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_TIME);
1133         RNA_def_property_int_sdna(prop, NULL, "start");
1134         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1135         RNA_def_property_ui_text(prop, "Start Frame", "");
1136         RNA_def_property_int_funcs(prop, NULL, "rna_Sequence_start_frame_set", NULL); /* overlap tests and calc_seq_disp */
1137         RNA_def_property_editable_func(prop, "rna_Sequence_frame_editable");
1138         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1139         
1140         prop = RNA_def_property(srna, "frame_final_start", PROP_INT, PROP_TIME);
1141         RNA_def_property_int_sdna(prop, NULL, "startdisp");
1142         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1143         RNA_def_property_ui_text(prop, "Start Frame",
1144                                  "Start frame displayed in the sequence editor after offsets are applied, setting this is "
1145                                  "equivalent to moving the handle, not the actual start frame");
1146         /* overlap tests and calc_seq_disp */
1147         RNA_def_property_int_funcs(prop, NULL, "rna_Sequence_start_frame_final_set", NULL);
1148         RNA_def_property_editable_func(prop, "rna_Sequence_frame_editable");
1149         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1150
1151         prop = RNA_def_property(srna, "frame_final_end", PROP_INT, PROP_TIME);
1152         RNA_def_property_int_sdna(prop, NULL, "enddisp");
1153         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1154         RNA_def_property_ui_text(prop, "End Frame",
1155                                  "End frame displayed in the sequence editor after offsets are applied");
1156         /* overlap tests and calc_seq_disp */
1157         RNA_def_property_int_funcs(prop, NULL, "rna_Sequence_end_frame_final_set", NULL);
1158         RNA_def_property_editable_func(prop, "rna_Sequence_frame_editable");
1159         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1160
1161         prop = RNA_def_property(srna, "frame_offset_start", PROP_INT, PROP_TIME);
1162         RNA_def_property_int_sdna(prop, NULL, "startofs");
1163         RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* overlap tests */
1164         RNA_def_property_ui_text(prop, "Start Offset", "");
1165         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1166         
1167         prop = RNA_def_property(srna, "frame_offset_end", PROP_INT, PROP_TIME);
1168         RNA_def_property_int_sdna(prop, NULL, "endofs");
1169         RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* overlap tests */
1170         RNA_def_property_ui_text(prop, "End Offset", "");
1171         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1172         
1173         prop = RNA_def_property(srna, "frame_still_start", PROP_INT, PROP_TIME);
1174         RNA_def_property_int_sdna(prop, NULL, "startstill");
1175         RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* overlap tests */
1176         RNA_def_property_range(prop, 0, MAXFRAME);
1177         RNA_def_property_ui_text(prop, "Start Still", "");
1178         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1179         
1180         prop = RNA_def_property(srna, "frame_still_end", PROP_INT, PROP_TIME);
1181         RNA_def_property_int_sdna(prop, NULL, "endstill");
1182         RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* overlap tests */
1183         RNA_def_property_range(prop, 0, MAXFRAME);
1184         RNA_def_property_ui_text(prop, "End Still", "");
1185         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1186         
1187         prop = RNA_def_property(srna, "channel", PROP_INT, PROP_UNSIGNED);
1188         RNA_def_property_int_sdna(prop, NULL, "machine");
1189         RNA_def_property_range(prop, 0, MAXSEQ - 1);
1190         RNA_def_property_ui_text(prop, "Channel", "Y position of the sequence strip");
1191         RNA_def_property_int_funcs(prop, NULL, "rna_Sequence_channel_set", NULL); /* overlap test */
1192         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1193
1194         /* blending */
1195
1196         prop = RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
1197         RNA_def_property_enum_sdna(prop, NULL, "blend_mode");
1198         RNA_def_property_enum_items(prop, blend_mode_items);
1199         RNA_def_property_ui_text(prop, "Blend Mode", "");
1200         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1201         
1202         prop = RNA_def_property(srna, "blend_alpha", PROP_FLOAT, PROP_FACTOR);
1203         RNA_def_property_range(prop, 0.0f, 1.0f);
1204         RNA_def_property_ui_text(prop, "Blend Opacity", "");
1205         /* stupid 0-100 -> 0-1 */
1206         RNA_def_property_float_funcs(prop, "rna_Sequence_opacity_get", "rna_Sequence_opacity_set", NULL);
1207         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1208         
1209         prop = RNA_def_property(srna, "effect_fader", PROP_FLOAT, PROP_NONE);
1210         RNA_def_property_range(prop, 0.0f, 1.0f);
1211         RNA_def_property_float_sdna(prop, NULL, "effect_fader");
1212         RNA_def_property_ui_text(prop, "Effect fader position", "");
1213         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1214
1215         prop = RNA_def_property(srna, "use_default_fade", PROP_BOOLEAN, PROP_NONE);
1216         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_EFFECT_DEFAULT_FADE);
1217         RNA_def_property_ui_text(prop, "Use Default Fade",
1218                                  "Fade effect using the built-in default (usually make transition as long as "
1219                                  "effect strip)");
1220         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1221         
1222
1223         prop = RNA_def_property(srna, "speed_factor", PROP_FLOAT, PROP_NONE);
1224         RNA_def_property_float_sdna(prop, NULL, "speed_fader");
1225         RNA_def_property_ui_text(prop, "Speed factor",
1226                                  "Multiply the current speed of the sequence with this number or remap current frame "
1227                                  "to this frame");
1228         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1229
1230         RNA_api_sequence_strip(srna);
1231 }
1232
1233 static void rna_def_editor(BlenderRNA *brna)
1234 {
1235         StructRNA *srna;
1236         PropertyRNA *prop;
1237         
1238         srna = RNA_def_struct(brna, "SequenceEditor", NULL);
1239         RNA_def_struct_ui_text(srna, "Sequence Editor", "Sequence editing data for a Scene datablock");
1240         RNA_def_struct_ui_icon(srna, ICON_SEQUENCE);
1241         RNA_def_struct_sdna(srna, "Editing");
1242
1243         prop = RNA_def_property(srna, "sequences", PROP_COLLECTION, PROP_NONE);
1244         RNA_def_property_collection_sdna(prop, NULL, "seqbase", NULL);
1245         RNA_def_property_struct_type(prop, "Sequence");
1246         RNA_def_property_ui_text(prop, "Sequences", "");
1247         RNA_api_sequences(brna, prop);
1248
1249         prop = RNA_def_property(srna, "sequences_all", PROP_COLLECTION, PROP_NONE);
1250         RNA_def_property_collection_sdna(prop, NULL, "seqbase", NULL);
1251         RNA_def_property_struct_type(prop, "Sequence");
1252         RNA_def_property_ui_text(prop, "Sequences", "");
1253         RNA_def_property_collection_funcs(prop, "rna_SequenceEditor_sequences_all_begin",
1254                                           "rna_SequenceEditor_sequences_all_next", NULL, NULL, NULL, NULL, NULL, NULL);
1255
1256         prop = RNA_def_property(srna, "meta_stack", PROP_COLLECTION, PROP_NONE);
1257         RNA_def_property_collection_sdna(prop, NULL, "metastack", NULL);
1258         RNA_def_property_struct_type(prop, "Sequence");
1259         RNA_def_property_ui_text(prop, "Meta Stack", "Meta strip stack, last is currently edited meta strip");
1260         RNA_def_property_collection_funcs(prop, NULL, NULL, NULL, "rna_SequenceEditor_meta_stack_get",
1261                                           NULL, NULL, NULL, NULL);
1262         
1263         prop = RNA_def_property(srna, "active_strip", PROP_POINTER, PROP_NONE);
1264         RNA_def_property_pointer_sdna(prop, NULL, "act_seq");
1265         RNA_def_property_flag(prop, PROP_EDITABLE);
1266         RNA_def_property_ui_text(prop, "Active Strip", "Sequencer's active strip");
1267
1268         prop = RNA_def_property(srna, "show_overlay", PROP_BOOLEAN, PROP_NONE);
1269         RNA_def_property_boolean_sdna(prop, NULL, "over_flag", SEQ_EDIT_OVERLAY_SHOW);
1270         RNA_def_property_ui_text(prop, "Draw Axes", "Partial overlay on top of the sequencer");
1271         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_SEQUENCER, NULL);
1272
1273         prop = RNA_def_property(srna, "overlay_lock", PROP_BOOLEAN, PROP_NONE);
1274         RNA_def_property_boolean_sdna(prop, NULL, "over_flag", SEQ_EDIT_OVERLAY_ABS);
1275         RNA_def_property_ui_text(prop, "Overlay Lock", "");
1276         RNA_def_property_boolean_funcs(prop, NULL, "rna_SequenceEditor_overlay_lock_set");
1277         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_SEQUENCER, NULL);
1278
1279         /* access to fixed and relative frame */
1280         prop = RNA_def_property(srna, "overlay_frame", PROP_INT, PROP_NONE);
1281         RNA_def_property_ui_text(prop, "Overlay Offset", "");
1282         RNA_def_property_int_funcs(prop, "rna_SequenceEditor_overlay_frame_get",
1283                                    "rna_SequenceEditor_overlay_frame_set", NULL);
1284         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_SEQUENCER, NULL);
1285 }
1286
1287 static void rna_def_filter_video(StructRNA *srna)
1288 {
1289         PropertyRNA *prop;
1290
1291         prop = RNA_def_property(srna, "use_deinterlace", PROP_BOOLEAN, PROP_NONE);
1292         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_FILTERY);
1293         RNA_def_property_ui_text(prop, "De-Interlace", "For video movies to remove fields");
1294         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update_reopen_files");
1295
1296         prop = RNA_def_property(srna, "use_premultiply", PROP_BOOLEAN, PROP_NONE);
1297         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_MAKE_PREMUL);
1298         RNA_def_property_ui_text(prop, "Premultiply", "Convert RGB from key alpha to premultiplied alpha");
1299         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1300
1301         prop = RNA_def_property(srna, "use_flip_x", PROP_BOOLEAN, PROP_NONE);
1302         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_FLIPX);
1303         RNA_def_property_ui_text(prop, "Flip X", "Flip on the X axis");
1304         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1305
1306         prop = RNA_def_property(srna, "use_flip_y", PROP_BOOLEAN, PROP_NONE);
1307         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_FLIPY);
1308         RNA_def_property_ui_text(prop, "Flip Y", "Flip on the Y axis");
1309         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1310
1311         prop = RNA_def_property(srna, "use_float", PROP_BOOLEAN, PROP_NONE);
1312         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_MAKE_FLOAT);
1313         RNA_def_property_ui_text(prop, "Convert Float", "Convert input to float data");
1314         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1315
1316         prop = RNA_def_property(srna, "use_reverse_frames", PROP_BOOLEAN, PROP_NONE);
1317         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_REVERSE_FRAMES);
1318         RNA_def_property_ui_text(prop, "Flip Time", "Reverse frame order");
1319         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1320
1321         prop = RNA_def_property(srna, "color_multiply", PROP_FLOAT, PROP_UNSIGNED);
1322         RNA_def_property_float_sdna(prop, NULL, "mul");
1323         RNA_def_property_range(prop, 0.0f, 20.0f);
1324         RNA_def_property_ui_text(prop, "Multiply Colors", "");
1325         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1326
1327         prop = RNA_def_property(srna, "color_saturation", PROP_FLOAT, PROP_UNSIGNED);
1328         RNA_def_property_float_sdna(prop, NULL, "sat");
1329         RNA_def_property_range(prop, 0.0f, 20.0f);
1330         RNA_def_property_ui_range(prop, 0.0f, 2.0f, 3, 3);
1331         RNA_def_property_ui_text(prop, "Saturation", "");
1332         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1333
1334         prop = RNA_def_property(srna, "strobe", PROP_FLOAT, PROP_NONE);
1335         RNA_def_property_range(prop, 1.0f, 30.0f);
1336         RNA_def_property_ui_text(prop, "Strobe", "Only display every nth frame");
1337         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1338
1339         prop = RNA_def_property(srna, "use_color_balance", PROP_BOOLEAN, PROP_NONE);
1340         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_COLOR_BALANCE);
1341         RNA_def_property_ui_text(prop, "Use Color Balance", "(3-Way color correction) on input");
1342         RNA_def_property_boolean_funcs(prop, NULL, "rna_Sequence_use_color_balance_set");
1343         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1344
1345         prop = RNA_def_property(srna, "color_balance", PROP_POINTER, PROP_NONE);
1346         RNA_def_property_pointer_sdna(prop, NULL, "strip->color_balance");
1347         RNA_def_property_ui_text(prop, "Color Balance", "");
1348
1349         prop = RNA_def_property(srna, "use_translation", PROP_BOOLEAN, PROP_NONE);
1350         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_TRANSFORM);
1351         RNA_def_property_ui_text(prop, "Use Translation", "Translate image before processing");
1352         RNA_def_property_boolean_funcs(prop, NULL, "rna_Sequence_use_translation_set");
1353         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1354
1355         prop = RNA_def_property(srna, "transform", PROP_POINTER, PROP_NONE);
1356         RNA_def_property_pointer_sdna(prop, NULL, "strip->transform");
1357         RNA_def_property_ui_text(prop, "Transform", "");
1358
1359         prop = RNA_def_property(srna, "use_crop", PROP_BOOLEAN, PROP_NONE);
1360         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_CROP);
1361         RNA_def_property_ui_text(prop, "Use Crop", "Crop image before processing");
1362         RNA_def_property_boolean_funcs(prop, NULL, "rna_Sequence_use_crop_set");
1363         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1364
1365         prop = RNA_def_property(srna, "crop", PROP_POINTER, PROP_NONE);
1366         RNA_def_property_pointer_sdna(prop, NULL, "strip->crop");
1367         RNA_def_property_ui_text(prop, "Crop", "");
1368 }
1369
1370 static void rna_def_proxy(StructRNA *srna)
1371 {
1372         PropertyRNA *prop;
1373
1374         prop = RNA_def_property(srna, "use_proxy", PROP_BOOLEAN, PROP_NONE);
1375         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_PROXY);
1376         RNA_def_property_ui_text(prop, "Use Proxy / Timecode", "Use a preview proxy and/or timecode index for this strip");
1377         RNA_def_property_boolean_funcs(prop, NULL, "rna_Sequence_use_proxy_set");
1378
1379         prop = RNA_def_property(srna, "proxy", PROP_POINTER, PROP_NONE);
1380         RNA_def_property_pointer_sdna(prop, NULL, "strip->proxy");
1381         RNA_def_property_ui_text(prop, "Proxy", "");
1382
1383         prop = RNA_def_property(srna, "use_proxy_custom_directory", PROP_BOOLEAN, PROP_NONE);
1384         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_PROXY_CUSTOM_DIR);
1385         RNA_def_property_ui_text(prop, "Proxy Custom Directory", "Use a custom directory to store data");
1386         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1387
1388         prop = RNA_def_property(srna, "use_proxy_custom_file", PROP_BOOLEAN, PROP_NONE);
1389         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_PROXY_CUSTOM_FILE);
1390         RNA_def_property_ui_text(prop, "Proxy Custom File", "Use a custom file to read proxy data from");
1391         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1392 }
1393
1394 static void rna_def_input(StructRNA *srna)
1395 {
1396         PropertyRNA *prop;
1397
1398         prop = RNA_def_property(srna, "animation_offset_start", PROP_INT, PROP_UNSIGNED);
1399         RNA_def_property_int_sdna(prop, NULL, "anim_startofs");
1400         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1401         RNA_def_property_int_funcs(prop, NULL, "rna_Sequence_anim_startofs_final_set", NULL); /* overlap tests */
1402
1403         RNA_def_property_ui_text(prop, "Animation Start Offset", "Animation start offset (trim start)");
1404         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1405         
1406         prop = RNA_def_property(srna, "animation_offset_end", PROP_INT, PROP_UNSIGNED);
1407         RNA_def_property_int_sdna(prop, NULL, "anim_endofs");
1408         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1409         RNA_def_property_int_funcs(prop, NULL, "rna_Sequence_anim_endofs_final_set", NULL); /* overlap tests */
1410         RNA_def_property_ui_text(prop, "Animation End Offset", "Animation end offset (trim end)");
1411         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1412 }
1413
1414 static void rna_def_effect_inputs(StructRNA *srna, int count)
1415 {
1416         PropertyRNA *prop;
1417
1418         prop = RNA_def_property(srna, "input_count", PROP_INT, PROP_UNSIGNED);
1419         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1420         RNA_def_property_int_funcs(prop, "rna_Sequence_input_count_get", NULL, NULL);
1421
1422         if (count >= 1) {
1423                 prop = RNA_def_property(srna, "input_1",  PROP_POINTER, PROP_NONE);
1424                 RNA_def_property_pointer_sdna(prop, NULL, "seq1");
1425                 RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
1426                 RNA_def_property_ui_text(prop, "Input 1", "First input for the effect strip");
1427         }
1428
1429         if (count >= 2) {
1430                 prop = RNA_def_property(srna, "input_2",  PROP_POINTER, PROP_NONE);
1431                 RNA_def_property_pointer_sdna(prop, NULL, "seq2");
1432                 RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
1433                 RNA_def_property_ui_text(prop, "Input 2", "Second input for the effect strip");
1434         }
1435
1436         /*
1437         if (count == 3) { // not used by any effects (perhaps one day plugins?)
1438                 prop = RNA_def_property(srna, "input_3",  PROP_POINTER, PROP_NONE);
1439                 RNA_def_property_pointer_sdna(prop, NULL, "seq3");
1440                 RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
1441                 RNA_def_property_ui_text(prop, "Input 3", "Third input for the effect strip");
1442         }
1443         */
1444 }
1445
1446 static void rna_def_image(BlenderRNA *brna)
1447 {
1448         StructRNA *srna;
1449         PropertyRNA *prop;
1450         
1451         srna = RNA_def_struct(brna, "ImageSequence", "Sequence");
1452         RNA_def_struct_ui_text(srna, "Image Sequence", "Sequence strip to load one or more images");
1453         RNA_def_struct_sdna(srna, "Sequence");
1454
1455         prop = RNA_def_property(srna, "directory", PROP_STRING, PROP_DIRPATH);
1456         RNA_def_property_string_sdna(prop, NULL, "strip->dir");
1457         RNA_def_property_ui_text(prop, "Directory", "");
1458         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1459
1460         prop = RNA_def_property(srna, "elements", PROP_COLLECTION, PROP_NONE);
1461         RNA_def_property_collection_sdna(prop, NULL, "strip->stripdata", NULL);
1462         RNA_def_property_struct_type(prop, "SequenceElement");
1463         RNA_def_property_ui_text(prop, "Elements", "");
1464         RNA_def_property_collection_funcs(prop, "rna_SequenceEditor_elements_begin", "rna_iterator_array_next",
1465                                           "rna_iterator_array_end", "rna_iterator_array_get",
1466                                           "rna_SequenceEditor_elements_length", NULL, NULL, NULL);
1467         RNA_api_sequence_elements(brna, prop);
1468
1469         rna_def_filter_video(srna);
1470         rna_def_proxy(srna);
1471         rna_def_input(srna);
1472 }
1473
1474 static void rna_def_meta(BlenderRNA *brna)
1475 {
1476         StructRNA *srna;
1477         PropertyRNA *prop;
1478         
1479         srna = RNA_def_struct(brna, "MetaSequence", "Sequence");
1480         RNA_def_struct_ui_text(srna, "Meta Sequence", "Sequence strip to group other strips as a single sequence strip");
1481         RNA_def_struct_sdna(srna, "Sequence");
1482
1483         prop = RNA_def_property(srna, "sequences", PROP_COLLECTION, PROP_NONE);
1484         RNA_def_property_collection_sdna(prop, NULL, "seqbase", NULL);
1485         RNA_def_property_struct_type(prop, "Sequence");
1486         RNA_def_property_ui_text(prop, "Sequences", "");
1487
1488         rna_def_filter_video(srna);
1489         rna_def_proxy(srna);
1490         rna_def_input(srna);
1491 }
1492
1493 static void rna_def_scene(BlenderRNA *brna)
1494 {
1495         StructRNA *srna;
1496         PropertyRNA *prop;
1497         
1498         srna = RNA_def_struct(brna, "SceneSequence", "Sequence");
1499         RNA_def_struct_ui_text(srna, "Scene Sequence", "Sequence strip to used the rendered image of a scene");
1500         RNA_def_struct_sdna(srna, "Sequence");
1501
1502         prop = RNA_def_property(srna, "scene", PROP_POINTER, PROP_NONE);
1503         RNA_def_property_flag(prop, PROP_EDITABLE);
1504         RNA_def_property_ui_text(prop, "Scene", "Scene that this sequence uses");
1505         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1506
1507         prop = RNA_def_property(srna, "scene_camera", PROP_POINTER, PROP_NONE);
1508         RNA_def_property_flag(prop, PROP_EDITABLE);
1509         RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, "rna_Camera_object_poll");
1510         RNA_def_property_ui_text(prop, "Camera Override", "Override the scenes active camera");
1511         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1512
1513         rna_def_filter_video(srna);
1514         rna_def_proxy(srna);
1515         rna_def_input(srna);
1516 }
1517
1518 static void rna_def_movie(BlenderRNA *brna)
1519 {
1520         StructRNA *srna;
1521         PropertyRNA *prop;
1522         
1523         srna = RNA_def_struct(brna, "MovieSequence", "Sequence");
1524         RNA_def_struct_ui_text(srna, "Movie Sequence", "Sequence strip to load a video");
1525         RNA_def_struct_sdna(srna, "Sequence");
1526
1527         prop = RNA_def_property(srna, "mpeg_preseek", PROP_INT, PROP_NONE);
1528         RNA_def_property_int_sdna(prop, NULL, "anim_preseek");
1529         RNA_def_property_range(prop, 0, 50);
1530         RNA_def_property_ui_text(prop, "MPEG Preseek", "For MPEG movies, preseek this many frames");
1531         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1532
1533         prop = RNA_def_property(srna, "stream_index", PROP_INT, PROP_NONE);
1534         RNA_def_property_int_sdna(prop, NULL, "streamindex");
1535         RNA_def_property_range(prop, 0, 20);
1536         RNA_def_property_ui_text(prop, "Stream Index",
1537                                  "For files with several movie streams, use the stream with the given index");
1538         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update_reopen_files");
1539
1540         prop = RNA_def_property(srna, "elements", PROP_COLLECTION, PROP_NONE);
1541         RNA_def_property_collection_sdna(prop, NULL, "strip->stripdata", NULL);
1542         RNA_def_property_struct_type(prop, "SequenceElement");
1543         RNA_def_property_ui_text(prop, "Elements", "");
1544         RNA_def_property_collection_funcs(prop, "rna_SequenceEditor_elements_begin", "rna_iterator_array_next",
1545                                           "rna_iterator_array_end", "rna_iterator_array_get",
1546                                           "rna_SequenceEditor_elements_length", NULL, NULL, NULL);
1547
1548         prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
1549         RNA_def_property_ui_text(prop, "File", "");
1550         RNA_def_property_string_funcs(prop, "rna_Sequence_filepath_get", "rna_Sequence_filepath_length",
1551                                       "rna_Sequence_filepath_set");
1552         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_filepath_update");
1553
1554         rna_def_filter_video(srna);
1555         rna_def_proxy(srna);
1556         rna_def_input(srna);
1557 }
1558
1559 static void rna_def_movieclip(BlenderRNA *brna)
1560 {
1561         StructRNA *srna;
1562         PropertyRNA *prop;
1563         
1564         srna = RNA_def_struct(brna, "MovieClipSequence", "Sequence");
1565         RNA_def_struct_ui_text(srna, "MovieClip Sequence", "Sequence strip to load a video from the clip editor");
1566         RNA_def_struct_sdna(srna, "Sequence");
1567
1568         /* TODO - add clip property? */
1569
1570         prop = RNA_def_property(srna, "undistort", PROP_BOOLEAN, PROP_NONE);
1571         RNA_def_property_boolean_sdna(prop, NULL, "clip_flag", SEQ_MOVIECLIP_RENDER_UNDISTORTED);
1572         RNA_def_property_ui_text(prop, "Undistort Clip", "Use the undistorted version of the clip");
1573         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1574
1575         prop = RNA_def_property(srna, "stabilize2d", PROP_BOOLEAN, PROP_NONE);
1576         RNA_def_property_boolean_sdna(prop, NULL, "clip_flag", SEQ_MOVIECLIP_RENDER_STABILIZED);
1577         RNA_def_property_ui_text(prop, "Stabilize 2D Clip", "Use the 2D stabilized version of the clip");
1578         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1579
1580         rna_def_filter_video(srna);
1581         rna_def_input(srna);
1582 }
1583
1584 static void rna_def_mask(BlenderRNA *brna)
1585 {
1586         StructRNA *srna;
1587         PropertyRNA *prop;
1588
1589         srna = RNA_def_struct(brna, "MaskSequence", "Sequence");
1590         RNA_def_struct_ui_text(srna, "Mask Sequence", "Sequence strip to load a video from a mask");
1591         RNA_def_struct_sdna(srna, "Sequence");
1592
1593         prop = RNA_def_property(srna, "mask", PROP_POINTER, PROP_NONE);
1594         RNA_def_property_flag(prop, PROP_EDITABLE);
1595         RNA_def_property_ui_text(prop, "Mask", "Mask that this sequence uses");
1596         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1597
1598         rna_def_filter_video(srna);
1599         rna_def_input(srna);
1600 }
1601
1602 static void rna_def_sound(BlenderRNA *brna)
1603 {
1604         StructRNA *srna;
1605         PropertyRNA *prop;
1606         
1607         srna = RNA_def_struct(brna, "SoundSequence", "Sequence");
1608         RNA_def_struct_ui_text(srna, "Sound Sequence",
1609                                "Sequence strip defining a sound to be played over a period of time");
1610         RNA_def_struct_sdna(srna, "Sequence");
1611
1612         prop = RNA_def_property(srna, "sound", PROP_POINTER, PROP_NONE);
1613         RNA_def_property_struct_type(prop, "Sound");
1614         RNA_def_property_ui_text(prop, "Sound", "Sound datablock used by this sequence");
1615         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1616
1617         prop = RNA_def_property(srna, "volume", PROP_FLOAT, PROP_NONE);
1618         RNA_def_property_float_sdna(prop, NULL, "volume");
1619         RNA_def_property_range(prop, 0.0f, 100.0f);
1620         RNA_def_property_ui_text(prop, "Volume", "Playback volume of the sound");
1621         RNA_def_property_float_funcs(prop, NULL, "rna_Sequence_volume_set", NULL);
1622         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1623
1624         prop = RNA_def_property(srna, "pitch", PROP_FLOAT, PROP_NONE);
1625         RNA_def_property_float_sdna(prop, NULL, "pitch");
1626         RNA_def_property_range(prop, 0.1f, 10.0f);
1627         RNA_def_property_ui_text(prop, "Pitch", "Playback pitch of the sound");
1628         RNA_def_property_float_funcs(prop, NULL, "rna_Sequence_pitch_set", NULL);
1629         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1630
1631         prop = RNA_def_property(srna, "pan", PROP_FLOAT, PROP_NONE);
1632         RNA_def_property_float_sdna(prop, NULL, "pan");
1633         RNA_def_property_range(prop, -2.0f, 2.0f);
1634         RNA_def_property_ui_text(prop, "Pan", "Playback panning of the sound (only for Mono sources)");
1635         RNA_def_property_float_funcs(prop, NULL, "rna_Sequence_pan_set", NULL);
1636         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1637
1638         prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
1639         RNA_def_property_ui_text(prop, "File", "");
1640         RNA_def_property_string_funcs(prop, "rna_Sequence_filepath_get", "rna_Sequence_filepath_length",
1641                                       "rna_Sequence_filepath_set");
1642         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_filepath_update");
1643
1644         prop = RNA_def_property(srna, "show_waveform", PROP_BOOLEAN, PROP_NONE);
1645         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_AUDIO_DRAW_WAVEFORM);
1646         RNA_def_property_ui_text(prop, "Draw Waveform", "Whether to draw the sound's waveform");
1647         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
1648         
1649         rna_def_input(srna);
1650 }
1651
1652 static void rna_def_effect(BlenderRNA *brna)
1653 {
1654         StructRNA *srna;
1655
1656         srna = RNA_def_struct(brna, "EffectSequence", "Sequence");
1657         RNA_def_struct_ui_text(srna, "Effect Sequence",
1658                                "Sequence strip applying an effect on the images created by other strips");
1659         RNA_def_struct_sdna(srna, "Sequence");
1660
1661         rna_def_filter_video(srna);
1662         rna_def_proxy(srna);
1663 }
1664
1665 static void rna_def_multicam(StructRNA *srna)
1666 {
1667         PropertyRNA *prop;
1668         
1669         prop = RNA_def_property(srna, "multicam_source", PROP_INT, PROP_UNSIGNED);
1670         RNA_def_property_int_sdna(prop, NULL, "multicam_source");
1671         RNA_def_property_range(prop, 0, MAXSEQ - 1);
1672         RNA_def_property_ui_text(prop, "Multicam Source Channel", "");
1673         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1674
1675         rna_def_input(srna);
1676 }
1677
1678 static void rna_def_wipe(StructRNA *srna)
1679 {
1680         PropertyRNA *prop;
1681         
1682         static const EnumPropertyItem wipe_type_items[] = {
1683                 {0, "SINGLE", 0, "Single", ""},
1684                 {1, "DOUBLE", 0, "Double", ""},
1685                 /* not used yet {2, "BOX", 0, "Box", ""}, */
1686                 /* not used yet {3, "CROSS", 0, "Cross", ""}, */
1687                 {4, "IRIS", 0, "Iris", ""},
1688                 {5, "CLOCK", 0, "Clock", ""},
1689                 {0, NULL, 0, NULL, NULL}
1690         };
1691
1692         static const EnumPropertyItem wipe_direction_items[] = {
1693                 {0, "OUT", 0, "Out", ""},
1694                 {1, "IN", 0, "In", ""},
1695                 {0, NULL, 0, NULL, NULL}
1696         };
1697
1698         RNA_def_struct_sdna_from(srna, "WipeVars", "effectdata");
1699
1700         prop = RNA_def_property(srna, "blur_width", PROP_FLOAT, PROP_UNSIGNED);
1701         RNA_def_property_float_sdna(prop, NULL, "edgeWidth");
1702         RNA_def_property_range(prop, 0.0f, 1.0f);
1703         RNA_def_property_ui_text(prop, "Blur Width",
1704                                  "Width of the blur edge, in percentage relative to the image size");
1705         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1706
1707 #if 1 /* expose as radians */
1708         prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
1709         RNA_def_property_float_funcs(prop, "rna_WipeSequence_angle_get", "rna_WipeSequence_angle_set", NULL);
1710         RNA_def_property_range(prop, DEG2RAD(-90.0), DEG2RAD(90.0));
1711 #else
1712         prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_NONE);
1713         RNA_def_property_float_sdna(prop, NULL, "angle");
1714         RNA_def_property_range(prop, -90.0f, 90.0f);
1715 #endif
1716         RNA_def_property_ui_text(prop, "Angle", "Edge angle");
1717         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1718         
1719         prop = RNA_def_property(srna, "direction", PROP_ENUM, PROP_NONE);
1720         RNA_def_property_enum_sdna(prop, NULL, "forward");
1721         RNA_def_property_enum_items(prop, wipe_direction_items);
1722         RNA_def_property_ui_text(prop, "Direction", "Wipe direction");
1723         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1724         
1725         prop = RNA_def_property(srna, "transition_type", PROP_ENUM, PROP_NONE);
1726         RNA_def_property_enum_sdna(prop, NULL, "wipetype");
1727         RNA_def_property_enum_items(prop, wipe_type_items);
1728         RNA_def_property_ui_text(prop, "Transition Type", "");
1729         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1730 }
1731
1732 static void rna_def_glow(StructRNA *srna)
1733 {
1734         PropertyRNA *prop;
1735
1736         RNA_def_struct_sdna_from(srna, "GlowVars", "effectdata");
1737         
1738         prop = RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_NONE);
1739         RNA_def_property_float_sdna(prop, NULL, "fMini");
1740         RNA_def_property_range(prop, 0.0f, 1.0f);
1741         RNA_def_property_ui_text(prop, "Threshold", "Minimum intensity to trigger a glow");
1742         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1743         
1744         prop = RNA_def_property(srna, "clamp", PROP_FLOAT, PROP_NONE);
1745         RNA_def_property_float_sdna(prop, NULL, "fClamp");
1746         RNA_def_property_range(prop, 0.0f, 1.0f);
1747         RNA_def_property_ui_text(prop, "Clamp", "Brightness limit of intensity");
1748         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1749         
1750         prop = RNA_def_property(srna, "boost_factor", PROP_FLOAT, PROP_NONE);
1751         RNA_def_property_float_sdna(prop, NULL, "fBoost");
1752         RNA_def_property_range(prop, 0.0f, 10.0f);
1753         RNA_def_property_ui_text(prop, "Boost Factor", "Brightness multiplier");
1754         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1755         
1756         prop = RNA_def_property(srna, "blur_radius", PROP_FLOAT, PROP_NONE);
1757         RNA_def_property_float_sdna(prop, NULL, "dDist");
1758         RNA_def_property_range(prop, 0.5f, 20.0f);
1759         RNA_def_property_ui_text(prop, "Blur Distance", "Radius of glow effect");
1760         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1761         
1762         prop = RNA_def_property(srna, "quality", PROP_INT, PROP_NONE);
1763         RNA_def_property_int_sdna(prop, NULL, "dQuality");
1764         RNA_def_property_range(prop, 1, 5);
1765         RNA_def_property_ui_text(prop, "Quality", "Accuracy of the blur effect");
1766         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1767         
1768         prop = RNA_def_property(srna, "use_only_boost", PROP_BOOLEAN, PROP_NONE);
1769         RNA_def_property_boolean_sdna(prop, NULL, "bNoComp", 0);
1770         RNA_def_property_ui_text(prop, "Only Boost", "Show the glow buffer only");
1771         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1772 }
1773
1774 static void rna_def_transform(StructRNA *srna)
1775 {
1776         PropertyRNA *prop;
1777
1778         static const EnumPropertyItem interpolation_items[] = {
1779                 {0, "NONE", 0, "None", "No interpolation"},
1780                 {1, "BILINEAR", 0, "Bilinear", "Bilinear interpolation"},
1781                 {2, "BICUBIC", 0, "Bicubic", "Bicubic interpolation"},
1782                 {0, NULL, 0, NULL, NULL}
1783         };
1784
1785         static const EnumPropertyItem translation_unit_items[] = {
1786                 {0, "PIXELS", 0, "Pixels", ""},
1787                 {1, "PERCENT", 0, "Percent", ""},
1788                 {0, NULL, 0, NULL, NULL}
1789         };
1790
1791         RNA_def_struct_sdna_from(srna, "TransformVars", "effectdata");
1792
1793         prop = RNA_def_property(srna, "scale_start_x", PROP_FLOAT, PROP_UNSIGNED);
1794         RNA_def_property_float_sdna(prop, NULL, "ScalexIni");
1795         RNA_def_property_ui_text(prop, "Scale X", "");
1796         RNA_def_property_ui_range(prop, 0, 10, 3, 10);
1797         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1798         
1799         prop = RNA_def_property(srna, "scale_start_y", PROP_FLOAT, PROP_UNSIGNED);
1800         RNA_def_property_float_sdna(prop, NULL, "ScaleyIni");
1801         RNA_def_property_ui_text(prop, "Scale Y", "");
1802         RNA_def_property_ui_range(prop, 0, 10, 3, 10);
1803         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1804         
1805         prop = RNA_def_property(srna, "use_uniform_scale", PROP_BOOLEAN, PROP_NONE);
1806         RNA_def_property_boolean_sdna(prop, NULL, "uniform_scale", 0);
1807         RNA_def_property_ui_text(prop, "Uniform Scale", "Scale uniformly, preserving aspect ratio");
1808         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1809         
1810         prop = RNA_def_property(srna, "translate_start_x", PROP_FLOAT, PROP_NONE);
1811         RNA_def_property_float_sdna(prop, NULL, "xIni");
1812         RNA_def_property_ui_text(prop, "Translate X", "");
1813         RNA_def_property_ui_range(prop, -500.0f, 500.0f, 3, 10);
1814         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1815         
1816         prop = RNA_def_property(srna, "translate_start_y", PROP_FLOAT, PROP_NONE);
1817         RNA_def_property_float_sdna(prop, NULL, "yIni");
1818         RNA_def_property_ui_text(prop, "Translate Y", "");
1819         RNA_def_property_ui_range(prop, -500.0f, 500.0f, 3, 10);
1820         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1821         
1822         prop = RNA_def_property(srna, "rotation_start", PROP_FLOAT, PROP_NONE);
1823         RNA_def_property_float_sdna(prop, NULL, "rotIni");
1824         RNA_def_property_range(prop, -360.0f, 360.0f);
1825         RNA_def_property_ui_text(prop, "Rotation", "");
1826         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1827         
1828         prop = RNA_def_property(srna, "translation_unit", PROP_ENUM, PROP_NONE);
1829         RNA_def_property_enum_sdna(prop, NULL, "percent");
1830         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); /* not meant to be animated */
1831         RNA_def_property_enum_items(prop, translation_unit_items);
1832         RNA_def_property_ui_text(prop, "Translation Unit", "");
1833         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1834         
1835         prop = RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
1836         RNA_def_property_enum_items(prop, interpolation_items);
1837         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); /* not meant to be animated */
1838         RNA_def_property_ui_text(prop, "Interpolation", "");
1839         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1840 }
1841
1842 static void rna_def_solid_color(StructRNA *srna)
1843 {
1844         PropertyRNA *prop;
1845
1846         RNA_def_struct_sdna_from(srna, "SolidColorVars", "effectdata");
1847
1848         prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
1849         RNA_def_property_float_sdna(prop, NULL, "col");
1850         RNA_def_property_ui_text(prop, "Color", "");
1851         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1852 }
1853
1854 static void rna_def_speed_control(StructRNA *srna)
1855 {
1856         PropertyRNA *prop;
1857
1858         RNA_def_struct_sdna_from(srna, "SpeedControlVars", "effectdata");
1859
1860         prop = RNA_def_property(srna, "multiply_speed", PROP_FLOAT, PROP_UNSIGNED);
1861         RNA_def_property_float_sdna(prop, NULL, "globalSpeed");
1862         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); /* seq->facf0 is used to animate this */
1863         RNA_def_property_ui_text(prop, "Multiply Speed", "Multiply the resulting speed after the speed factor");
1864         RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 0);
1865         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1866         
1867         prop = RNA_def_property(srna, "use_as_speed", PROP_BOOLEAN, PROP_NONE);
1868         RNA_def_property_boolean_sdna(prop, NULL, "flags", SEQ_SPEED_INTEGRATE);
1869         RNA_def_property_ui_text(prop, "Use as speed", "Interpret the value as speed instead of a frame number");
1870         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1871
1872         prop = RNA_def_property(srna, "use_frame_blend", PROP_BOOLEAN, PROP_NONE);
1873         RNA_def_property_boolean_sdna(prop, NULL, "flags", SEQ_SPEED_BLEND);
1874         RNA_def_property_ui_text(prop, "Frame Blending", "Blend two frames into the target for a smoother result");
1875         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1876
1877         prop = RNA_def_property(srna, "scale_to_length", PROP_BOOLEAN, PROP_NONE);
1878         RNA_def_property_boolean_sdna(prop, NULL, "flags", SEQ_SPEED_COMPRESS_IPO_Y);
1879         RNA_def_property_ui_text(prop, "Scale to length", "Scale values from 0.0 to 1.0 to target sequence length");
1880         RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_update");
1881 }
1882
1883 static EffectInfo def_effects[] = {
1884         {"AddSequence", "Add Sequence",
1885          "Add Sequence",
1886          NULL, 2},
1887         {"AdjustmentSequence", "Adjustment Layer Sequence",
1888          "Sequence strip to perform filter adjustments to layers below",
1889          rna_def_input, 0},
1890         {"AlphaOverSequence", "Alpha Over Sequence",
1891          "Alpha Over Sequence",
1892          NULL, 2},
1893         {"AlphaUnderSequence", "Alpha Under Sequence",
1894          "Alpha Under Sequence",
1895          NULL, 2},
1896         {"ColorSequence", "Color Sequence",
1897          "Sequence strip creating an image filled with a single color",
1898          rna_def_solid_color, 0},
1899         {"CrossSequence", "Cross Sequence",
1900          "Cross Sequence",
1901          NULL, 2},
1902         {"GammaCrossSequence", "Gamma Cross Sequence",
1903          "Gamma Cross Sequence",
1904          NULL, 2},
1905         {"GlowSequence", "Glow Sequence",
1906          "Sequence strip creating a glow effect",
1907          rna_def_glow, 1},
1908         {"MulticamSequence", "Multicam Select Sequence",
1909          "Sequence strip to perform multicam editing",
1910          rna_def_multicam, 0},
1911         {"MultiplySequence", "Multiply Sequence",
1912          "Multiply Sequence",
1913          NULL, 2},
1914         {"OverDropSequence", "Over Drop Sequence",
1915          "Over Drop Sequence",
1916          NULL, 2},
1917         {"SpeedControlSequence", "SpeedControl Sequence",
1918          "Sequence strip to control the speed of other strips",
1919          rna_def_speed_control, 1},
1920         {"SubtractSequence", "Subtract Sequence",
1921          "Subtract Sequence",
1922          NULL, 2},
1923         {"TransformSequence", "Transform Sequence",
1924          "Sequence strip applying affine transformations to other strips",
1925          rna_def_transform, 1},
1926         {"WipeSequence", "Wipe Sequence",
1927          "Sequence strip creating a wipe transition",
1928          rna_def_wipe, 1},
1929         {"", "", "", NULL, 0}
1930 };
1931
1932 static void rna_def_effects(BlenderRNA *brna)
1933 {
1934         StructRNA *srna;
1935         EffectInfo *effect;
1936
1937         for (effect = def_effects; effect->struct_name[0] != '\0'; effect++) {
1938                 srna = RNA_def_struct(brna, effect->struct_name, "EffectSequence");
1939                 RNA_def_struct_ui_text(srna, effect->ui_name, effect->ui_desc);
1940                 RNA_def_struct_sdna(srna, "Sequence");
1941
1942                 rna_def_effect_inputs(srna, effect->inputs);
1943
1944                 if (effect->func)
1945                         effect->func(srna);
1946         }
1947 }
1948
1949 void RNA_def_sequencer(BlenderRNA *brna)
1950 {
1951         rna_def_strip_element(brna);
1952         rna_def_strip_proxy(brna);
1953         rna_def_strip_color_balance(brna);
1954         rna_def_strip_crop(brna);
1955         rna_def_strip_transform(brna);
1956
1957         rna_def_sequence(brna);
1958         rna_def_editor(brna);
1959
1960         rna_def_image(brna);
1961         rna_def_meta(brna);
1962         rna_def_scene(brna);
1963         rna_def_movie(brna);
1964         rna_def_movieclip(brna);
1965         rna_def_mask(brna);
1966         rna_def_sound(brna);
1967         rna_def_effect(brna);
1968         rna_def_effects(brna);
1969 }
1970
1971 #endif