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