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