Revert part of "GPencil: Invert Paste operator and make Paste to Active default"
[blender.git] / source / blender / makesrna / intern / rna_sequencer.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 /** \file
18  * \ingroup RNA
19  */
20
21 #include <stdlib.h>
22 #include <limits.h>
23
24 #include "DNA_anim_types.h"
25 #include "DNA_object_types.h"
26 #include "DNA_scene_types.h"
27 #include "DNA_sequence_types.h"
28 #include "DNA_movieclip_types.h"
29 #include "DNA_vfont_types.h"
30
31 #include "BLI_math.h"
32
33 #include "BLT_translation.h"
34
35 #include "BKE_animsys.h"
36 #include "BKE_sequencer.h"
37 #include "BKE_sound.h"
38
39 #include "IMB_metadata.h"
40
41 #include "MEM_guardedalloc.h"
42
43 #include "RNA_access.h"
44 #include "RNA_define.h"
45 #include "RNA_enum_types.h"
46
47 #include "rna_internal.h"
48
49 #include "WM_types.h"
50
51 typedef struct EffectInfo {
52   const char *struct_name;
53   const char *ui_name;
54   const char *ui_desc;
55   void (*func)(StructRNA *);
56   int inputs;
57 } EffectInfo;
58
59 const EnumPropertyItem rna_enum_sequence_modifier_type_items[] = {
60     {seqModifierType_ColorBalance, "COLOR_BALANCE", ICON_NONE, "Color Balance", ""},
61     {seqModifierType_Curves, "CURVES", ICON_NONE, "Curves", ""},
62     {seqModifierType_HueCorrect, "HUE_CORRECT", ICON_NONE, "Hue Correct", ""},
63     {seqModifierType_BrightContrast, "BRIGHT_CONTRAST", ICON_NONE, "Bright/Contrast", ""},
64     {seqModifierType_Mask, "MASK", ICON_NONE, "Mask", ""},
65     {seqModifierType_WhiteBalance, "WHITE_BALANCE", ICON_NONE, "White Balance", ""},
66     {seqModifierType_Tonemap, "TONEMAP", ICON_NONE, "Tone Map", ""},
67     {0, NULL, 0, NULL, NULL},
68 };
69
70 #ifdef RNA_RUNTIME
71
72 #  include "BKE_global.h"
73 #  include "BKE_report.h"
74 #  include "BKE_idprop.h"
75 #  include "BKE_movieclip.h"
76
77 #  include "WM_api.h"
78
79 #  include "DEG_depsgraph.h"
80 #  include "DEG_depsgraph_build.h"
81
82 #  include "IMB_imbuf.h"
83
84 typedef struct SequenceSearchData {
85   Sequence *seq;
86   void *data;
87   SequenceModifierData *smd;
88 } SequenceSearchData;
89
90 /* build a temp reference to the parent */
91 static void meta_tmp_ref(Sequence *seq_par, Sequence *seq)
92 {
93   for (; seq; seq = seq->next) {
94     seq->tmp = seq_par;
95     if (seq->type == SEQ_TYPE_META) {
96       meta_tmp_ref(seq, seq->seqbase.first);
97     }
98   }
99 }
100
101 static void rna_SequenceElement_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
102 {
103   Scene *scene = (Scene *)ptr->owner_id;
104   Editing *ed = BKE_sequencer_editing_get(scene, false);
105
106   if (ed) {
107     StripElem *se = (StripElem *)ptr->data;
108     Sequence *seq;
109
110     /* slow but we can't avoid! */
111     seq = BKE_sequencer_from_elem(&ed->seqbase, se);
112     if (seq) {
113       BKE_sequence_invalidate_cache_raw(scene, seq);
114     }
115   }
116 }
117
118 static void rna_Sequence_invalidate_raw_update(Main *UNUSED(bmain),
119                                                Scene *UNUSED(scene),
120                                                PointerRNA *ptr)
121 {
122   Scene *scene = (Scene *)ptr->owner_id;
123   Editing *ed = BKE_sequencer_editing_get(scene, false);
124
125   if (ed) {
126     Sequence *seq = (Sequence *)ptr->data;
127
128     BKE_sequence_invalidate_cache_raw(scene, seq);
129   }
130 }
131
132 static void rna_Sequence_invalidate_preprocessed_update(Main *UNUSED(bmain),
133                                                         Scene *UNUSED(scene),
134                                                         PointerRNA *ptr)
135 {
136   Scene *scene = (Scene *)ptr->owner_id;
137   Editing *ed = BKE_sequencer_editing_get(scene, false);
138
139   if (ed) {
140     Sequence *seq = (Sequence *)ptr->data;
141
142     BKE_sequence_invalidate_cache_preprocessed(scene, seq);
143   }
144 }
145
146 static void rna_Sequence_invalidate_composite_update(Main *UNUSED(bmain),
147                                                      Scene *UNUSED(scene),
148                                                      PointerRNA *ptr)
149 {
150   Scene *scene = (Scene *)ptr->owner_id;
151   Editing *ed = BKE_sequencer_editing_get(scene, false);
152
153   if (ed) {
154     Sequence *seq = (Sequence *)ptr->data;
155
156     BKE_sequence_invalidate_cache_composite(scene, seq);
157   }
158 }
159
160 static void rna_Sequence_use_sequence(Main *bmain, Scene *scene, PointerRNA *ptr)
161 {
162   /* General update callback. */
163   rna_Sequence_invalidate_raw_update(bmain, scene, ptr);
164   /* Changing recursion changes set of IDs which needs to be remapped by the copy-on-write.
165    * the only way for this currently is to tag the ID for ID_RECALC_COPY_ON_WRITE. */
166   Editing *ed = BKE_sequencer_editing_get(scene, false);
167   if (ed) {
168     Sequence *seq = (Sequence *)ptr->data;
169     if (seq->scene != NULL) {
170       DEG_id_tag_update(&seq->scene->id, ID_RECALC_COPY_ON_WRITE);
171     }
172   }
173   /* The sequencer scene is to be updated as well, including new relations from the nested
174    * sequencer. */
175   DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);
176   DEG_relations_tag_update(bmain);
177 }
178
179 static void rna_SequenceEditor_sequences_all_begin(CollectionPropertyIterator *iter,
180                                                    PointerRNA *ptr)
181 {
182   Scene *scene = (Scene *)ptr->owner_id;
183   Editing *ed = BKE_sequencer_editing_get(scene, false);
184
185   meta_tmp_ref(NULL, ed->seqbase.first);
186
187   rna_iterator_listbase_begin(iter, &ed->seqbase, NULL);
188 }
189
190 static void rna_SequenceEditor_update_cache(Main *UNUSED(bmain),
191                                             Scene *scene,
192                                             PointerRNA *UNUSED(ptr))
193 {
194   Editing *ed = scene->ed;
195
196   BKE_sequencer_free_imbuf(scene, &ed->seqbase, false);
197   BKE_sequencer_cache_cleanup(scene);
198 }
199
200 static void rna_SequenceEditor_sequences_all_next(CollectionPropertyIterator *iter)
201 {
202   ListBaseIterator *internal = &iter->internal.listbase;
203   Sequence *seq = (Sequence *)internal->link;
204
205   if (seq->seqbase.first) {
206     internal->link = (Link *)seq->seqbase.first;
207   }
208   else if (seq->next) {
209     internal->link = (Link *)seq->next;
210   }
211   else {
212     internal->link = NULL;
213
214     do {
215       seq = seq->tmp; /* XXX - seq's don't reference their parents! */
216       if (seq && seq->next) {
217         internal->link = (Link *)seq->next;
218         break;
219       }
220     } while (seq);
221   }
222
223   iter->valid = (internal->link != NULL);
224 }
225
226 /* internal use */
227 static int rna_SequenceEditor_elements_length(PointerRNA *ptr)
228 {
229   Sequence *seq = (Sequence *)ptr->data;
230
231   /* Hack? copied from sequencer.c::reload_sequence_new_file() */
232   size_t olen = MEM_allocN_len(seq->strip->stripdata) / sizeof(struct StripElem);
233
234   /* The problem with seq->strip->len and seq->len is that it's discounted from the offset
235    * (hard cut trim). */
236   return (int)olen;
237 }
238
239 static void rna_SequenceEditor_elements_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
240 {
241   Sequence *seq = (Sequence *)ptr->data;
242   rna_iterator_array_begin(iter,
243                            (void *)seq->strip->stripdata,
244                            sizeof(StripElem),
245                            rna_SequenceEditor_elements_length(ptr),
246                            0,
247                            NULL);
248 }
249
250 static void rna_Sequence_views_format_update(Main *bmain, Scene *scene, PointerRNA *ptr)
251 {
252   rna_Sequence_invalidate_raw_update(bmain, scene, ptr);
253 }
254
255 static void do_sequence_frame_change_update(Scene *scene, Sequence *seq)
256 {
257   Editing *ed = BKE_sequencer_editing_get(scene, false);
258   ListBase *seqbase = BKE_sequence_seqbase(&ed->seqbase, seq);
259   Sequence *tseq;
260   BKE_sequence_calc_disp(scene, seq);
261
262   /* ensure effects are always fit in length to their input */
263
264   /* TODO(sergey): probably could be optimized.
265    *               in terms skipping update of non-changing strips
266    */
267   for (tseq = seqbase->first; tseq; tseq = tseq->next) {
268     if (tseq->seq1 || tseq->seq2 || tseq->seq3) {
269       BKE_sequence_calc(scene, tseq);
270     }
271   }
272
273   if (BKE_sequence_test_overlap(seqbase, seq)) {
274     BKE_sequence_base_shuffle(seqbase, seq, scene); /* XXX - BROKEN!, uses context seqbasep */
275   }
276   BKE_sequencer_sort(scene);
277 }
278
279 /* A simple wrapper around above func, directly usable as prop update func.
280  * Also invalidate cache if needed.
281  */
282 static void rna_Sequence_frame_change_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
283 {
284   Scene *scene = (Scene *)ptr->owner_id;
285   do_sequence_frame_change_update(scene, (Sequence *)ptr->data);
286   rna_Sequence_invalidate_preprocessed_update(bmain, scene, ptr);
287 }
288
289 static void rna_Sequence_start_frame_set(PointerRNA *ptr, int value)
290 {
291   Sequence *seq = (Sequence *)ptr->data;
292   Scene *scene = (Scene *)ptr->owner_id;
293
294   BKE_sequence_translate(scene, seq, value - seq->start);
295   do_sequence_frame_change_update(scene, seq);
296 }
297
298 static void rna_Sequence_start_frame_final_set(PointerRNA *ptr, int value)
299 {
300   Sequence *seq = (Sequence *)ptr->data;
301   Scene *scene = (Scene *)ptr->owner_id;
302
303   BKE_sequence_tx_set_final_left(seq, value);
304   BKE_sequence_single_fix(seq);
305   do_sequence_frame_change_update(scene, seq);
306 }
307
308 static void rna_Sequence_end_frame_final_set(PointerRNA *ptr, int value)
309 {
310   Sequence *seq = (Sequence *)ptr->data;
311   Scene *scene = (Scene *)ptr->owner_id;
312
313   BKE_sequence_tx_set_final_right(seq, value);
314   BKE_sequence_single_fix(seq);
315   do_sequence_frame_change_update(scene, seq);
316 }
317
318 static void rna_Sequence_anim_startofs_final_set(PointerRNA *ptr, int value)
319 {
320   Sequence *seq = (Sequence *)ptr->data;
321   Scene *scene = (Scene *)ptr->owner_id;
322
323   seq->anim_startofs = MIN2(value, seq->len + seq->anim_startofs);
324
325   BKE_sequence_reload_new_file(G.main, scene, seq, false);
326   do_sequence_frame_change_update(scene, seq);
327 }
328
329 static void rna_Sequence_anim_endofs_final_set(PointerRNA *ptr, int value)
330 {
331   Sequence *seq = (Sequence *)ptr->data;
332   Scene *scene = (Scene *)ptr->owner_id;
333
334   seq->anim_endofs = MIN2(value, seq->len + seq->anim_endofs);
335
336   BKE_sequence_reload_new_file(G.main, scene, seq, false);
337   do_sequence_frame_change_update(scene, seq);
338 }
339
340 static void rna_Sequence_frame_length_set(PointerRNA *ptr, int value)
341 {
342   Sequence *seq = (Sequence *)ptr->data;
343   Scene *scene = (Scene *)ptr->owner_id;
344
345   BKE_sequence_tx_set_final_right(seq, BKE_sequence_tx_get_final_left(seq, false) + value);
346   do_sequence_frame_change_update(scene, seq);
347 }
348
349 static int rna_Sequence_frame_length_get(PointerRNA *ptr)
350 {
351   Sequence *seq = (Sequence *)ptr->data;
352   return BKE_sequence_tx_get_final_right(seq, false) - BKE_sequence_tx_get_final_left(seq, false);
353 }
354
355 static int rna_Sequence_frame_editable(PointerRNA *ptr, const char **UNUSED(r_info))
356 {
357   Sequence *seq = (Sequence *)ptr->data;
358   /* Effect sequences' start frame and length must be readonly! */
359   return (BKE_sequence_effect_get_num_inputs(seq->type)) ? 0 : PROP_EDITABLE;
360 }
361
362 static void rna_Sequence_channel_set(PointerRNA *ptr, int value)
363 {
364   Sequence *seq = (Sequence *)ptr->data;
365   Scene *scene = (Scene *)ptr->owner_id;
366   Editing *ed = BKE_sequencer_editing_get(scene, false);
367   ListBase *seqbase = BKE_sequence_seqbase(&ed->seqbase, seq);
368
369   /* check channel increment or decrement */
370   const int channel_delta = (value >= seq->machine) ? 1 : -1;
371   seq->machine = value;
372
373   if (BKE_sequence_test_overlap(seqbase, seq)) {
374     /* XXX - BROKEN!, uses context seqbasep */
375     BKE_sequence_base_shuffle_ex(seqbase, seq, scene, channel_delta);
376   }
377   BKE_sequencer_sort(scene);
378 }
379
380 static void rna_Sequence_frame_offset_range(
381     PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
382 {
383   Sequence *seq = (Sequence *)ptr->data;
384   *min = ELEM(seq->type, SEQ_TYPE_SOUND_RAM, SEQ_TYPE_SOUND_HD) ? 0 : INT_MIN;
385   *max = INT_MAX;
386 }
387
388 static void rna_Sequence_use_proxy_set(PointerRNA *ptr, bool value)
389 {
390   Sequence *seq = (Sequence *)ptr->data;
391   BKE_sequencer_proxy_set(seq, value != 0);
392 }
393
394 static void rna_Sequence_use_translation_set(PointerRNA *ptr, bool value)
395 {
396   Sequence *seq = (Sequence *)ptr->data;
397   if (value) {
398     seq->flag |= SEQ_USE_TRANSFORM;
399     if (seq->strip->transform == NULL) {
400       seq->strip->transform = MEM_callocN(sizeof(struct StripTransform), "StripTransform");
401     }
402   }
403   else {
404     seq->flag &= ~SEQ_USE_TRANSFORM;
405   }
406 }
407
408 static void rna_Sequence_use_crop_set(PointerRNA *ptr, bool value)
409 {
410   Sequence *seq = (Sequence *)ptr->data;
411   if (value) {
412     seq->flag |= SEQ_USE_CROP;
413     if (seq->strip->crop == NULL) {
414       seq->strip->crop = MEM_callocN(sizeof(struct StripCrop), "StripCrop");
415     }
416   }
417   else {
418     seq->flag &= ~SEQ_USE_CROP;
419   }
420 }
421
422 static int transform_seq_cmp_cb(Sequence *seq, void *arg_pt)
423 {
424   SequenceSearchData *data = arg_pt;
425
426   if (seq->strip && seq->strip->transform == data->data) {
427     data->seq = seq;
428     return -1; /* done so bail out */
429   }
430   return 1;
431 }
432
433 static Sequence *sequence_get_by_transform(Editing *ed, StripTransform *transform)
434 {
435   SequenceSearchData data;
436
437   data.seq = NULL;
438   data.data = transform;
439
440   /* irritating we need to search for our sequence! */
441   BKE_sequencer_base_recursive_apply(&ed->seqbase, transform_seq_cmp_cb, &data);
442
443   return data.seq;
444 }
445
446 static char *rna_SequenceTransform_path(PointerRNA *ptr)
447 {
448   Scene *scene = (Scene *)ptr->owner_id;
449   Editing *ed = BKE_sequencer_editing_get(scene, false);
450   Sequence *seq = sequence_get_by_transform(ed, ptr->data);
451
452   if (seq && seq->name + 2) {
453     char name_esc[(sizeof(seq->name) - 2) * 2];
454
455     BLI_strescape(name_esc, seq->name + 2, sizeof(name_esc));
456     return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"].transform", name_esc);
457   }
458   else {
459     return BLI_strdup("");
460   }
461 }
462
463 static void rna_SequenceTransform_update(Main *UNUSED(bmain),
464                                          Scene *UNUSED(scene),
465                                          PointerRNA *ptr)
466 {
467   Scene *scene = (Scene *)ptr->owner_id;
468   Editing *ed = BKE_sequencer_editing_get(scene, false);
469   Sequence *seq = sequence_get_by_transform(ed, ptr->data);
470
471   BKE_sequence_invalidate_cache_preprocessed(scene, seq);
472 }
473
474 static int crop_seq_cmp_cb(Sequence *seq, void *arg_pt)
475 {
476   SequenceSearchData *data = arg_pt;
477
478   if (seq->strip && seq->strip->crop == data->data) {
479     data->seq = seq;
480     return -1; /* done so bail out */
481   }
482   return 1;
483 }
484
485 static Sequence *sequence_get_by_crop(Editing *ed, StripCrop *crop)
486 {
487   SequenceSearchData data;
488
489   data.seq = NULL;
490   data.data = crop;
491
492   /* irritating we need to search for our sequence! */
493   BKE_sequencer_base_recursive_apply(&ed->seqbase, crop_seq_cmp_cb, &data);
494
495   return data.seq;
496 }
497
498 static char *rna_SequenceCrop_path(PointerRNA *ptr)
499 {
500   Scene *scene = (Scene *)ptr->owner_id;
501   Editing *ed = BKE_sequencer_editing_get(scene, false);
502   Sequence *seq = sequence_get_by_crop(ed, ptr->data);
503
504   if (seq && seq->name + 2) {
505     char name_esc[(sizeof(seq->name) - 2) * 2];
506
507     BLI_strescape(name_esc, seq->name + 2, sizeof(name_esc));
508     return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"].crop", name_esc);
509   }
510   else {
511     return BLI_strdup("");
512   }
513 }
514
515 static void rna_SequenceCrop_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
516 {
517   Scene *scene = (Scene *)ptr->owner_id;
518   Editing *ed = BKE_sequencer_editing_get(scene, false);
519   Sequence *seq = sequence_get_by_crop(ed, ptr->data);
520
521   BKE_sequence_invalidate_cache_preprocessed(scene, seq);
522 }
523
524 static void rna_Sequence_text_font_set(PointerRNA *ptr,
525                                        PointerRNA ptr_value,
526                                        struct ReportList *UNUSED(reports))
527 {
528   Sequence *seq = ptr->data;
529   TextVars *data = seq->effectdata;
530   VFont *value = ptr_value.data;
531
532   BKE_sequencer_text_font_unload(data, true);
533
534   id_us_plus(&value->id);
535   data->text_blf_id = SEQ_FONT_NOT_LOADED;
536   data->text_font = value;
537 }
538
539 /* name functions that ignore the first two characters */
540 static void rna_Sequence_name_get(PointerRNA *ptr, char *value)
541 {
542   Sequence *seq = (Sequence *)ptr->data;
543   BLI_strncpy(value, seq->name + 2, sizeof(seq->name) - 2);
544 }
545
546 static int rna_Sequence_name_length(PointerRNA *ptr)
547 {
548   Sequence *seq = (Sequence *)ptr->data;
549   return strlen(seq->name + 2);
550 }
551
552 static void rna_Sequence_name_set(PointerRNA *ptr, const char *value)
553 {
554   Scene *scene = (Scene *)ptr->owner_id;
555   Sequence *seq = (Sequence *)ptr->data;
556   char oldname[sizeof(seq->name)];
557   AnimData *adt;
558
559   /* make a copy of the old name first */
560   BLI_strncpy(oldname, seq->name + 2, sizeof(seq->name) - 2);
561
562   /* copy the new name into the name slot */
563   BLI_strncpy_utf8(seq->name + 2, value, sizeof(seq->name) - 2);
564
565   /* make sure the name is unique */
566   BKE_sequence_base_unique_name_recursive(&scene->ed->seqbase, seq);
567
568   /* fix all the animation data which may link to this */
569
570   /* Don't rename everywhere because these are per scene. */
571 #  if 0
572   BKE_animdata_fix_paths_rename_all(NULL, "sequence_editor.sequences_all", oldname, seq->name + 2);
573 #  endif
574   adt = BKE_animdata_from_id(&scene->id);
575   if (adt) {
576     BKE_animdata_fix_paths_rename(
577         &scene->id, adt, NULL, "sequence_editor.sequences_all", oldname, seq->name + 2, 0, 0, 1);
578   }
579 }
580
581 static StructRNA *rna_Sequence_refine(struct PointerRNA *ptr)
582 {
583   Sequence *seq = (Sequence *)ptr->data;
584
585   switch (seq->type) {
586     case SEQ_TYPE_IMAGE:
587       return &RNA_ImageSequence;
588     case SEQ_TYPE_META:
589       return &RNA_MetaSequence;
590     case SEQ_TYPE_SCENE:
591       return &RNA_SceneSequence;
592     case SEQ_TYPE_MOVIE:
593       return &RNA_MovieSequence;
594     case SEQ_TYPE_MOVIECLIP:
595       return &RNA_MovieClipSequence;
596     case SEQ_TYPE_MASK:
597       return &RNA_MaskSequence;
598     case SEQ_TYPE_SOUND_RAM:
599       return &RNA_SoundSequence;
600     case SEQ_TYPE_CROSS:
601       return &RNA_CrossSequence;
602     case SEQ_TYPE_ADD:
603       return &RNA_AddSequence;
604     case SEQ_TYPE_SUB:
605       return &RNA_SubtractSequence;
606     case SEQ_TYPE_ALPHAOVER:
607       return &RNA_AlphaOverSequence;
608     case SEQ_TYPE_ALPHAUNDER:
609       return &RNA_AlphaUnderSequence;
610     case SEQ_TYPE_GAMCROSS:
611       return &RNA_GammaCrossSequence;
612     case SEQ_TYPE_MUL:
613       return &RNA_MultiplySequence;
614     case SEQ_TYPE_OVERDROP:
615       return &RNA_OverDropSequence;
616     case SEQ_TYPE_MULTICAM:
617       return &RNA_MulticamSequence;
618     case SEQ_TYPE_ADJUSTMENT:
619       return &RNA_AdjustmentSequence;
620     case SEQ_TYPE_WIPE:
621       return &RNA_WipeSequence;
622     case SEQ_TYPE_GLOW:
623       return &RNA_GlowSequence;
624     case SEQ_TYPE_TRANSFORM:
625       return &RNA_TransformSequence;
626     case SEQ_TYPE_COLOR:
627       return &RNA_ColorSequence;
628     case SEQ_TYPE_SPEED:
629       return &RNA_SpeedControlSequence;
630     case SEQ_TYPE_GAUSSIAN_BLUR:
631       return &RNA_GaussianBlurSequence;
632     case SEQ_TYPE_TEXT:
633       return &RNA_TextSequence;
634     case SEQ_TYPE_COLORMIX:
635       return &RNA_ColorMixSequence;
636     default:
637       return &RNA_Sequence;
638   }
639 }
640
641 static char *rna_Sequence_path(PointerRNA *ptr)
642 {
643   Sequence *seq = (Sequence *)ptr->data;
644
645   /* sequencer data comes from scene...
646    * TODO: would be nice to make SequenceEditor data a data-block of its own (for shorter paths)
647    */
648   if (seq->name + 2) {
649     char name_esc[(sizeof(seq->name) - 2) * 2];
650
651     BLI_strescape(name_esc, seq->name + 2, sizeof(name_esc));
652     return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"]", name_esc);
653   }
654   else {
655     return BLI_strdup("");
656   }
657 }
658
659 static IDProperty *rna_Sequence_idprops(PointerRNA *ptr, bool create)
660 {
661   Sequence *seq = ptr->data;
662
663   if (create && !seq->prop) {
664     IDPropertyTemplate val = {0};
665     seq->prop = IDP_New(IDP_GROUP, &val, "Sequence ID properties");
666   }
667
668   return seq->prop;
669 }
670
671 static PointerRNA rna_MovieSequence_metadata_get(Sequence *seq)
672 {
673   if (seq == NULL || seq->anims.first == NULL) {
674     return PointerRNA_NULL;
675   }
676
677   StripAnim *sanim = seq->anims.first;
678   if (sanim->anim == NULL) {
679     return PointerRNA_NULL;
680   }
681
682   IDProperty *metadata = IMB_anim_load_metadata(sanim->anim);
683   if (metadata == NULL) {
684     return PointerRNA_NULL;
685   }
686
687   PointerRNA ptr;
688   RNA_pointer_create(NULL, &RNA_IDPropertyWrapPtr, metadata, &ptr);
689   return ptr;
690 }
691
692 static PointerRNA rna_SequenceEditor_meta_stack_get(CollectionPropertyIterator *iter)
693 {
694   ListBaseIterator *internal = &iter->internal.listbase;
695   MetaStack *ms = (MetaStack *)internal->link;
696
697   return rna_pointer_inherit_refine(&iter->parent, &RNA_Sequence, ms->parseq);
698 }
699
700 /* TODO, expose seq path setting as a higher level sequencer BKE function */
701 static void rna_Sequence_filepath_set(PointerRNA *ptr, const char *value)
702 {
703   Sequence *seq = (Sequence *)(ptr->data);
704   BLI_split_dirfile(value,
705                     seq->strip->dir,
706                     seq->strip->stripdata->name,
707                     sizeof(seq->strip->dir),
708                     sizeof(seq->strip->stripdata->name));
709 }
710
711 static void rna_Sequence_filepath_get(PointerRNA *ptr, char *value)
712 {
713   Sequence *seq = (Sequence *)(ptr->data);
714
715   BLI_join_dirfile(value, FILE_MAX, seq->strip->dir, seq->strip->stripdata->name);
716 }
717
718 static int rna_Sequence_filepath_length(PointerRNA *ptr)
719 {
720   Sequence *seq = (Sequence *)(ptr->data);
721   char path[FILE_MAX];
722
723   BLI_join_dirfile(path, sizeof(path), seq->strip->dir, seq->strip->stripdata->name);
724   return strlen(path);
725 }
726
727 static void rna_Sequence_proxy_filepath_set(PointerRNA *ptr, const char *value)
728 {
729   StripProxy *proxy = (StripProxy *)(ptr->data);
730   BLI_split_dirfile(value, proxy->dir, proxy->file, sizeof(proxy->dir), sizeof(proxy->file));
731   if (proxy->anim) {
732     IMB_free_anim(proxy->anim);
733     proxy->anim = NULL;
734   }
735 }
736
737 static void rna_Sequence_proxy_filepath_get(PointerRNA *ptr, char *value)
738 {
739   StripProxy *proxy = (StripProxy *)(ptr->data);
740
741   BLI_join_dirfile(value, FILE_MAX, proxy->dir, proxy->file);
742 }
743
744 static int rna_Sequence_proxy_filepath_length(PointerRNA *ptr)
745 {
746   StripProxy *proxy = (StripProxy *)(ptr->data);
747   char path[FILE_MAX];
748
749   BLI_join_dirfile(path, sizeof(path), proxy->dir, proxy->file);
750   return strlen(path);
751 }
752
753 static void rna_Sequence_audio_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *UNUSED(ptr))
754 {
755   DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);
756 }
757
758 static int rna_Sequence_input_count_get(PointerRNA *ptr)
759 {
760   Sequence *seq = (Sequence *)(ptr->data);
761
762   return BKE_sequence_effect_get_num_inputs(seq->type);
763 }
764
765 #  if 0
766 static void rna_SoundSequence_filename_set(PointerRNA *ptr, const char *value)
767 {
768   Sequence *seq = (Sequence *)(ptr->data);
769   BLI_split_dirfile(value,
770                     seq->strip->dir,
771                     seq->strip->stripdata->name,
772                     sizeof(seq->strip->dir),
773                     sizeof(seq->strip->stripdata->name));
774 }
775
776 static void rna_SequenceElement_filename_set(PointerRNA *ptr, const char *value)
777 {
778   StripElem *elem = (StripElem *)(ptr->data);
779   BLI_split_file_part(value, elem->name, sizeof(elem->name));
780 }
781 #  endif
782
783 static void rna_Sequence_reopen_files_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
784 {
785   Scene *scene = (Scene *)ptr->owner_id;
786   Editing *ed = BKE_sequencer_editing_get(scene, false);
787
788   BKE_sequencer_free_imbuf(scene, &ed->seqbase, false);
789   rna_Sequence_invalidate_raw_update(bmain, scene, ptr);
790
791   if (RNA_struct_is_a(ptr->type, &RNA_SoundSequence)) {
792     BKE_sequencer_update_sound_bounds(scene, ptr->data);
793   }
794 }
795
796 static void rna_Sequence_mute_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
797 {
798   Scene *scene = (Scene *)ptr->owner_id;
799
800   DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS);
801 }
802
803 static void rna_Sequence_filepath_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
804 {
805   Scene *scene = (Scene *)ptr->owner_id;
806   Sequence *seq = (Sequence *)(ptr->data);
807   BKE_sequence_reload_new_file(bmain, scene, seq, true);
808   BKE_sequence_calc(scene, seq);
809   rna_Sequence_invalidate_raw_update(bmain, scene, ptr);
810 }
811
812 static void rna_Sequence_sound_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *UNUSED(ptr))
813 {
814   DEG_id_tag_update(&scene->id, ID_RECALC_SEQUENCER_STRIPS | ID_RECALC_AUDIO);
815 }
816
817 static int seqproxy_seq_cmp_cb(Sequence *seq, void *arg_pt)
818 {
819   SequenceSearchData *data = arg_pt;
820
821   if (seq->strip && seq->strip->proxy == data->data) {
822     data->seq = seq;
823     return -1; /* done so bail out */
824   }
825   return 1;
826 }
827
828 static Sequence *sequence_get_by_proxy(Editing *ed, StripProxy *proxy)
829 {
830   SequenceSearchData data;
831
832   data.seq = NULL;
833   data.data = proxy;
834
835   BKE_sequencer_base_recursive_apply(&ed->seqbase, seqproxy_seq_cmp_cb, &data);
836   return data.seq;
837 }
838
839 static void rna_Sequence_tcindex_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
840 {
841   Scene *scene = (Scene *)ptr->owner_id;
842   Editing *ed = BKE_sequencer_editing_get(scene, false);
843   Sequence *seq = sequence_get_by_proxy(ed, ptr->data);
844
845   BKE_sequence_reload_new_file(bmain, scene, seq, false);
846   do_sequence_frame_change_update(scene, seq);
847 }
848
849 static void rna_SequenceProxy_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
850 {
851   Scene *scene = (Scene *)ptr->owner_id;
852   Editing *ed = BKE_sequencer_editing_get(scene, false);
853   Sequence *seq = sequence_get_by_proxy(ed, ptr->data);
854
855   BKE_sequence_invalidate_cache_raw(scene, seq);
856 }
857
858 /* do_versions? */
859 static float rna_Sequence_opacity_get(PointerRNA *ptr)
860 {
861   Sequence *seq = (Sequence *)(ptr->data);
862   return seq->blend_opacity / 100.0f;
863 }
864 static void rna_Sequence_opacity_set(PointerRNA *ptr, float value)
865 {
866   Sequence *seq = (Sequence *)(ptr->data);
867   CLAMP(value, 0.0f, 1.0f);
868   seq->blend_opacity = value * 100.0f;
869 }
870
871 static int colbalance_seq_cmp_cb(Sequence *seq, void *arg_pt)
872 {
873   SequenceSearchData *data = arg_pt;
874
875   if (seq->modifiers.first) {
876     SequenceModifierData *smd = seq->modifiers.first;
877
878     for (smd = seq->modifiers.first; smd; smd = smd->next) {
879       if (smd->type == seqModifierType_ColorBalance) {
880         ColorBalanceModifierData *cbmd = (ColorBalanceModifierData *)smd;
881
882         if (&cbmd->color_balance == data->data) {
883           data->seq = seq;
884           data->smd = smd;
885           return -1; /* done so bail out */
886         }
887       }
888     }
889   }
890
891   return 1;
892 }
893
894 static Sequence *sequence_get_by_colorbalance(Editing *ed,
895                                               StripColorBalance *cb,
896                                               SequenceModifierData **r_smd)
897 {
898   SequenceSearchData data;
899
900   data.seq = NULL;
901   data.smd = NULL;
902   data.data = cb;
903
904   /* irritating we need to search for our sequence! */
905   BKE_sequencer_base_recursive_apply(&ed->seqbase, colbalance_seq_cmp_cb, &data);
906
907   *r_smd = data.smd;
908
909   return data.seq;
910 }
911
912 static char *rna_SequenceColorBalance_path(PointerRNA *ptr)
913 {
914   Scene *scene = (Scene *)ptr->owner_id;
915   SequenceModifierData *smd;
916   Editing *ed = BKE_sequencer_editing_get(scene, false);
917   Sequence *seq = sequence_get_by_colorbalance(ed, ptr->data, &smd);
918
919   if (seq && seq->name + 2) {
920     char name_esc[(sizeof(seq->name) - 2) * 2];
921
922     BLI_strescape(name_esc, seq->name + 2, sizeof(name_esc));
923
924     if (!smd) {
925       /* path to old filter color balance */
926       return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"].color_balance", name_esc);
927     }
928     else {
929       /* path to modifier */
930       char name_esc_smd[sizeof(smd->name) * 2];
931
932       BLI_strescape(name_esc_smd, smd->name, sizeof(name_esc_smd));
933       return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"].modifiers[\"%s\"].color_balance",
934                           name_esc,
935                           name_esc_smd);
936     }
937   }
938   else {
939     return BLI_strdup("");
940   }
941 }
942
943 static void rna_SequenceColorBalance_update(Main *UNUSED(bmain),
944                                             Scene *UNUSED(scene),
945                                             PointerRNA *ptr)
946 {
947   Scene *scene = (Scene *)ptr->owner_id;
948   Editing *ed = BKE_sequencer_editing_get(scene, false);
949   SequenceModifierData *smd;
950   Sequence *seq = sequence_get_by_colorbalance(ed, ptr->data, &smd);
951
952   BKE_sequence_invalidate_cache_preprocessed(scene, seq);
953 }
954
955 static void rna_SequenceEditor_overlay_lock_set(PointerRNA *ptr, bool value)
956 {
957   Scene *scene = (Scene *)ptr->owner_id;
958   Editing *ed = BKE_sequencer_editing_get(scene, false);
959
960   if (ed == NULL) {
961     return;
962   }
963
964   /* convert from abs to relative and back */
965   if ((ed->over_flag & SEQ_EDIT_OVERLAY_ABS) == 0 && value) {
966     ed->over_cfra = scene->r.cfra + ed->over_ofs;
967     ed->over_flag |= SEQ_EDIT_OVERLAY_ABS;
968   }
969   else if ((ed->over_flag & SEQ_EDIT_OVERLAY_ABS) && !value) {
970     ed->over_ofs = ed->over_cfra - scene->r.cfra;
971     ed->over_flag &= ~SEQ_EDIT_OVERLAY_ABS;
972   }
973 }
974
975 static int rna_SequenceEditor_overlay_frame_get(PointerRNA *ptr)
976 {
977   Scene *scene = (Scene *)ptr->owner_id;
978   Editing *ed = BKE_sequencer_editing_get(scene, false);
979
980   if (ed == NULL) {
981     return scene->r.cfra;
982   }
983
984   if (ed->over_flag & SEQ_EDIT_OVERLAY_ABS) {
985     return ed->over_cfra - scene->r.cfra;
986   }
987   else {
988     return ed->over_ofs;
989   }
990 }
991
992 static void rna_SequenceEditor_overlay_frame_set(PointerRNA *ptr, int value)
993 {
994   Scene *scene = (Scene *)ptr->owner_id;
995   Editing *ed = BKE_sequencer_editing_get(scene, false);
996
997   if (ed == NULL) {
998     return;
999   }
1000
1001   if (ed->over_flag & SEQ_EDIT_OVERLAY_ABS) {
1002     ed->over_cfra = (scene->r.cfra + value);
1003   }
1004   else {
1005     ed->over_ofs = value;
1006   }
1007 }
1008
1009 static int modifier_seq_cmp_cb(Sequence *seq, void *arg_pt)
1010 {
1011   SequenceSearchData *data = arg_pt;
1012
1013   if (BLI_findindex(&seq->modifiers, data->data) != -1) {
1014     data->seq = seq;
1015     return -1; /* done so bail out */
1016   }
1017
1018   return 1;
1019 }
1020
1021 static Sequence *sequence_get_by_modifier(Editing *ed, SequenceModifierData *smd)
1022 {
1023   SequenceSearchData data;
1024
1025   data.seq = NULL;
1026   data.data = smd;
1027
1028   /* irritating we need to search for our sequence! */
1029   BKE_sequencer_base_recursive_apply(&ed->seqbase, modifier_seq_cmp_cb, &data);
1030
1031   return data.seq;
1032 }
1033
1034 static StructRNA *rna_SequenceModifier_refine(struct PointerRNA *ptr)
1035 {
1036   SequenceModifierData *smd = (SequenceModifierData *)ptr->data;
1037
1038   switch (smd->type) {
1039     case seqModifierType_ColorBalance:
1040       return &RNA_ColorBalanceModifier;
1041     case seqModifierType_Curves:
1042       return &RNA_CurvesModifier;
1043     case seqModifierType_HueCorrect:
1044       return &RNA_HueCorrectModifier;
1045     case seqModifierType_BrightContrast:
1046       return &RNA_BrightContrastModifier;
1047     case seqModifierType_WhiteBalance:
1048       return &RNA_WhiteBalanceModifier;
1049     case seqModifierType_Tonemap:
1050       return &RNA_SequencerTonemapModifierData;
1051     default:
1052       return &RNA_SequenceModifier;
1053   }
1054 }
1055
1056 static char *rna_SequenceModifier_path(PointerRNA *ptr)
1057 {
1058   Scene *scene = (Scene *)ptr->owner_id;
1059   Editing *ed = BKE_sequencer_editing_get(scene, false);
1060   SequenceModifierData *smd = ptr->data;
1061   Sequence *seq = sequence_get_by_modifier(ed, smd);
1062
1063   if (seq && seq->name + 2) {
1064     char name_esc[(sizeof(seq->name) - 2) * 2];
1065     char name_esc_smd[sizeof(smd->name) * 2];
1066
1067     BLI_strescape(name_esc, seq->name + 2, sizeof(name_esc));
1068     BLI_strescape(name_esc_smd, smd->name, sizeof(name_esc_smd));
1069     return BLI_sprintfN(
1070         "sequence_editor.sequences_all[\"%s\"].modifiers[\"%s\"]", name_esc, name_esc_smd);
1071   }
1072   else {
1073     return BLI_strdup("");
1074   }
1075 }
1076
1077 static void rna_SequenceModifier_name_set(PointerRNA *ptr, const char *value)
1078 {
1079   SequenceModifierData *smd = ptr->data;
1080   Scene *scene = (Scene *)ptr->owner_id;
1081   Editing *ed = BKE_sequencer_editing_get(scene, false);
1082   Sequence *seq = sequence_get_by_modifier(ed, smd);
1083   AnimData *adt;
1084   char oldname[sizeof(smd->name)];
1085
1086   /* make a copy of the old name first */
1087   BLI_strncpy(oldname, smd->name, sizeof(smd->name));
1088
1089   /* copy the new name into the name slot */
1090   BLI_strncpy_utf8(smd->name, value, sizeof(smd->name));
1091
1092   /* make sure the name is truly unique */
1093   BKE_sequence_modifier_unique_name(seq, smd);
1094
1095   /* fix all the animation data which may link to this */
1096   adt = BKE_animdata_from_id(&scene->id);
1097   if (adt) {
1098     char path[1024];
1099
1100     BLI_snprintf(
1101         path, sizeof(path), "sequence_editor.sequences_all[\"%s\"].modifiers", seq->name + 2);
1102     BKE_animdata_fix_paths_rename(&scene->id, adt, NULL, path, oldname, smd->name, 0, 0, 1);
1103   }
1104 }
1105
1106 static void rna_SequenceModifier_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
1107 {
1108   /* strip from other scenes could be modified, so using active scene is not reliable */
1109   Scene *scene = (Scene *)ptr->owner_id;
1110   Editing *ed = BKE_sequencer_editing_get(scene, false);
1111   Sequence *seq = sequence_get_by_modifier(ed, ptr->data);
1112
1113   BKE_sequence_invalidate_cache_preprocessed(scene, seq);
1114 }
1115
1116 static bool rna_SequenceModifier_otherSequence_poll(PointerRNA *ptr, PointerRNA value)
1117 {
1118   Scene *scene = (Scene *)ptr->owner_id;
1119   Editing *ed = BKE_sequencer_editing_get(scene, false);
1120   Sequence *seq = sequence_get_by_modifier(ed, ptr->data);
1121   Sequence *cur = (Sequence *)value.data;
1122
1123   if ((seq == cur) || (cur->type == SEQ_TYPE_SOUND_RAM)) {
1124     return false;
1125   }
1126
1127   return true;
1128 }
1129
1130 static SequenceModifierData *rna_Sequence_modifier_new(
1131     Sequence *seq, bContext *C, ReportList *reports, const char *name, int type)
1132 {
1133   if (!BKE_sequence_supports_modifiers(seq)) {
1134     BKE_report(reports, RPT_ERROR, "Sequence type does not support modifiers");
1135
1136     return NULL;
1137   }
1138   else {
1139     Scene *scene = CTX_data_scene(C);
1140     SequenceModifierData *smd;
1141
1142     smd = BKE_sequence_modifier_new(seq, name, type);
1143
1144     BKE_sequence_invalidate_cache_preprocessed(scene, seq);
1145
1146     WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, NULL);
1147
1148     return smd;
1149   }
1150 }
1151
1152 static void rna_Sequence_modifier_remove(Sequence *seq,
1153                                          bContext *C,
1154                                          ReportList *reports,
1155                                          PointerRNA *smd_ptr)
1156 {
1157   SequenceModifierData *smd = smd_ptr->data;
1158   Scene *scene = CTX_data_scene(C);
1159
1160   if (BKE_sequence_modifier_remove(seq, smd) == false) {
1161     BKE_report(reports, RPT_ERROR, "Modifier was not found in the stack");
1162     return;
1163   }
1164
1165   RNA_POINTER_INVALIDATE(smd_ptr);
1166   BKE_sequence_invalidate_cache_preprocessed(scene, seq);
1167
1168   WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, NULL);
1169 }
1170
1171 static void rna_Sequence_modifier_clear(Sequence *seq, bContext *C)
1172 {
1173   Scene *scene = CTX_data_scene(C);
1174
1175   BKE_sequence_modifier_clear(seq);
1176
1177   BKE_sequence_invalidate_cache_preprocessed(scene, seq);
1178
1179   WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, NULL);
1180 }
1181
1182 static float rna_Sequence_fps_get(PointerRNA *ptr)
1183 {
1184   Scene *scene = (Scene *)ptr->owner_id;
1185   Sequence *seq = (Sequence *)(ptr->data);
1186   return BKE_sequence_get_fps(scene, seq);
1187 }
1188
1189 #else
1190
1191 static void rna_def_strip_element(BlenderRNA *brna)
1192 {
1193   StructRNA *srna;
1194   PropertyRNA *prop;
1195
1196   srna = RNA_def_struct(brna, "SequenceElement", NULL);
1197   RNA_def_struct_ui_text(srna, "Sequence Element", "Sequence strip data for a single frame");
1198   RNA_def_struct_sdna(srna, "StripElem");
1199
1200   prop = RNA_def_property(srna, "filename", PROP_STRING, PROP_FILENAME);
1201   RNA_def_property_string_sdna(prop, NULL, "name");
1202   RNA_def_property_ui_text(prop, "Filename", "Name of the source file");
1203   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceElement_update");
1204
1205   prop = RNA_def_property(srna, "orig_width", PROP_INT, PROP_NONE);
1206   RNA_def_property_int_sdna(prop, NULL, "orig_width");
1207   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1208   RNA_def_property_ui_text(prop, "Orig Width", "Original image width");
1209
1210   prop = RNA_def_property(srna, "orig_height", PROP_INT, PROP_NONE);
1211   RNA_def_property_int_sdna(prop, NULL, "orig_height");
1212   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1213   RNA_def_property_ui_text(prop, "Orig Height", "Original image height");
1214 }
1215
1216 static void rna_def_strip_crop(BlenderRNA *brna)
1217 {
1218   StructRNA *srna;
1219   PropertyRNA *prop;
1220
1221   srna = RNA_def_struct(brna, "SequenceCrop", NULL);
1222   RNA_def_struct_ui_text(srna, "Sequence Crop", "Cropping parameters for a sequence strip");
1223   RNA_def_struct_sdna(srna, "StripCrop");
1224
1225   prop = RNA_def_property(srna, "max_y", PROP_INT, PROP_PIXEL);
1226   RNA_def_property_int_sdna(prop, NULL, "top");
1227   RNA_def_property_ui_text(prop, "Top", "Number of pixels to crop from the top");
1228   RNA_def_property_ui_range(prop, 0, 4096, 1, -1);
1229   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceCrop_update");
1230
1231   prop = RNA_def_property(srna, "min_y", PROP_INT, PROP_PIXEL);
1232   RNA_def_property_int_sdna(prop, NULL, "bottom");
1233   RNA_def_property_ui_text(prop, "Bottom", "Number of pixels to crop from the bottom");
1234   RNA_def_property_ui_range(prop, 0, 4096, 1, -1);
1235   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceCrop_update");
1236
1237   prop = RNA_def_property(srna, "min_x", PROP_INT, PROP_PIXEL);
1238   RNA_def_property_int_sdna(prop, NULL, "left");
1239   RNA_def_property_ui_text(prop, "Left", "Number of pixels to crop from the left side");
1240   RNA_def_property_ui_range(prop, 0, 4096, 1, -1);
1241   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceCrop_update");
1242
1243   prop = RNA_def_property(srna, "max_x", PROP_INT, PROP_PIXEL);
1244   RNA_def_property_int_sdna(prop, NULL, "right");
1245   RNA_def_property_ui_text(prop, "Right", "Number of pixels to crop from the right side");
1246   RNA_def_property_ui_range(prop, 0, 4096, 1, -1);
1247   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceCrop_update");
1248
1249   RNA_def_struct_path_func(srna, "rna_SequenceCrop_path");
1250 }
1251
1252 static void rna_def_strip_transform(BlenderRNA *brna)
1253 {
1254   StructRNA *srna;
1255   PropertyRNA *prop;
1256
1257   srna = RNA_def_struct(brna, "SequenceTransform", NULL);
1258   RNA_def_struct_ui_text(srna, "Sequence Transform", "Transform parameters for a sequence strip");
1259   RNA_def_struct_sdna(srna, "StripTransform");
1260
1261   prop = RNA_def_property(srna, "offset_x", PROP_INT, PROP_PIXEL);
1262   RNA_def_property_int_sdna(prop, NULL, "xofs");
1263   RNA_def_property_ui_text(
1264       prop, "Offset X", "Amount to move the input on the X axis within its boundaries");
1265   RNA_def_property_ui_range(prop, -4096, 4096, 1, -1);
1266   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceTransform_update");
1267
1268   prop = RNA_def_property(srna, "offset_y", PROP_INT, PROP_PIXEL);
1269   RNA_def_property_int_sdna(prop, NULL, "yofs");
1270   RNA_def_property_ui_text(
1271       prop, "Offset Y", "Amount to move the input on the Y axis within its boundaries");
1272   RNA_def_property_ui_range(prop, -4096, 4096, 1, -1);
1273   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceTransform_update");
1274
1275   RNA_def_struct_path_func(srna, "rna_SequenceTransform_path");
1276 }
1277
1278 static void rna_def_strip_proxy(BlenderRNA *brna)
1279 {
1280   StructRNA *srna;
1281   PropertyRNA *prop;
1282
1283   static const EnumPropertyItem seq_tc_items[] = {
1284       {SEQ_PROXY_TC_NONE, "NONE", 0, "No TC in use", ""},
1285       {SEQ_PROXY_TC_RECORD_RUN,
1286        "RECORD_RUN",
1287        0,
1288        "Record Run",
1289        "Use images in the order as they are recorded"},
1290       {SEQ_PROXY_TC_FREE_RUN,
1291        "FREE_RUN",
1292        0,
1293        "Free Run",
1294        "Use global timestamp written by recording device"},
1295       {SEQ_PROXY_TC_INTERP_REC_DATE_FREE_RUN,
1296        "FREE_RUN_REC_DATE",
1297        0,
1298        "Free Run (rec date)",
1299        "Interpolate a global timestamp using the "
1300        "record date and time written by recording device"},
1301       {SEQ_PROXY_TC_RECORD_RUN_NO_GAPS,
1302        "RECORD_RUN_NO_GAPS",
1303        0,
1304        "Record Run No Gaps",
1305        "Like record run, but ignore timecode, "
1306        "changes in framerate or dropouts"},
1307       {0, NULL, 0, NULL, NULL},
1308   };
1309
1310   srna = RNA_def_struct(brna, "SequenceProxy", NULL);
1311   RNA_def_struct_ui_text(srna, "Sequence Proxy", "Proxy parameters for a sequence strip");
1312   RNA_def_struct_sdna(srna, "StripProxy");
1313
1314   prop = RNA_def_property(srna, "directory", PROP_STRING, PROP_DIRPATH);
1315   RNA_def_property_string_sdna(prop, NULL, "dir");
1316   RNA_def_property_ui_text(prop, "Directory", "Location to store the proxy files");
1317   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceProxy_update");
1318
1319   prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
1320   RNA_def_property_ui_text(prop, "Path", "Location of custom proxy file");
1321   RNA_def_property_string_funcs(prop,
1322                                 "rna_Sequence_proxy_filepath_get",
1323                                 "rna_Sequence_proxy_filepath_length",
1324                                 "rna_Sequence_proxy_filepath_set");
1325
1326   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceProxy_update");
1327
1328   prop = RNA_def_property(srna, "use_overwrite", PROP_BOOLEAN, PROP_NONE);
1329   RNA_def_property_boolean_negative_sdna(prop, NULL, "build_flags", SEQ_PROXY_SKIP_EXISTING);
1330   RNA_def_property_ui_text(prop, "Overwrite", "Overwrite existing proxy files when building");
1331
1332   prop = RNA_def_property(srna, "build_25", PROP_BOOLEAN, PROP_NONE);
1333   RNA_def_property_boolean_sdna(prop, NULL, "build_size_flags", SEQ_PROXY_IMAGE_SIZE_25);
1334   RNA_def_property_ui_text(prop, "25%", "Build 25% proxy resolution");
1335
1336   prop = RNA_def_property(srna, "build_50", PROP_BOOLEAN, PROP_NONE);
1337   RNA_def_property_boolean_sdna(prop, NULL, "build_size_flags", SEQ_PROXY_IMAGE_SIZE_50);
1338   RNA_def_property_ui_text(prop, "50%", "Build 50% proxy resolution");
1339
1340   prop = RNA_def_property(srna, "build_75", PROP_BOOLEAN, PROP_NONE);
1341   RNA_def_property_boolean_sdna(prop, NULL, "build_size_flags", SEQ_PROXY_IMAGE_SIZE_75);
1342   RNA_def_property_ui_text(prop, "75%", "Build 75% proxy resolution");
1343
1344   prop = RNA_def_property(srna, "build_100", PROP_BOOLEAN, PROP_NONE);
1345   RNA_def_property_boolean_sdna(prop, NULL, "build_size_flags", SEQ_PROXY_IMAGE_SIZE_100);
1346   RNA_def_property_ui_text(prop, "100%", "Build 100% proxy resolution");
1347
1348   prop = RNA_def_property(srna, "build_record_run", PROP_BOOLEAN, PROP_NONE);
1349   RNA_def_property_boolean_sdna(prop, NULL, "build_tc_flags", SEQ_PROXY_TC_RECORD_RUN);
1350   RNA_def_property_ui_text(prop, "Rec Run", "Build record run time code index");
1351
1352   prop = RNA_def_property(srna, "build_free_run", PROP_BOOLEAN, PROP_NONE);
1353   RNA_def_property_boolean_sdna(prop, NULL, "build_tc_flags", SEQ_PROXY_TC_FREE_RUN);
1354   RNA_def_property_ui_text(prop, "Free Run", "Build free run time code index");
1355
1356   prop = RNA_def_property(srna, "build_free_run_rec_date", PROP_BOOLEAN, PROP_NONE);
1357   RNA_def_property_boolean_sdna(
1358       prop, NULL, "build_tc_flags", SEQ_PROXY_TC_INTERP_REC_DATE_FREE_RUN);
1359   RNA_def_property_ui_text(
1360       prop, "Free Run (Rec Date)", "Build free run time code index using Record Date/Time");
1361
1362   prop = RNA_def_property(srna, "quality", PROP_INT, PROP_UNSIGNED);
1363   RNA_def_property_int_sdna(prop, NULL, "quality");
1364   RNA_def_property_ui_text(prop, "Quality", "JPEG Quality of proxies to build");
1365   RNA_def_property_ui_range(prop, 1, 100, 1, -1);
1366
1367   prop = RNA_def_property(srna, "timecode", PROP_ENUM, PROP_NONE);
1368   RNA_def_property_enum_sdna(prop, NULL, "tc");
1369   RNA_def_property_enum_items(prop, seq_tc_items);
1370   RNA_def_property_ui_text(prop, "Timecode", "Method for reading the inputs timecode");
1371   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_tcindex_update");
1372
1373   prop = RNA_def_property(srna, "use_proxy_custom_directory", PROP_BOOLEAN, PROP_NONE);
1374   RNA_def_property_boolean_sdna(prop, NULL, "storage", SEQ_STORAGE_PROXY_CUSTOM_DIR);
1375   RNA_def_property_ui_text(prop, "Proxy Custom Directory", "Use a custom directory to store data");
1376   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
1377
1378   prop = RNA_def_property(srna, "use_proxy_custom_file", PROP_BOOLEAN, PROP_NONE);
1379   RNA_def_property_boolean_sdna(prop, NULL, "storage", SEQ_STORAGE_PROXY_CUSTOM_FILE);
1380   RNA_def_property_ui_text(prop, "Proxy Custom File", "Use a custom file to read proxy data from");
1381   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
1382 }
1383
1384 static void rna_def_color_balance(BlenderRNA *brna)
1385 {
1386   StructRNA *srna;
1387   PropertyRNA *prop;
1388
1389   srna = RNA_def_struct(brna, "SequenceColorBalanceData", NULL);
1390   RNA_def_struct_ui_text(srna,
1391                          "Sequence Color Balance Data",
1392                          "Color balance parameters for a sequence strip and it's modifiers");
1393   RNA_def_struct_sdna(srna, "StripColorBalance");
1394
1395   prop = RNA_def_property(srna, "lift", PROP_FLOAT, PROP_COLOR_GAMMA);
1396   RNA_def_property_ui_text(prop, "Lift", "Color balance lift (shadows)");
1397   RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
1398   RNA_def_property_float_default(prop, 1.0f);
1399   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceColorBalance_update");
1400
1401   prop = RNA_def_property(srna, "gamma", PROP_FLOAT, PROP_COLOR_GAMMA);
1402   RNA_def_property_ui_text(prop, "Gamma", "Color balance gamma (midtones)");
1403   RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
1404   RNA_def_property_float_default(prop, 1.0f);
1405   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceColorBalance_update");
1406
1407   prop = RNA_def_property(srna, "gain", PROP_FLOAT, PROP_COLOR_GAMMA);
1408   RNA_def_property_ui_text(prop, "Gain", "Color balance gain (highlights)");
1409   RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
1410   RNA_def_property_float_default(prop, 1.0f);
1411   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceColorBalance_update");
1412
1413   prop = RNA_def_property(srna, "invert_gain", PROP_BOOLEAN, PROP_NONE);
1414   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_COLOR_BALANCE_INVERSE_GAIN);
1415   RNA_def_property_ui_text(prop, "Inverse Gain", "Invert the gain color`");
1416   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceColorBalance_update");
1417
1418   prop = RNA_def_property(srna, "invert_gamma", PROP_BOOLEAN, PROP_NONE);
1419   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_COLOR_BALANCE_INVERSE_GAMMA);
1420   RNA_def_property_ui_text(prop, "Inverse Gamma", "Invert the gamma color");
1421   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceColorBalance_update");
1422
1423   prop = RNA_def_property(srna, "invert_lift", PROP_BOOLEAN, PROP_NONE);
1424   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_COLOR_BALANCE_INVERSE_LIFT);
1425   RNA_def_property_ui_text(prop, "Inverse Lift", "Invert the lift color");
1426   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceColorBalance_update");
1427
1428   /* not yet used */
1429 #  if 0
1430   prop = RNA_def_property(srna, "exposure", PROP_FLOAT, PROP_NONE);
1431   RNA_def_property_range(prop, 0.0f, 1.0f);
1432   RNA_def_property_ui_text(prop, "Exposure", "");
1433   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_ColorBabalnce_update");
1434
1435   prop = RNA_def_property(srna, "saturation", PROP_FLOAT, PROP_NONE);
1436   RNA_def_property_range(prop, 0.0f, 1.0f);
1437   RNA_def_property_ui_text(prop, "Saturation", "");
1438   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_ColorBabalnce_update");
1439 #  endif
1440
1441   RNA_def_struct_path_func(srna, "rna_SequenceColorBalance_path");
1442 }
1443
1444 static void rna_def_strip_color_balance(BlenderRNA *brna)
1445 {
1446   StructRNA *srna;
1447
1448   srna = RNA_def_struct(brna, "SequenceColorBalance", "SequenceColorBalanceData");
1449   RNA_def_struct_ui_text(
1450       srna, "Sequence Color Balance", "Color balance parameters for a sequence strip");
1451   RNA_def_struct_sdna(srna, "StripColorBalance");
1452 }
1453
1454 static const EnumPropertyItem blend_mode_items[] = {
1455     {SEQ_BLEND_REPLACE, "REPLACE", 0, "Replace", ""},
1456     {SEQ_TYPE_CROSS, "CROSS", 0, "Cross", ""},
1457     {0, "", ICON_NONE, NULL, NULL},
1458     {SEQ_TYPE_DARKEN, "DARKEN", 0, "Darken", ""},
1459     {SEQ_TYPE_MUL, "MULTIPLY", 0, "Multiply", ""},
1460     {SEQ_TYPE_COLOR_BURN, "BURN", 0, "Color Burn", ""},
1461     {SEQ_TYPE_LINEAR_BURN, "LINEAR_BURN", 0, "Linear Burn", ""},
1462     {0, "", ICON_NONE, NULL, NULL},
1463     {SEQ_TYPE_LIGHTEN, "LIGHTEN", 0, "Lighten", ""},
1464     {SEQ_TYPE_SCREEN, "SCREEN", 0, "Screen", ""},
1465     {SEQ_TYPE_DODGE, "DODGE", 0, "Dodge", ""},
1466     {SEQ_TYPE_ADD, "ADD", 0, "Add", ""},
1467     {0, "", ICON_NONE, NULL, NULL},
1468     {SEQ_TYPE_OVERLAY, "OVERLAY", 0, "Overlay", ""},
1469     {SEQ_TYPE_SOFT_LIGHT, "SOFT_LIGHT", 0, "Soft Light", ""},
1470     {SEQ_TYPE_HARD_LIGHT, "HARD_LIGHT", 0, "Hard Light", ""},
1471     {SEQ_TYPE_VIVID_LIGHT, "VIVID_LIGHT", 0, "Vivid Light", ""},
1472     {SEQ_TYPE_LIN_LIGHT, "LINEAR_LIGHT", 0, "Linear Light", ""},
1473     {SEQ_TYPE_PIN_LIGHT, "PIN_LIGHT", 0, "Pin Light", ""},
1474     {0, "", ICON_NONE, NULL, NULL},
1475     {SEQ_TYPE_DIFFERENCE, "DIFFERENCE", 0, "Difference", ""},
1476     {SEQ_TYPE_EXCLUSION, "EXCLUSION", 0, "Exclusion", ""},
1477     {SEQ_TYPE_SUB, "SUBTRACT", 0, "Subtract", ""},
1478     {0, "", ICON_NONE, NULL, NULL},
1479     {SEQ_TYPE_HUE, "HUE", 0, "Hue", ""},
1480     {SEQ_TYPE_SATURATION, "SATURATION", 0, "Saturation", ""},
1481     {SEQ_TYPE_BLEND_COLOR, "COLOR", 0, "Color", ""},
1482     {SEQ_TYPE_VALUE, "VALUE", 0, "Value", ""},
1483     {0, "", ICON_NONE, NULL, NULL},
1484     {SEQ_TYPE_ALPHAOVER, "ALPHA_OVER", 0, "Alpha Over", ""},
1485     {SEQ_TYPE_ALPHAUNDER, "ALPHA_UNDER", 0, "Alpha Under", ""},
1486     {SEQ_TYPE_GAMCROSS, "GAMMA_CROSS", 0, "Gamma Cross", ""},
1487     {SEQ_TYPE_OVERDROP, "OVER_DROP", 0, "Over Drop", ""},
1488     {0, NULL, 0, NULL, NULL},
1489 };
1490
1491 static void rna_def_sequence_modifiers(BlenderRNA *brna, PropertyRNA *cprop)
1492 {
1493   StructRNA *srna;
1494
1495   FunctionRNA *func;
1496   PropertyRNA *parm;
1497
1498   RNA_def_property_srna(cprop, "SequenceModifiers");
1499   srna = RNA_def_struct(brna, "SequenceModifiers", NULL);
1500   RNA_def_struct_sdna(srna, "Sequence");
1501   RNA_def_struct_ui_text(srna, "Strip Modifiers", "Collection of strip modifiers");
1502
1503   /* add modifier */
1504   func = RNA_def_function(srna, "new", "rna_Sequence_modifier_new");
1505   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
1506   RNA_def_function_ui_description(func, "Add a new modifier");
1507   parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the modifier");
1508   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1509   /* modifier to add */
1510   parm = RNA_def_enum(func,
1511                       "type",
1512                       rna_enum_sequence_modifier_type_items,
1513                       seqModifierType_ColorBalance,
1514                       "",
1515                       "Modifier type to add");
1516   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1517   /* return type */
1518   parm = RNA_def_pointer(func, "modifier", "SequenceModifier", "", "Newly created modifier");
1519   RNA_def_function_return(func, parm);
1520
1521   /* remove modifier */
1522   func = RNA_def_function(srna, "remove", "rna_Sequence_modifier_remove");
1523   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
1524   RNA_def_function_ui_description(func, "Remove an existing modifier from the sequence");
1525   /* modifier to remove */
1526   parm = RNA_def_pointer(func, "modifier", "SequenceModifier", "", "Modifier to remove");
1527   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1528   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1529
1530   /* clear all modifiers */
1531   func = RNA_def_function(srna, "clear", "rna_Sequence_modifier_clear");
1532   RNA_def_function_flag(func, FUNC_USE_CONTEXT);
1533   RNA_def_function_ui_description(func, "Remove all modifiers from the sequence");
1534 }
1535
1536 static void rna_def_sequence(BlenderRNA *brna)
1537 {
1538   StructRNA *srna;
1539   PropertyRNA *prop;
1540
1541   static const EnumPropertyItem seq_type_items[] = {
1542       {SEQ_TYPE_IMAGE, "IMAGE", 0, "Image", ""},
1543       {SEQ_TYPE_META, "META", 0, "Meta", ""},
1544       {SEQ_TYPE_SCENE, "SCENE", 0, "Scene", ""},
1545       {SEQ_TYPE_MOVIE, "MOVIE", 0, "Movie", ""},
1546       {SEQ_TYPE_MOVIECLIP, "MOVIECLIP", 0, "Clip", ""},
1547       {SEQ_TYPE_MASK, "MASK", 0, "Mask", ""},
1548       {SEQ_TYPE_SOUND_RAM, "SOUND", 0, "Sound", ""},
1549       {SEQ_TYPE_CROSS, "CROSS", 0, "Cross", ""},
1550       {SEQ_TYPE_ADD, "ADD", 0, "Add", ""},
1551       {SEQ_TYPE_SUB, "SUBTRACT", 0, "Subtract", ""},
1552       {SEQ_TYPE_ALPHAOVER, "ALPHA_OVER", 0, "Alpha Over", ""},
1553       {SEQ_TYPE_ALPHAUNDER, "ALPHA_UNDER", 0, "Alpha Under", ""},
1554       {SEQ_TYPE_GAMCROSS, "GAMMA_CROSS", 0, "Gamma Cross", ""},
1555       {SEQ_TYPE_MUL, "MULTIPLY", 0, "Multiply", ""},
1556       {SEQ_TYPE_OVERDROP, "OVER_DROP", 0, "Over Drop", ""},
1557       {SEQ_TYPE_WIPE, "WIPE", 0, "Wipe", ""},
1558       {SEQ_TYPE_GLOW, "GLOW", 0, "Glow", ""},
1559       {SEQ_TYPE_TRANSFORM, "TRANSFORM", 0, "Transform", ""},
1560       {SEQ_TYPE_COLOR, "COLOR", 0, "Color", ""},
1561       {SEQ_TYPE_SPEED, "SPEED", 0, "Speed", ""},
1562       {SEQ_TYPE_MULTICAM, "MULTICAM", 0, "Multicam Selector", ""},
1563       {SEQ_TYPE_ADJUSTMENT, "ADJUSTMENT", 0, "Adjustment Layer", ""},
1564       {SEQ_TYPE_GAUSSIAN_BLUR, "GAUSSIAN_BLUR", 0, "Gaussian Blur", ""},
1565       {SEQ_TYPE_TEXT, "TEXT", 0, "Text", ""},
1566       {SEQ_TYPE_COLORMIX, "COLORMIX", 0, "Color Mix", ""},
1567       {0, NULL, 0, NULL, NULL},
1568   };
1569
1570   srna = RNA_def_struct(brna, "Sequence", NULL);
1571   RNA_def_struct_ui_text(srna, "Sequence", "Sequence strip in the sequence editor");
1572   RNA_def_struct_refine_func(srna, "rna_Sequence_refine");
1573   RNA_def_struct_path_func(srna, "rna_Sequence_path");
1574   RNA_def_struct_idprops_func(srna, "rna_Sequence_idprops");
1575
1576   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1577   RNA_def_property_string_funcs(
1578       prop, "rna_Sequence_name_get", "rna_Sequence_name_length", "rna_Sequence_name_set");
1579   RNA_def_property_string_maxlength(prop, sizeof(((Sequence *)NULL)->name) - 2);
1580   RNA_def_property_ui_text(prop, "Name", "");
1581   RNA_def_struct_name_property(srna, prop);
1582   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
1583
1584   prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1585   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1586   RNA_def_property_enum_items(prop, seq_type_items);
1587   RNA_def_property_ui_text(prop, "Type", "");
1588   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_SEQUENCE);
1589   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
1590
1591   /* flags */
1592   prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1593   RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
1594   RNA_def_property_ui_text(prop, "Select", "");
1595   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER | NA_SELECTED, NULL);
1596
1597   prop = RNA_def_property(srna, "select_left_handle", PROP_BOOLEAN, PROP_NONE);
1598   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_LEFTSEL);
1599   RNA_def_property_ui_text(prop, "Left Handle Selected", "");
1600   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER | NA_SELECTED, NULL);
1601
1602   prop = RNA_def_property(srna, "select_right_handle", PROP_BOOLEAN, PROP_NONE);
1603   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_RIGHTSEL);
1604   RNA_def_property_ui_text(prop, "Right Handle Selected", "");
1605   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER | NA_SELECTED, NULL);
1606
1607   prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
1608   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_MUTE);
1609   RNA_def_property_ui_icon(prop, ICON_CHECKBOX_HLT, -1);
1610   RNA_def_property_ui_text(
1611       prop, "Mute", "Disable strip so that it cannot be viewed in the output");
1612   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_mute_update");
1613
1614   prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
1615   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_LOCK);
1616   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1617   RNA_def_property_ui_icon(prop, ICON_UNLOCKED, true);
1618   RNA_def_property_ui_text(prop, "Lock", "Lock strip so that it cannot be transformed");
1619   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
1620
1621   /* strip positioning */
1622   prop = RNA_def_property(srna, "frame_final_duration", PROP_INT, PROP_TIME);
1623   RNA_def_property_range(prop, 1, MAXFRAME);
1624   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1625   RNA_def_property_ui_text(
1626       prop, "Length", "The length of the contents of this strip after the handles are applied");
1627   RNA_def_property_int_funcs(
1628       prop, "rna_Sequence_frame_length_get", "rna_Sequence_frame_length_set", NULL);
1629   RNA_def_property_editable_func(prop, "rna_Sequence_frame_editable");
1630   RNA_def_property_update(
1631       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
1632
1633   prop = RNA_def_property(srna, "frame_duration", PROP_INT, PROP_TIME);
1634   RNA_def_property_int_sdna(prop, NULL, "len");
1635   RNA_def_property_clear_flag(prop, PROP_EDITABLE | PROP_ANIMATABLE);
1636   RNA_def_property_range(prop, 1, MAXFRAME);
1637   RNA_def_property_ui_text(
1638       prop, "Length", "The length of the contents of this strip before the handles are applied");
1639
1640   prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_TIME);
1641   RNA_def_property_int_sdna(prop, NULL, "start");
1642   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1643   RNA_def_property_ui_text(prop, "Start Frame", "X position where the strip begins");
1644   RNA_def_property_int_funcs(
1645       prop, NULL, "rna_Sequence_start_frame_set", NULL); /* overlap tests and calc_seq_disp */
1646   RNA_def_property_editable_func(prop, "rna_Sequence_frame_editable");
1647   RNA_def_property_update(
1648       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
1649
1650   prop = RNA_def_property(srna, "frame_final_start", PROP_INT, PROP_TIME);
1651   RNA_def_property_int_sdna(prop, NULL, "startdisp");
1652   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1653   RNA_def_property_ui_text(
1654       prop,
1655       "Start Frame",
1656       "Start frame displayed in the sequence editor after offsets are applied, setting this is "
1657       "equivalent to moving the handle, not the actual start frame");
1658   /* overlap tests and calc_seq_disp */
1659   RNA_def_property_int_funcs(prop, NULL, "rna_Sequence_start_frame_final_set", NULL);
1660   RNA_def_property_editable_func(prop, "rna_Sequence_frame_editable");
1661   RNA_def_property_update(
1662       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
1663
1664   prop = RNA_def_property(srna, "frame_final_end", PROP_INT, PROP_TIME);
1665   RNA_def_property_int_sdna(prop, NULL, "enddisp");
1666   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1667   RNA_def_property_ui_text(
1668       prop, "End Frame", "End frame displayed in the sequence editor after offsets are applied");
1669   /* overlap tests and calc_seq_disp */
1670   RNA_def_property_int_funcs(prop, NULL, "rna_Sequence_end_frame_final_set", NULL);
1671   RNA_def_property_editable_func(prop, "rna_Sequence_frame_editable");
1672   RNA_def_property_update(
1673       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
1674
1675   prop = RNA_def_property(srna, "frame_offset_start", PROP_INT, PROP_TIME);
1676   RNA_def_property_int_sdna(prop, NULL, "startofs");
1677   //  RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* overlap tests */
1678   RNA_def_property_ui_text(prop, "Start Offset", "");
1679   RNA_def_property_int_funcs(prop, NULL, NULL, "rna_Sequence_frame_offset_range");
1680   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_frame_change_update");
1681
1682   prop = RNA_def_property(srna, "frame_offset_end", PROP_INT, PROP_TIME);
1683   RNA_def_property_int_sdna(prop, NULL, "endofs");
1684   //  RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* overlap tests */
1685   RNA_def_property_ui_text(prop, "End Offset", "");
1686   RNA_def_property_int_funcs(prop, NULL, NULL, "rna_Sequence_frame_offset_range");
1687   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_frame_change_update");
1688
1689   prop = RNA_def_property(srna, "frame_still_start", PROP_INT, PROP_TIME);
1690   RNA_def_property_int_sdna(prop, NULL, "startstill");
1691   //  RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* overlap tests */
1692   RNA_def_property_range(prop, 0, MAXFRAME);
1693   RNA_def_property_ui_text(prop, "Start Still", "");
1694   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_frame_change_update");
1695
1696   prop = RNA_def_property(srna, "frame_still_end", PROP_INT, PROP_TIME);
1697   RNA_def_property_int_sdna(prop, NULL, "endstill");
1698   //  RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* overlap tests */
1699   RNA_def_property_range(prop, 0, MAXFRAME);
1700   RNA_def_property_ui_text(prop, "End Still", "");
1701   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_frame_change_update");
1702
1703   prop = RNA_def_property(srna, "channel", PROP_INT, PROP_UNSIGNED);
1704   RNA_def_property_int_sdna(prop, NULL, "machine");
1705   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1706   RNA_def_property_range(prop, 1, MAXSEQ);
1707   RNA_def_property_ui_text(prop, "Channel", "Y position of the sequence strip");
1708   RNA_def_property_int_funcs(prop, NULL, "rna_Sequence_channel_set", NULL); /* overlap test */
1709   RNA_def_property_update(
1710       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
1711
1712   prop = RNA_def_property(srna, "use_linear_modifiers", PROP_BOOLEAN, PROP_NONE);
1713   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_LINEAR_MODIFIERS);
1714   RNA_def_property_ui_text(prop,
1715                            "Use Linear Modifiers",
1716                            "Calculate modifiers in linear space instead of sequencer's space");
1717   RNA_def_property_update(
1718       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
1719
1720   /* blending */
1721
1722   prop = RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
1723   RNA_def_property_enum_sdna(prop, NULL, "blend_mode");
1724   RNA_def_property_enum_items(prop, blend_mode_items);
1725   RNA_def_property_ui_text(
1726       prop, "Blend Mode", "Method for controlling how the strip combines with other strips");
1727   RNA_def_property_update(
1728       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
1729
1730   prop = RNA_def_property(srna, "blend_alpha", PROP_FLOAT, PROP_FACTOR);
1731   RNA_def_property_range(prop, 0.0f, 1.0f);
1732   RNA_def_property_ui_text(
1733       prop, "Blend Opacity", "Percentage of how much the strip's colors affect other strips");
1734   /* stupid 0-100 -> 0-1 */
1735   RNA_def_property_float_funcs(prop, "rna_Sequence_opacity_get", "rna_Sequence_opacity_set", NULL);
1736   RNA_def_property_update(
1737       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_composite_update");
1738
1739   prop = RNA_def_property(srna, "effect_fader", PROP_FLOAT, PROP_FACTOR);
1740   RNA_def_property_range(prop, 0.0f, 1.0f);
1741   RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.1, 3);
1742   RNA_def_property_float_sdna(prop, NULL, "effect_fader");
1743   RNA_def_property_ui_text(prop, "Effect Fader Position", "Custom fade value");
1744   RNA_def_property_update(
1745       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
1746
1747   prop = RNA_def_property(srna, "use_default_fade", PROP_BOOLEAN, PROP_NONE);
1748   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_EFFECT_DEFAULT_FADE);
1749   RNA_def_property_ui_text(
1750       prop,
1751       "Use Default Fade",
1752       "Fade effect using the built-in default (usually make transition as long as "
1753       "effect strip)");
1754   RNA_def_property_update(
1755       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
1756
1757   prop = RNA_def_property(srna, "speed_factor", PROP_FLOAT, PROP_NONE);
1758   RNA_def_property_float_sdna(prop, NULL, "speed_fader");
1759   RNA_def_property_ui_text(
1760       prop,
1761       "Speed Factor",
1762       "Multiply the current speed of the sequence with this number or remap current frame "
1763       "to this frame");
1764   RNA_def_property_update(
1765       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
1766
1767   /* modifiers */
1768   prop = RNA_def_property(srna, "modifiers", PROP_COLLECTION, PROP_NONE);
1769   RNA_def_property_struct_type(prop, "SequenceModifier");
1770   RNA_def_property_ui_text(prop, "Modifiers", "Modifiers affecting this strip");
1771   rna_def_sequence_modifiers(brna, prop);
1772
1773   prop = RNA_def_property(srna, "use_cache_raw", PROP_BOOLEAN, PROP_NONE);
1774   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_STORE_RAW);
1775   RNA_def_property_ui_text(prop,
1776                            "Cache Raw",
1777                            "Cache raw images read from disk, for faster tweaking of strip "
1778                            "parameters at the cost of memory usage");
1779
1780   prop = RNA_def_property(srna, "use_cache_preprocessed", PROP_BOOLEAN, PROP_NONE);
1781   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_STORE_PREPROCESSED);
1782   RNA_def_property_ui_text(
1783       prop,
1784       "Cache Preprocessed",
1785       "Cache preprocessed images, for faster tweaking of effects at the cost of memory usage");
1786
1787   prop = RNA_def_property(srna, "use_cache_composite", PROP_BOOLEAN, PROP_NONE);
1788   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_STORE_COMPOSITE);
1789   RNA_def_property_ui_text(prop,
1790                            "Cache Composite",
1791                            "Cache intermediate composited images, for faster tweaking of stacked "
1792                            "strips at the cost of memory usage");
1793
1794   prop = RNA_def_property(srna, "override_cache_settings", PROP_BOOLEAN, PROP_NONE);
1795   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_OVERRIDE);
1796   RNA_def_property_ui_text(prop, "Override Cache Settings", "Override global cache settings");
1797
1798   RNA_api_sequence_strip(srna);
1799 }
1800
1801 static void rna_def_editor(BlenderRNA *brna)
1802 {
1803   StructRNA *srna;
1804   PropertyRNA *prop;
1805
1806   static const EnumPropertyItem editing_storage_items[] = {
1807       {0, "PER_STRIP", 0, "Per Strip", "Store proxies using per strip settings"},
1808       {SEQ_EDIT_PROXY_DIR_STORAGE,
1809        "PROJECT",
1810        0,
1811        "Project",
1812        "Store proxies using project directory"},
1813       {0, NULL, 0, NULL, NULL},
1814   };
1815   srna = RNA_def_struct(brna, "SequenceEditor", NULL);
1816   RNA_def_struct_ui_text(srna, "Sequence Editor", "Sequence editing data for a Scene data-block");
1817   RNA_def_struct_ui_icon(srna, ICON_SEQUENCE);
1818   RNA_def_struct_sdna(srna, "Editing");
1819
1820   prop = RNA_def_property(srna, "sequences", PROP_COLLECTION, PROP_NONE);
1821   RNA_def_property_collection_sdna(prop, NULL, "seqbase", NULL);
1822   RNA_def_property_struct_type(prop, "Sequence");
1823   RNA_def_property_ui_text(prop, "Sequences", "Top-level strips only");
1824   RNA_api_sequences(brna, prop);
1825
1826   prop = RNA_def_property(srna, "sequences_all", PROP_COLLECTION, PROP_NONE);
1827   RNA_def_property_collection_sdna(prop, NULL, "seqbase", NULL);
1828   RNA_def_property_struct_type(prop, "Sequence");
1829   RNA_def_property_ui_text(
1830       prop, "All Sequences", "All strips, recursively including those inside metastrips");
1831   RNA_def_property_collection_funcs(prop,
1832                                     "rna_SequenceEditor_sequences_all_begin",
1833                                     "rna_SequenceEditor_sequences_all_next",
1834                                     NULL,
1835                                     NULL,
1836                                     NULL,
1837                                     NULL,
1838                                     NULL,
1839                                     NULL);
1840
1841   prop = RNA_def_property(srna, "meta_stack", PROP_COLLECTION, PROP_NONE);
1842   RNA_def_property_collection_sdna(prop, NULL, "metastack", NULL);
1843   RNA_def_property_struct_type(prop, "Sequence");
1844   RNA_def_property_ui_text(
1845       prop, "Meta Stack", "Meta strip stack, last is currently edited meta strip");
1846   RNA_def_property_collection_funcs(
1847       prop, NULL, NULL, NULL, "rna_SequenceEditor_meta_stack_get", NULL, NULL, NULL, NULL);
1848
1849   prop = RNA_def_property(srna, "active_strip", PROP_POINTER, PROP_NONE);
1850   RNA_def_property_pointer_sdna(prop, NULL, "act_seq");
1851   RNA_def_property_flag(prop, PROP_EDITABLE);
1852   RNA_def_property_ui_text(prop, "Active Strip", "Sequencer's active strip");
1853
1854   prop = RNA_def_property(srna, "show_overlay", PROP_BOOLEAN, PROP_NONE);
1855   RNA_def_property_boolean_sdna(prop, NULL, "over_flag", SEQ_EDIT_OVERLAY_SHOW);
1856   RNA_def_property_ui_text(
1857       prop, "Show Overlay", "Partial overlay on top of the sequencer with a frame offset");
1858   RNA_def_property_update(prop, NC_SPACE | ND_SPACE_SEQUENCER, NULL);
1859
1860   prop = RNA_def_property(srna, "use_overlay_lock", PROP_BOOLEAN, PROP_NONE);
1861   RNA_def_property_boolean_sdna(prop, NULL, "over_flag", SEQ_EDIT_OVERLAY_ABS);
1862   RNA_def_property_ui_text(prop, "Overlay Lock", "");
1863   RNA_def_property_boolean_funcs(prop, NULL, "rna_SequenceEditor_overlay_lock_set");
1864   RNA_def_property_update(prop, NC_SPACE | ND_SPACE_SEQUENCER, NULL);
1865
1866   /* access to fixed and relative frame */
1867   prop = RNA_def_property(srna, "overlay_frame", PROP_INT, PROP_NONE);
1868   RNA_def_property_ui_text(prop, "Overlay Offset", "Number of frames to offset");
1869   RNA_def_property_int_funcs(
1870       prop, "rna_SequenceEditor_overlay_frame_get", "rna_SequenceEditor_overlay_frame_set", NULL);
1871   RNA_def_property_update(prop, NC_SPACE | ND_SPACE_SEQUENCER, NULL);
1872
1873   prop = RNA_def_property(srna, "proxy_storage", PROP_ENUM, PROP_NONE);
1874   RNA_def_property_enum_items(prop, editing_storage_items);
1875   RNA_def_property_ui_text(prop, "Proxy Storage", "How to store proxies for this project");
1876   RNA_def_property_update(prop, NC_SPACE | ND_SPACE_SEQUENCER, "rna_SequenceEditor_update_cache");
1877
1878   prop = RNA_def_property(srna, "proxy_dir", PROP_STRING, PROP_DIRPATH);
1879   RNA_def_property_string_sdna(prop, NULL, "proxy_dir");
1880   RNA_def_property_ui_text(prop, "Proxy Directory", "");
1881   RNA_def_property_update(prop, NC_SPACE | ND_SPACE_SEQUENCER, "rna_SequenceEditor_update_cache");
1882
1883   /* cache flags */
1884
1885   prop = RNA_def_property(srna, "show_cache", PROP_BOOLEAN, PROP_NONE);
1886   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_VIEW_ENABLE);
1887   RNA_def_property_ui_text(prop, "Show Cache", "Visualize cached images on the timeline");
1888   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
1889
1890   prop = RNA_def_property(srna, "show_cache_final_out", PROP_BOOLEAN, PROP_NONE);
1891   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_VIEW_FINAL_OUT);
1892   RNA_def_property_ui_text(prop, "Final Images", "Visualize cached complete frames");
1893   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
1894
1895   prop = RNA_def_property(srna, "show_cache_raw", PROP_BOOLEAN, PROP_NONE);
1896   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_VIEW_RAW);
1897   RNA_def_property_ui_text(prop, "Raw Images", "Visualize cached raw images");
1898   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
1899
1900   prop = RNA_def_property(srna, "show_cache_preprocessed", PROP_BOOLEAN, PROP_NONE);
1901   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_VIEW_PREPROCESSED);
1902   RNA_def_property_ui_text(prop, "Preprocessed Images", "Visualize cached preprocessed images");
1903   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
1904
1905   prop = RNA_def_property(srna, "show_cache_composite", PROP_BOOLEAN, PROP_NONE);
1906   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_VIEW_COMPOSITE);
1907   RNA_def_property_ui_text(prop, "Composite Images", "Visualize cached composite images");
1908   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
1909
1910   prop = RNA_def_property(srna, "use_cache_raw", PROP_BOOLEAN, PROP_NONE);
1911   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_STORE_RAW);
1912   RNA_def_property_ui_text(prop,
1913                            "Cache Raw",
1914                            "Cache raw images read from disk, for faster tweaking of strip "
1915                            "parameters at the cost of memory usage");
1916
1917   prop = RNA_def_property(srna, "use_cache_preprocessed", PROP_BOOLEAN, PROP_NONE);
1918   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_STORE_PREPROCESSED);
1919   RNA_def_property_ui_text(
1920       prop,
1921       "Cache Preprocessed",
1922       "Cache preprocessed images, for faster tweaking of effects at the cost of memory usage");
1923
1924   prop = RNA_def_property(srna, "use_cache_composite", PROP_BOOLEAN, PROP_NONE);
1925   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_STORE_COMPOSITE);
1926   RNA_def_property_ui_text(prop,
1927                            "Cache Composite",
1928                            "Cache intermediate composited images, for faster tweaking of stacked "
1929                            "strips at the cost of memory usage");
1930
1931   prop = RNA_def_property(srna, "use_cache_final", PROP_BOOLEAN, PROP_NONE);
1932   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_STORE_FINAL_OUT);
1933   RNA_def_property_ui_text(prop, "Cache Final", "Cache final image for each frame");
1934
1935   prop = RNA_def_property(srna, "use_prefetch", PROP_BOOLEAN, PROP_NONE);
1936   RNA_def_property_boolean_sdna(prop, NULL, "cache_flag", SEQ_CACHE_PREFETCH_ENABLE);
1937   RNA_def_property_ui_text(prop,
1938                            "Prefetch frames",
1939                            "Render frames ahead of playhead in background for faster playback");
1940   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
1941
1942   prop = RNA_def_property(srna, "recycle_max_cost", PROP_FLOAT, PROP_NONE);
1943   RNA_def_property_range(prop, 0.0f, SEQ_CACHE_COST_MAX);
1944   RNA_def_property_ui_range(prop, 0.0f, SEQ_CACHE_COST_MAX, 0.1f, 1);
1945   RNA_def_property_float_sdna(prop, NULL, "recycle_max_cost");
1946   RNA_def_property_ui_text(
1947       prop, "Recycle Up to Cost", "Only frames with cost lower than this value will be recycled");
1948 }
1949
1950 static void rna_def_filter_video(StructRNA *srna)
1951 {
1952   PropertyRNA *prop;
1953
1954   static const EnumPropertyItem alpha_mode_items[] = {
1955       {SEQ_ALPHA_STRAIGHT,
1956        "STRAIGHT",
1957        0,
1958        "Straight",
1959        "RGB channels in transparent pixels are unaffected by the alpha channel"},
1960       {SEQ_ALPHA_PREMUL,
1961        "PREMUL",
1962        0,
1963        "Premultiplied",
1964        "RGB channels in transparent pixels are multiplied by the alpha channel"},
1965       {0, NULL, 0, NULL, NULL},
1966   };
1967
1968   prop = RNA_def_property(srna, "use_deinterlace", PROP_BOOLEAN, PROP_NONE);
1969   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_FILTERY);
1970   RNA_def_property_ui_text(prop, "Deinterlace", "Remove fields from video movies");
1971   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_reopen_files_update");
1972
1973   prop = RNA_def_property(srna, "alpha_mode", PROP_ENUM, PROP_NONE);
1974   RNA_def_property_enum_items(prop, alpha_mode_items);
1975   RNA_def_property_ui_text(
1976       prop, "Alpha Mode", "Representation of alpha information in the RGBA pixels");
1977   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
1978
1979   prop = RNA_def_property(srna, "use_flip_x", PROP_BOOLEAN, PROP_NONE);
1980   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_FLIPX);
1981   RNA_def_property_ui_text(prop, "Flip X", "Flip on the X axis");
1982   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
1983
1984   prop = RNA_def_property(srna, "use_flip_y", PROP_BOOLEAN, PROP_NONE);
1985   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_FLIPY);
1986   RNA_def_property_ui_text(prop, "Flip Y", "Flip on the Y axis");
1987   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
1988
1989   prop = RNA_def_property(srna, "use_float", PROP_BOOLEAN, PROP_NONE);
1990   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_MAKE_FLOAT);
1991   RNA_def_property_ui_text(prop, "Convert Float", "Convert input to float data");
1992   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
1993
1994   prop = RNA_def_property(srna, "use_reverse_frames", PROP_BOOLEAN, PROP_NONE);
1995   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_REVERSE_FRAMES);
1996   RNA_def_property_ui_text(prop, "Reverse Frames", "Reverse frame order");
1997   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
1998
1999   prop = RNA_def_property(srna, "color_multiply", PROP_FLOAT, PROP_UNSIGNED);
2000   RNA_def_property_float_sdna(prop, NULL, "mul");
2001   RNA_def_property_range(prop, 0.0f, 20.0f);
2002   RNA_def_property_float_default(prop, 1.0f);
2003   RNA_def_property_ui_text(prop, "Multiply Colors", "");
2004   RNA_def_property_update(
2005       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2006
2007   prop = RNA_def_property(srna, "color_saturation", PROP_FLOAT, PROP_UNSIGNED);
2008   RNA_def_property_float_sdna(prop, NULL, "sat");
2009   RNA_def_property_range(prop, 0.0f, 20.0f);
2010   RNA_def_property_ui_range(prop, 0.0f, 2.0f, 3, 3);
2011   RNA_def_property_float_default(prop, 1.0f);
2012   RNA_def_property_ui_text(prop, "Saturation", "Adjust the intensity of the input's color");
2013   RNA_def_property_update(
2014       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2015
2016   prop = RNA_def_property(srna, "strobe", PROP_FLOAT, PROP_NONE);
2017   RNA_def_property_range(prop, 1.0f, 30.0f);
2018   RNA_def_property_ui_text(prop, "Strobe", "Only display every nth frame");
2019   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2020
2021   prop = RNA_def_property(srna, "use_translation", PROP_BOOLEAN, PROP_NONE);
2022   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_TRANSFORM);
2023   RNA_def_property_ui_text(prop, "Use Translation", "Translate image before processing");
2024   RNA_def_property_boolean_funcs(prop, NULL, "rna_Sequence_use_translation_set");
2025   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2026
2027   prop = RNA_def_property(srna, "transform", PROP_POINTER, PROP_NONE);
2028   RNA_def_property_pointer_sdna(prop, NULL, "strip->transform");
2029   RNA_def_property_ui_text(prop, "Transform", "");
2030
2031   prop = RNA_def_property(srna, "use_crop", PROP_BOOLEAN, PROP_NONE);
2032   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_CROP);
2033   RNA_def_property_ui_text(prop, "Use Crop", "Crop image before processing");
2034   RNA_def_property_boolean_funcs(prop, NULL, "rna_Sequence_use_crop_set");
2035   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2036
2037   prop = RNA_def_property(srna, "crop", PROP_POINTER, PROP_NONE);
2038   RNA_def_property_pointer_sdna(prop, NULL, "strip->crop");
2039   RNA_def_property_ui_text(prop, "Crop", "");
2040 }
2041
2042 static void rna_def_proxy(StructRNA *srna)
2043 {
2044   PropertyRNA *prop;
2045
2046   prop = RNA_def_property(srna, "use_proxy", PROP_BOOLEAN, PROP_NONE);
2047   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_PROXY);
2048   RNA_def_property_ui_text(
2049       prop, "Use Proxy / Timecode", "Use a preview proxy and/or timecode index for this strip");
2050   RNA_def_property_boolean_funcs(prop, NULL, "rna_Sequence_use_proxy_set");
2051   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2052
2053   prop = RNA_def_property(srna, "proxy", PROP_POINTER, PROP_NONE);
2054   RNA_def_property_pointer_sdna(prop, NULL, "strip->proxy");
2055   RNA_def_property_ui_text(prop, "Proxy", "");
2056 }
2057
2058 static void rna_def_input(StructRNA *srna)
2059 {
2060   PropertyRNA *prop;
2061
2062   prop = RNA_def_property(srna, "animation_offset_start", PROP_INT, PROP_UNSIGNED);
2063   RNA_def_property_int_sdna(prop, NULL, "anim_startofs");
2064   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2065   RNA_def_property_int_funcs(
2066       prop, NULL, "rna_Sequence_anim_startofs_final_set", NULL); /* overlap tests */
2067   RNA_def_property_ui_text(prop, "Animation Start Offset", "Animation start offset (trim start)");
2068   RNA_def_property_update(
2069       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2070
2071   prop = RNA_def_property(srna, "animation_offset_end", PROP_INT, PROP_UNSIGNED);
2072   RNA_def_property_int_sdna(prop, NULL, "anim_endofs");
2073   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2074   RNA_def_property_int_funcs(
2075       prop, NULL, "rna_Sequence_anim_endofs_final_set", NULL); /* overlap tests */
2076   RNA_def_property_ui_text(prop, "Animation End Offset", "Animation end offset (trim end)");
2077   RNA_def_property_update(
2078       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2079 }
2080
2081 static void rna_def_effect_inputs(StructRNA *srna, int count)
2082 {
2083   PropertyRNA *prop;
2084
2085   prop = RNA_def_property(srna, "input_count", PROP_INT, PROP_UNSIGNED);
2086   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2087   RNA_def_property_int_funcs(prop, "rna_Sequence_input_count_get", NULL, NULL);
2088
2089   if (count >= 1) {
2090     prop = RNA_def_property(srna, "input_1", PROP_POINTER, PROP_NONE);
2091     RNA_def_property_pointer_sdna(prop, NULL, "seq1");
2092     RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
2093     RNA_def_property_ui_text(prop, "Input 1", "First input for the effect strip");
2094   }
2095
2096   if (count >= 2) {
2097     prop = RNA_def_property(srna, "input_2", PROP_POINTER, PROP_NONE);
2098     RNA_def_property_pointer_sdna(prop, NULL, "seq2");
2099     RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
2100     RNA_def_property_ui_text(prop, "Input 2", "Second input for the effect strip");
2101   }
2102
2103 #  if 0
2104   if (count == 3) {
2105     /* Not used by any effects (perhaps one day plugins?). */
2106     prop = RNA_def_property(srna, "input_3", PROP_POINTER, PROP_NONE);
2107     RNA_def_property_pointer_sdna(prop, NULL, "seq3");
2108     RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
2109     RNA_def_property_ui_text(prop, "Input 3", "Third input for the effect strip");
2110   }
2111 #  endif
2112 }
2113
2114 static void rna_def_color_management(StructRNA *srna)
2115 {
2116   PropertyRNA *prop;
2117
2118   prop = RNA_def_property(srna, "colorspace_settings", PROP_POINTER, PROP_NONE);
2119   RNA_def_property_pointer_sdna(prop, NULL, "strip->colorspace_settings");
2120   RNA_def_property_struct_type(prop, "ColorManagedInputColorspaceSettings");
2121   RNA_def_property_ui_text(prop, "Color Space Settings", "Input color space settings");
2122 }
2123
2124 static void rna_def_movie_types(StructRNA *srna)
2125 {
2126   PropertyRNA *prop;
2127
2128   prop = RNA_def_property(srna, "fps", PROP_FLOAT, PROP_NONE);
2129   RNA_def_property_ui_text(prop, "FPS", "Frames per second");
2130   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2131   RNA_def_property_float_funcs(prop, "rna_Sequence_fps_get", NULL, NULL);
2132 }
2133
2134 static void rna_def_image(BlenderRNA *brna)
2135 {
2136   StructRNA *srna;
2137   PropertyRNA *prop;
2138
2139   srna = RNA_def_struct(brna, "ImageSequence", "Sequence");
2140   RNA_def_struct_ui_text(srna, "Image Sequence", "Sequence strip to load one or more images");
2141   RNA_def_struct_sdna(srna, "Sequence");
2142
2143   prop = RNA_def_property(srna, "directory", PROP_STRING, PROP_DIRPATH);
2144   RNA_def_property_string_sdna(prop, NULL, "strip->dir");
2145   RNA_def_property_ui_text(prop, "Directory", "");
2146   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2147
2148   prop = RNA_def_property(srna, "elements", PROP_COLLECTION, PROP_NONE);
2149   RNA_def_property_collection_sdna(prop, NULL, "strip->stripdata", NULL);
2150   RNA_def_property_struct_type(prop, "SequenceElement");
2151   RNA_def_property_ui_text(prop, "Elements", "");
2152   RNA_def_property_collection_funcs(prop,
2153                                     "rna_SequenceEditor_elements_begin",
2154                                     "rna_iterator_array_next",
2155                                     "rna_iterator_array_end",
2156                                     "rna_iterator_array_get",
2157                                     "rna_SequenceEditor_elements_length",
2158                                     NULL,
2159                                     NULL,
2160                                     NULL);
2161   RNA_api_sequence_elements(brna, prop);
2162
2163   /* multiview */
2164   prop = RNA_def_property(srna, "use_multiview", PROP_BOOLEAN, PROP_NONE);
2165   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_VIEWS);
2166   RNA_def_property_ui_text(prop, "Use Multi-View", "Use Multiple Views (when available)");
2167   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_views_format_update");
2168
2169   prop = RNA_def_property(srna, "views_format", PROP_ENUM, PROP_NONE);
2170   RNA_def_property_enum_sdna(prop, NULL, "views_format");
2171   RNA_def_property_enum_items(prop, rna_enum_views_format_items);
2172   RNA_def_property_ui_text(prop, "Views Format", "Mode to load image views");
2173   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Sequence_views_format_update");
2174
2175   prop = RNA_def_property(srna, "stereo_3d_format", PROP_POINTER, PROP_NONE);
2176   RNA_def_property_pointer_sdna(prop, NULL, "stereo3d_format");
2177   RNA_def_property_flag(prop, PROP_NEVER_NULL);
2178   RNA_def_property_struct_type(prop, "Stereo3dFormat");
2179   RNA_def_property_ui_text(prop, "Stereo 3D Format", "Settings for stereo 3d");
2180
2181   rna_def_filter_video(srna);
2182   rna_def_proxy(srna);
2183   rna_def_input(srna);
2184   rna_def_color_management(srna);
2185 }
2186
2187 static void rna_def_meta(BlenderRNA *brna)
2188 {
2189   StructRNA *srna;
2190   PropertyRNA *prop;
2191
2192   srna = RNA_def_struct(brna, "MetaSequence", "Sequence");
2193   RNA_def_struct_ui_text(
2194       srna, "Meta Sequence", "Sequence strip to group other strips as a single sequence strip");
2195   RNA_def_struct_sdna(srna, "Sequence");
2196
2197   prop = RNA_def_property(srna, "sequences", PROP_COLLECTION, PROP_NONE);
2198   RNA_def_property_collection_sdna(prop, NULL, "seqbase", NULL);
2199   RNA_def_property_struct_type(prop, "Sequence");
2200   RNA_def_property_ui_text(prop, "Sequences", "");
2201
2202   rna_def_filter_video(srna);
2203   rna_def_proxy(srna);
2204   rna_def_input(srna);
2205 }
2206
2207 static void rna_def_scene(BlenderRNA *brna)
2208 {
2209   StructRNA *srna;
2210   PropertyRNA *prop;
2211
2212   static const EnumPropertyItem scene_input_items[] = {
2213       {0, "CAMERA", ICON_VIEW3D, "Camera", "Use the Scene's 3D camera as input"},
2214       {SEQ_SCENE_STRIPS,
2215        "SEQUENCER",
2216        ICON_SEQUENCE,
2217        "Sequencer",
2218        "Use the Scene's Sequencer timeline as input"},
2219       {0, NULL, 0, NULL, NULL},
2220   };
2221
2222   srna = RNA_def_struct(brna, "SceneSequence", "Sequence");
2223   RNA_def_struct_ui_text(
2224       srna, "Scene Sequence", "Sequence strip to used the rendered image of a scene");
2225   RNA_def_struct_sdna(srna, "Sequence");
2226
2227   prop = RNA_def_property(srna, "scene", PROP_POINTER, PROP_NONE);
2228   RNA_def_property_flag(prop, PROP_EDITABLE);
2229   RNA_def_property_ui_text(prop, "Scene", "Scene that this sequence uses");
2230   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2231
2232   prop = RNA_def_property(srna, "scene_camera", PROP_POINTER, PROP_NONE);
2233   RNA_def_property_flag(prop, PROP_EDITABLE);
2234   RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, "rna_Camera_object_poll");
2235   RNA_def_property_ui_text(prop, "Camera Override", "Override the scenes active camera");
2236   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2237
2238   prop = RNA_def_property(srna, "scene_input", PROP_ENUM, PROP_NONE);
2239   RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
2240   RNA_def_property_enum_items(prop, scene_input_items);
2241   RNA_def_property_ui_text(prop, "Input", "Input type to use for the Scene strip");
2242   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_use_sequence");
2243
2244   prop = RNA_def_property(srna, "use_grease_pencil", PROP_BOOLEAN, PROP_NONE);
2245   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", SEQ_SCENE_NO_GPENCIL);
2246   RNA_def_property_ui_text(
2247       prop, "Use Grease Pencil", "Show Grease Pencil strokes in OpenGL previews");
2248   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
2249
2250   rna_def_filter_video(srna);
2251   rna_def_proxy(srna);
2252   rna_def_input(srna);
2253   rna_def_movie_types(srna);
2254 }
2255
2256 static void rna_def_movie(BlenderRNA *brna)
2257 {
2258   StructRNA *srna;
2259   PropertyRNA *prop;
2260   FunctionRNA *func;
2261   PropertyRNA *parm;
2262
2263   srna = RNA_def_struct(brna, "MovieSequence", "Sequence");
2264   RNA_def_struct_ui_text(srna, "Movie Sequence", "Sequence strip to load a video");
2265   RNA_def_struct_sdna(srna, "Sequence");
2266
2267   prop = RNA_def_property(srna, "mpeg_preseek", PROP_INT, PROP_NONE);
2268   RNA_def_property_int_sdna(prop, NULL, "anim_preseek");
2269   RNA_def_property_range(prop, 0, 50);
2270   RNA_def_property_ui_text(prop, "MPEG Preseek", "For MPEG movies, preseek this many frames");
2271   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
2272
2273   prop = RNA_def_property(srna, "stream_index", PROP_INT, PROP_NONE);
2274   RNA_def_property_int_sdna(prop, NULL, "streamindex");
2275   RNA_def_property_range(prop, 0, 20);
2276   RNA_def_property_ui_text(
2277       prop,
2278       "Stream Index",
2279       "For files with several movie streams, use the stream with the given index");
2280   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_reopen_files_update");
2281
2282   prop = RNA_def_property(srna, "elements", PROP_COLLECTION, PROP_NONE);
2283   RNA_def_property_collection_sdna(prop, NULL, "strip->stripdata", NULL);
2284   RNA_def_property_struct_type(prop, "SequenceElement");
2285   RNA_def_property_ui_text(prop, "Elements", "");
2286   RNA_def_property_collection_funcs(prop,
2287                                     "rna_SequenceEditor_elements_begin",
2288                                     "rna_iterator_array_next",
2289                                     "rna_iterator_array_end",
2290                                     "rna_iterator_array_get",
2291                                     "rna_SequenceEditor_elements_length",
2292                                     NULL,
2293                                     NULL,
2294                                     NULL);
2295
2296   prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
2297   RNA_def_property_ui_text(prop, "File", "");
2298   RNA_def_property_string_funcs(prop,
2299                                 "rna_Sequence_filepath_get",
2300                                 "rna_Sequence_filepath_length",
2301                                 "rna_Sequence_filepath_set");
2302   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_filepath_update");
2303
2304   /* metadata */
2305   func = RNA_def_function(srna, "metadata", "rna_MovieSequence_metadata_get");
2306   RNA_def_function_ui_description(func, "Retrieve metadata of the movie file");
2307   /* return type */
2308   parm = RNA_def_pointer(
2309       func, "metadata", "IDPropertyWrapPtr", "", "Dict-like object containing the metadata");
2310   RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
2311   RNA_def_function_return(func, parm);
2312
2313   /* multiview */
2314   prop = RNA_def_property(srna, "use_multiview", PROP_BOOLEAN, PROP_NONE);
2315   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_VIEWS);
2316   RNA_def_property_ui_text(prop, "Use Multi-View", "Use Multiple Views (when available)");
2317   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_views_format_update");
2318
2319   prop = RNA_def_property(srna, "views_format", PROP_ENUM, PROP_NONE);
2320   RNA_def_property_enum_sdna(prop, NULL, "views_format");
2321   RNA_def_property_enum_items(prop, rna_enum_views_format_items);
2322   RNA_def_property_ui_text(prop, "Views Format", "Mode to load movie views");
2323   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Sequence_views_format_update");
2324
2325   prop = RNA_def_property(srna, "stereo_3d_format", PROP_POINTER, PROP_NONE);
2326   RNA_def_property_pointer_sdna(prop, NULL, "stereo3d_format");
2327   RNA_def_property_flag(prop, PROP_NEVER_NULL);
2328   RNA_def_property_struct_type(prop, "Stereo3dFormat");
2329   RNA_def_property_ui_text(prop, "Stereo 3D Format", "Settings for stereo 3d");
2330
2331   rna_def_filter_video(srna);
2332   rna_def_proxy(srna);
2333   rna_def_input(srna);
2334   rna_def_color_management(srna);
2335   rna_def_movie_types(srna);
2336 }
2337
2338 static void rna_def_movieclip(BlenderRNA *brna)
2339 {
2340   StructRNA *srna;
2341   PropertyRNA *prop;
2342
2343   srna = RNA_def_struct(brna, "MovieClipSequence", "Sequence");
2344   RNA_def_struct_ui_text(
2345       srna, "MovieClip Sequence", "Sequence strip to load a video from the clip editor");
2346   RNA_def_struct_sdna(srna, "Sequence");
2347
2348   /* TODO - add clip property? */
2349
2350   prop = RNA_def_property(srna, "undistort", PROP_BOOLEAN, PROP_NONE);
2351   RNA_def_property_boolean_sdna(prop, NULL, "clip_flag", SEQ_MOVIECLIP_RENDER_UNDISTORTED);
2352   RNA_def_property_ui_text(prop, "Undistort Clip", "Use the undistorted version of the clip");
2353   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2354
2355   prop = RNA_def_property(srna, "stabilize2d", PROP_BOOLEAN, PROP_NONE);
2356   RNA_def_property_boolean_sdna(prop, NULL, "clip_flag", SEQ_MOVIECLIP_RENDER_STABILIZED);
2357   RNA_def_property_ui_text(prop, "Stabilize 2D Clip", "Use the 2D stabilized version of the clip");
2358   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2359
2360   rna_def_filter_video(srna);
2361   rna_def_input(srna);
2362   rna_def_movie_types(srna);
2363 }
2364
2365 static void rna_def_mask(BlenderRNA *brna)
2366 {
2367   StructRNA *srna;
2368   PropertyRNA *prop;
2369
2370   srna = RNA_def_struct(brna, "MaskSequence", "Sequence");
2371   RNA_def_struct_ui_text(srna, "Mask Sequence", "Sequence strip to load a video from a mask");
2372   RNA_def_struct_sdna(srna, "Sequence");
2373
2374   prop = RNA_def_property(srna, "mask", PROP_POINTER, PROP_NONE);
2375   RNA_def_property_flag(prop, PROP_EDITABLE);
2376   RNA_def_property_ui_text(prop, "Mask", "Mask that this sequence uses");
2377   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2378
2379   rna_def_filter_video(srna);
2380   rna_def_input(srna);
2381 }
2382
2383 static void rna_def_sound(BlenderRNA *brna)
2384 {
2385   StructRNA *srna;
2386   PropertyRNA *prop;
2387
2388   srna = RNA_def_struct(brna, "SoundSequence", "Sequence");
2389   RNA_def_struct_ui_text(srna,
2390                          "Sound Sequence",
2391                          "Sequence strip defining a sound to be played over a period of time");
2392   RNA_def_struct_sdna(srna, "Sequence");
2393
2394   prop = RNA_def_property(srna, "sound", PROP_POINTER, PROP_NONE);
2395   RNA_def_property_flag(prop, PROP_EDITABLE);
2396   RNA_def_property_struct_type(prop, "Sound");
2397   RNA_def_property_ui_text(prop, "Sound", "Sound data-block used by this sequence");
2398   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_sound_update");
2399
2400   prop = RNA_def_property(srna, "volume", PROP_FLOAT, PROP_NONE);
2401   RNA_def_property_float_sdna(prop, NULL, "volume");
2402   RNA_def_property_range(prop, 0.0f, 100.0f);
2403   RNA_def_property_ui_text(prop, "Volume", "Playback volume of the sound");
2404   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_SOUND);
2405   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_audio_update");
2406
2407   prop = RNA_def_property(srna, "pitch", PROP_FLOAT, PROP_NONE);
2408   RNA_def_property_float_sdna(prop, NULL, "pitch");
2409   RNA_def_property_range(prop, 0.1f, 10.0f);
2410   RNA_def_property_ui_text(prop, "Pitch", "Playback pitch of the sound");
2411   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_SOUND);
2412   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_audio_update");
2413
2414   prop = RNA_def_property(srna, "pan", PROP_FLOAT, PROP_NONE);
2415   RNA_def_property_float_sdna(prop, NULL, "pan");
2416   RNA_def_property_range(prop, -2.0f, 2.0f);
2417   RNA_def_property_ui_text(prop, "Pan", "Playback panning of the sound (only for Mono sources)");
2418   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_audio_update");
2419
2420   prop = RNA_def_property(srna, "show_waveform", PROP_BOOLEAN, PROP_NONE);
2421   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_AUDIO_DRAW_WAVEFORM);
2422   RNA_def_property_ui_text(
2423       prop, "Display Waveform", "Display the audio waveform inside the strip");
2424   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
2425
2426   rna_def_input(srna);
2427 }
2428
2429 static void rna_def_effect(BlenderRNA *brna)
2430 {
2431   StructRNA *srna;
2432
2433   srna = RNA_def_struct(brna, "EffectSequence", "Sequence");
2434   RNA_def_struct_ui_text(
2435       srna,
2436       "Effect Sequence",
2437       "Sequence strip applying an effect on the images created by other strips");
2438   RNA_def_struct_sdna(srna, "Sequence");
2439
2440   rna_def_filter_video(srna);
2441   rna_def_proxy(srna);
2442 }
2443
2444 static void rna_def_multicam(StructRNA *srna)
2445 {
2446   PropertyRNA *prop;
2447
2448   prop = RNA_def_property(srna, "multicam_source", PROP_INT, PROP_UNSIGNED);
2449   RNA_def_property_int_sdna(prop, NULL, "multicam_source");
2450   RNA_def_property_range(prop, 0, MAXSEQ - 1);
2451   RNA_def_property_ui_text(prop, "Multicam Source Channel", "");
2452   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2453
2454   rna_def_input(srna);
2455 }
2456
2457 static void rna_def_wipe(StructRNA *srna)
2458 {
2459   PropertyRNA *prop;
2460
2461   static const EnumPropertyItem wipe_type_items[] = {
2462       {0, "SINGLE", 0, "Single", ""},
2463       {1, "DOUBLE", 0, "Double", ""},
2464       /* not used yet {2, "BOX", 0, "Box", ""}, */
2465       /* not used yet {3, "CROSS", 0, "Cross", ""}, */
2466       {4, "IRIS", 0, "Iris", ""},
2467       {5, "CLOCK", 0, "Clock", ""},
2468       {0, NULL, 0, NULL, NULL},
2469   };
2470
2471   static const EnumPropertyItem wipe_direction_items[] = {
2472       {0, "OUT", 0, "Out", ""},
2473       {1, "IN", 0, "In", ""},
2474       {0, NULL, 0, NULL, NULL},
2475   };
2476
2477   RNA_def_struct_sdna_from(srna, "WipeVars", "effectdata");
2478
2479   prop = RNA_def_property(srna, "blur_width", PROP_FLOAT, PROP_FACTOR);
2480   RNA_def_property_float_sdna(prop, NULL, "edgeWidth");
2481   RNA_def_property_range(prop, 0.0f, 1.0f);
2482   RNA_def_property_ui_text(
2483       prop, "Blur Width", "Width of the blur edge, in percentage relative to the image size");
2484   RNA_def_property_update(
2485       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2486
2487   prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
2488   RNA_def_property_range(prop, DEG2RADF(-90.0f), DEG2RADF(90.0f));
2489   RNA_def_property_ui_text(prop, "Angle", "Edge angle");
2490   RNA_def_property_update(
2491       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2492
2493   prop = RNA_def_property(srna, "direction", PROP_ENUM, PROP_NONE);
2494   RNA_def_property_enum_sdna(prop, NULL, "forward");
2495   RNA_def_property_enum_items(prop, wipe_direction_items);
2496   RNA_def_property_ui_text(prop, "Direction", "Wipe direction");
2497   RNA_def_property_update(
2498       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2499
2500   prop = RNA_def_property(srna, "transition_type", PROP_ENUM, PROP_NONE);
2501   RNA_def_property_enum_sdna(prop, NULL, "wipetype");
2502   RNA_def_property_enum_items(prop, wipe_type_items);
2503   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_SEQUENCE);
2504   RNA_def_property_ui_text(prop, "Transition Type", "");
2505   RNA_def_property_update(
2506       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2507 }
2508
2509 static void rna_def_glow(StructRNA *srna)
2510 {
2511   PropertyRNA *prop;
2512
2513   RNA_def_struct_sdna_from(srna, "GlowVars", "effectdata");
2514
2515   prop = RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_FACTOR);
2516   RNA_def_property_float_sdna(prop, NULL, "fMini");
2517   RNA_def_property_range(prop, 0.0f, 1.0f);
2518   RNA_def_property_ui_text(prop, "Threshold", "Minimum intensity to trigger a glow");
2519   RNA_def_property_update(
2520       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2521
2522   prop = RNA_def_property(srna, "clamp", PROP_FLOAT, PROP_FACTOR);
2523   RNA_def_property_float_sdna(prop, NULL, "fClamp");
2524   RNA_def_property_range(prop, 0.0f, 1.0f);
2525   RNA_def_property_ui_text(prop, "Clamp", "Brightness limit of intensity");
2526   RNA_def_property_update(
2527       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2528
2529   prop = RNA_def_property(srna, "boost_factor", PROP_FLOAT, PROP_NONE);
2530   RNA_def_property_float_sdna(prop, NULL, "fBoost");
2531   RNA_def_property_range(prop, 0.0f, 10.0f);
2532   RNA_def_property_ui_text(prop, "Boost Factor", "Brightness multiplier");
2533   RNA_def_property_update(
2534       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2535
2536   prop = RNA_def_property(srna, "blur_radius", PROP_FLOAT, PROP_NONE);
2537   RNA_def_property_float_sdna(prop, NULL, "dDist");
2538   RNA_def_property_range(prop, 0.5f, 20.0f);
2539   RNA_def_property_ui_text(prop, "Blur Distance", "Radius of glow effect");
2540   RNA_def_property_update(
2541       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2542
2543   prop = RNA_def_property(srna, "quality", PROP_INT, PROP_NONE);
2544   RNA_def_property_int_sdna(prop, NULL, "dQuality");
2545   RNA_def_property_range(prop, 1, 5);
2546   RNA_def_property_ui_text(prop, "Quality", "Accuracy of the blur effect");
2547   RNA_def_property_update(
2548       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2549
2550   prop = RNA_def_property(srna, "use_only_boost", PROP_BOOLEAN, PROP_NONE);
2551   RNA_def_property_boolean_sdna(prop, NULL, "bNoComp", 0);
2552   RNA_def_property_ui_text(prop, "Only Boost", "Show the glow buffer only");
2553   RNA_def_property_update(
2554       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2555 }
2556
2557 static void rna_def_transform(StructRNA *srna)
2558 {
2559   PropertyRNA *prop;
2560
2561   static const EnumPropertyItem interpolation_items[] = {
2562       {0, "NONE", 0, "None", "No interpolation"},
2563       {1, "BILINEAR", 0, "Bilinear", "Bilinear interpolation"},
2564       {2, "BICUBIC", 0, "Bicubic", "Bicubic interpolation"},
2565       {0, NULL, 0, NULL, NULL},
2566   };
2567
2568   static const EnumPropertyItem translation_unit_items[] = {
2569       {0, "PIXELS", 0, "Pixels", ""},
2570       {1, "PERCENT", 0, "Percent", ""},
2571       {0, NULL, 0, NULL, NULL},
2572   };
2573
2574   RNA_def_struct_sdna_from(srna, "TransformVars", "effectdata");
2575
2576   prop = RNA_def_property(srna, "scale_start_x", PROP_FLOAT, PROP_UNSIGNED);
2577   RNA_def_property_float_sdna(prop, NULL, "ScalexIni");
2578   RNA_def_property_ui_text(prop, "Scale X", "Amount to scale the input in the X axis");
2579   RNA_def_property_ui_range(prop, 0, 10, 3, 6);
2580   RNA_def_property_update(
2581       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2582
2583   prop = RNA_def_property(srna, "scale_start_y", PROP_FLOAT, PROP_UNSIGNED);
2584   RNA_def_property_float_sdna(prop, NULL, "ScaleyIni");
2585   RNA_def_property_ui_text(prop, "Scale Y", "Amount to scale the input in the Y axis");
2586   RNA_def_property_ui_range(prop, 0, 10, 3, 6);
2587   RNA_def_property_update(
2588       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2589
2590   prop = RNA_def_property(srna, "use_uniform_scale", PROP_BOOLEAN, PROP_NONE);
2591   RNA_def_property_boolean_sdna(prop, NULL, "uniform_scale", 0);
2592   RNA_def_property_ui_text(prop, "Uniform Scale", "Scale uniformly, preserving aspect ratio");
2593   RNA_def_property_update(
2594       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2595
2596   prop = RNA_def_property(srna, "translate_start_x", PROP_FLOAT, PROP_NONE);
2597   RNA_def_property_float_sdna(prop, NULL, "xIni");
2598   RNA_def_property_ui_text(prop, "Translate X", "Amount to move the input on the X axis");
2599   RNA_def_property_ui_range(prop, -4000.0f, 4000.0f, 3, 6);
2600   RNA_def_property_update(
2601       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2602
2603   prop = RNA_def_property(srna, "translate_start_y", PROP_FLOAT, PROP_NONE);
2604   RNA_def_property_float_sdna(prop, NULL, "yIni");
2605   RNA_def_property_ui_text(prop, "Translate Y", "Amount to move the input on the Y axis");
2606   RNA_def_property_ui_range(prop, -4000.0f, 4000.0f, 3, 6);
2607   RNA_def_property_update(
2608       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2609
2610   prop = RNA_def_property(srna, "rotation_start", PROP_FLOAT, PROP_NONE);
2611   RNA_def_property_float_sdna(prop, NULL, "rotIni");
2612   RNA_def_property_ui_text(prop, "Rotation", "Degrees to rotate the input");
2613   RNA_def_property_update(
2614       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2615
2616   prop = RNA_def_property(srna, "translation_unit", PROP_ENUM, PROP_NONE);
2617   RNA_def_property_enum_sdna(prop, NULL, "percent");
2618   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); /* not meant to be animated */
2619   RNA_def_property_enum_items(prop, translation_unit_items);
2620   RNA_def_property_ui_text(prop, "Translation Unit", "Unit of measure to translate the input");
2621   RNA_def_property_update(
2622       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2623
2624   prop = RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
2625   RNA_def_property_enum_items(prop, interpolation_items);
2626   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); /* not meant to be animated */
2627   RNA_def_property_ui_text(
2628       prop, "Interpolation", "Method to determine how missing pixels are created");
2629   RNA_def_property_update(
2630       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2631 }
2632
2633 static void rna_def_solid_color(StructRNA *srna)
2634 {
2635   PropertyRNA *prop;
2636
2637   RNA_def_struct_sdna_from(srna, "SolidColorVars", "effectdata");
2638
2639   prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
2640   RNA_def_property_float_sdna(prop, NULL, "col");
2641   RNA_def_property_ui_text(prop, "Color", "Effect Strip color");
2642   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_raw_update");
2643 }
2644
2645 static void rna_def_speed_control(StructRNA *srna)
2646 {
2647   PropertyRNA *prop;
2648
2649   RNA_def_struct_sdna_from(srna, "SpeedControlVars", "effectdata");
2650
2651   prop = RNA_def_property(srna, "multiply_speed", PROP_FLOAT, PROP_UNSIGNED);
2652   RNA_def_property_float_sdna(prop, NULL, "globalSpeed");
2653   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); /* seq->facf0 is used to animate this */
2654   RNA_def_property_ui_text(
2655       prop, "Multiply Speed", "Multiply the resulting speed after the speed factor");
2656   RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, -1);
2657   RNA_def_property_update(
2658       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2659
2660   prop = RNA_def_property(srna, "use_as_speed", PROP_BOOLEAN, PROP_NONE);
2661   RNA_def_property_boolean_sdna(prop, NULL, "flags", SEQ_SPEED_INTEGRATE);
2662   RNA_def_property_ui_text(
2663       prop, "Use as Speed", "Interpret the value as speed instead of a frame number");
2664   RNA_def_property_update(
2665       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2666
2667   prop = RNA_def_property(srna, "use_scale_to_length", PROP_BOOLEAN, PROP_NONE);
2668   RNA_def_property_boolean_sdna(prop, NULL, "flags", SEQ_SPEED_COMPRESS_IPO_Y);
2669   RNA_def_property_ui_text(
2670       prop, "Scale to Length", "Scale values from 0.0 to 1.0 to target sequence length");
2671   RNA_def_property_update(
2672       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2673 }
2674
2675 static void rna_def_gaussian_blur(StructRNA *srna)
2676 {
2677   PropertyRNA *prop;
2678
2679   RNA_def_struct_sdna_from(srna, "GaussianBlurVars", "effectdata");
2680   prop = RNA_def_property(srna, "size_x", PROP_FLOAT, PROP_UNSIGNED);
2681   RNA_def_property_ui_text(prop, "Size X", "Size of the blur along X axis");
2682   RNA_def_property_ui_range(prop, 0.0f, FLT_MAX, 1, -1);
2683   RNA_def_property_update(
2684       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2685
2686   prop = RNA_def_property(srna, "size_y", PROP_FLOAT, PROP_UNSIGNED);
2687   RNA_def_property_ui_text(prop, "Size Y", "Size of the blur along Y axis");
2688   RNA_def_property_ui_range(prop, 0.0f, FLT_MAX, 1, -1);
2689   RNA_def_property_update(
2690       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2691 }
2692
2693 static void rna_def_text(StructRNA *srna)
2694 {
2695   static const EnumPropertyItem text_align_x_items[] = {
2696       {SEQ_TEXT_ALIGN_X_LEFT, "LEFT", ICON_ALIGN_LEFT, "Left", ""},
2697       {SEQ_TEXT_ALIGN_X_CENTER, "CENTER", ICON_ALIGN_CENTER, "Center", ""},
2698       {SEQ_TEXT_ALIGN_X_RIGHT, "RIGHT", ICON_ALIGN_RIGHT, "Right", ""},
2699       {0, NULL, 0, NULL, NULL},
2700   };
2701   static const EnumPropertyItem text_align_y_items[] = {
2702       {SEQ_TEXT_ALIGN_Y_TOP, "TOP", ICON_ALIGN_TOP, "Top", ""},
2703       {SEQ_TEXT_ALIGN_Y_CENTER, "CENTER", ICON_ALIGN_MIDDLE, "Center", ""},
2704       {SEQ_TEXT_ALIGN_Y_BOTTOM, "BOTTOM", ICON_ALIGN_BOTTOM, "Bottom", ""},
2705       {0, NULL, 0, NULL, NULL},
2706   };
2707
2708   PropertyRNA *prop;
2709
2710   RNA_def_struct_sdna_from(srna, "TextVars", "effectdata");
2711
2712   prop = RNA_def_property(srna, "font", PROP_POINTER, PROP_NONE);
2713   RNA_def_property_pointer_sdna(prop, NULL, "text_font");
2714   RNA_def_property_ui_icon(prop, ICON_FILE_FONT, false);
2715   RNA_def_property_ui_text(prop, "Font", "Font of the text. Falls back to the UI font by default");
2716   RNA_def_property_flag(prop, PROP_EDITABLE);
2717   RNA_def_property_pointer_funcs(prop, NULL, "rna_Sequence_text_font_set", NULL, NULL);
2718   RNA_def_property_update(
2719       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2720
2721   prop = RNA_def_property(srna, "font_size", PROP_INT, PROP_UNSIGNED);
2722   RNA_def_property_int_sdna(prop, NULL, "text_size");
2723   RNA_def_property_ui_text(prop, "Size", "Size of the text");
2724   RNA_def_property_range(prop, 0.0, 2000);
2725   RNA_def_property_ui_range(prop, 0.0f, 1000, 1, -1);
2726   RNA_def_property_update(
2727       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2728
2729   prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
2730   RNA_def_property_float_sdna(prop, NULL, "color");
2731   RNA_def_property_ui_text(prop, "Color", "Text color");
2732   RNA_def_property_update(
2733       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2734
2735   prop = RNA_def_property(srna, "shadow_color", PROP_FLOAT, PROP_COLOR_GAMMA);
2736   RNA_def_property_float_sdna(prop, NULL, "shadow_color");
2737   RNA_def_property_ui_text(prop, "Shadow Color", "");
2738   RNA_def_property_update(
2739       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2740
2741   prop = RNA_def_property(srna, "location", PROP_FLOAT, PROP_XYZ);
2742   RNA_def_property_float_sdna(prop, NULL, "loc");
2743   RNA_def_property_ui_text(prop, "Location", "Location of the text");
2744   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
2745   RNA_def_property_ui_range(prop, 0.0, 1.0, 1, -1);
2746   RNA_def_property_update(
2747       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2748
2749   prop = RNA_def_property(srna, "wrap_width", PROP_FLOAT, PROP_NONE);
2750   RNA_def_property_float_sdna(prop, NULL, "wrap_width");
2751   RNA_def_property_ui_text(prop, "Wrap Width", "Word wrap width as factor, zero disables");
2752   RNA_def_property_range(prop, 0, FLT_MAX);
2753   RNA_def_property_ui_range(prop, 0.0, 1.0, 1, -1);
2754   RNA_def_property_update(
2755       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2756
2757   prop = RNA_def_property(srna, "align_x", PROP_ENUM, PROP_NONE);
2758   RNA_def_property_enum_sdna(prop, NULL, "align");
2759   RNA_def_property_enum_items(prop, text_align_x_items);
2760   RNA_def_property_ui_text(
2761       prop, "Align X", "Align the text along the X axis, relative to the text midpoint");
2762   RNA_def_property_update(
2763       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2764
2765   prop = RNA_def_property(srna, "align_y", PROP_ENUM, PROP_NONE);
2766   RNA_def_property_enum_sdna(prop, NULL, "align_y");
2767   RNA_def_property_enum_items(prop, text_align_y_items);
2768   RNA_def_property_ui_text(
2769       prop, "Align Y", "Align the image along the Y axis, relative to the text midpoint");
2770   RNA_def_property_update(
2771       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2772
2773   prop = RNA_def_property(srna, "text", PROP_STRING, PROP_NONE);
2774   RNA_def_property_ui_text(prop, "Text", "Text that will be displayed");
2775   RNA_def_property_update(
2776       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2777
2778   prop = RNA_def_property(srna, "use_shadow", PROP_BOOLEAN, PROP_NONE);
2779   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_TEXT_SHADOW);
2780   RNA_def_property_ui_text(prop, "Shadow", "Display shadow behind text");
2781   RNA_def_property_update(
2782       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2783 }
2784
2785 static void rna_def_color_mix(StructRNA *srna)
2786 {
2787   static EnumPropertyItem blend_color_items[] = {
2788       {SEQ_TYPE_ADD, "ADD", 0, "Add", ""},
2789       {SEQ_TYPE_SUB, "SUBTRACT", 0, "Subtract", ""},
2790       {SEQ_TYPE_MUL, "MULTIPLY", 0, "Multiply", ""},
2791       {SEQ_TYPE_LIGHTEN, "LIGHTEN", 0, "Lighten", ""},
2792       {SEQ_TYPE_DARKEN, "DARKEN", 0, "Darken", ""},
2793       {SEQ_TYPE_SCREEN, "SCREEN", 0, "Screen", ""},
2794       {SEQ_TYPE_OVERLAY, "OVERLAY", 0, "Overlay", ""},
2795       {SEQ_TYPE_DODGE, "DODGE", 0, "Dodge", ""},
2796       {SEQ_TYPE_COLOR_BURN, "BURN", 0, "Color Burn", ""},
2797       {SEQ_TYPE_LINEAR_BURN, "LINEAR_BURN", 0, "Linear Burn", ""},
2798       {SEQ_TYPE_SOFT_LIGHT, "SOFT_LIGHT", 0, "Soft Light", ""},
2799       {SEQ_TYPE_HARD_LIGHT, "HARD_LIGHT", 0, "Hard Light", ""},
2800       {SEQ_TYPE_PIN_LIGHT, "PIN_LIGHT", 0, "Pin Light", ""},
2801       {SEQ_TYPE_LIN_LIGHT, "LINEAR_LIGHT", 0, "Linear Light", ""},
2802       {SEQ_TYPE_VIVID_LIGHT, "VIVID_LIGHT", 0, "Vivid Light", ""},
2803       {SEQ_TYPE_BLEND_COLOR, "COLOR", 0, "Color", ""},
2804       {SEQ_TYPE_HUE, "HUE", 0, "Hue", ""},
2805       {SEQ_TYPE_SATURATION, "SATURATION", 0, "Saturation", ""},
2806       {SEQ_TYPE_VALUE, "VALUE", 0, "Value", ""},
2807       {SEQ_TYPE_DIFFERENCE, "DIFFERENCE", 0, "Difference", ""},
2808       {SEQ_TYPE_EXCLUSION, "EXCLUSION", 0, "Exclusion", ""},
2809       {0, NULL, 0, NULL, NULL},
2810   };
2811
2812   PropertyRNA *prop;
2813
2814   RNA_def_struct_sdna_from(srna, "ColorMixVars", "effectdata");
2815
2816   prop = RNA_def_property(srna, "blend_effect", PROP_ENUM, PROP_NONE);
2817   RNA_def_property_enum_sdna(prop, NULL, "blend_effect");
2818   RNA_def_property_enum_items(prop, blend_color_items);
2819   RNA_def_property_ui_text(
2820       prop, "Blend Effect", "Method for controlling how the strip combines with other strips");
2821   RNA_def_property_update(
2822       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2823
2824   prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_FACTOR);
2825   RNA_def_property_range(prop, 0.0f, 1.0f);
2826   RNA_def_property_ui_text(
2827       prop, "Blend Factor", "Percentage of how much the strip's colors affect other strips");
2828   RNA_def_property_update(
2829       prop, NC_SCENE | ND_SEQUENCER, "rna_Sequence_invalidate_preprocessed_update");
2830 }
2831
2832 static EffectInfo def_effects[] = {
2833     {"AddSequence", "Add Sequence", "Add Sequence", NULL, 2},
2834     {"AdjustmentSequence",
2835      "Adjustment Layer Sequence",
2836      "Sequence strip to perform filter adjustments to layers below",
2837      rna_def_input,
2838      0},
2839     {"AlphaOverSequence", "Alpha Over Sequence", "Alpha Over Sequence", NULL, 2},
2840     {"AlphaUnderSequence", "Alpha Under Sequence", "Alpha Under Sequence", NULL, 2},
2841     {"ColorSequence",
2842      "Color Sequence",
2843      "Sequence strip creating an image filled with a single color",
2844      rna_def_solid_color,
2845      0},
2846     {"CrossSequence", "Cross Sequence", "Cross Sequence", NULL, 2},
2847     {"GammaCrossSequence", "Gamma Cross Sequence", "Gamma Cross Sequence", NULL, 2},
2848     {"GlowSequence", "Glow Sequence", "Sequence strip creating a glow effect", rna_def_glow, 1},
2849     {"MulticamSequence",
2850      "Multicam Select Sequence",
2851      "Sequence strip to perform multicam editing",
2852      rna_def_multicam,
2853      0},
2854     {"MultiplySequence", "Multiply Sequence", "Multiply Sequence", NULL, 2},
2855     {"OverDropSequence", "Over Drop Sequence", "Over Drop Sequence", NULL, 2},
2856     {"SpeedControlSequence",
2857      "SpeedControl Sequence",
2858      "Sequence strip to control the speed of other strips",
2859      rna_def_speed_control,
2860      1},
2861     {"SubtractSequence", "Subtract Sequence", "Subtract Sequence", NULL, 2},
2862     {"TransformSequence",
2863      "Transform Sequence",
2864      "Sequence strip applying affine transformations to other strips",
2865      rna_def_transform,
2866      1},
2867     {"WipeSequence",
2868      "Wipe Sequence",
2869      "Sequence strip creating a wipe transition",
2870      rna_def_wipe,
2871      2},
2872     {"GaussianBlurSequence",
2873      "Gaussian Blur Sequence",
2874      "Sequence strip creating a gaussian blur",
2875      rna_def_gaussian_blur,
2876      1},
2877     {"TextSequence", "Text Sequence", "Sequence strip creating text", rna_def_text, 0},
2878     {"ColorMixSequence", "Color Mix Sequence", "Color Mix Sequence", rna_def_color_mix, 2},
2879     {"", "", "", NULL, 0},
2880 };
2881
2882 static void rna_def_effects(BlenderRNA *brna)
2883 {
2884   StructRNA *srna;
2885   EffectInfo *effect;
2886
2887   for (effect = def_effects; effect->struct_name[0] != '\0'; effect++) {
2888     srna = RNA_def_struct(brna, effect->struct_name, "EffectSequence");
2889     RNA_def_struct_ui_text(srna, effect->ui_name, effect->ui_desc);
2890     RNA_def_struct_sdna(srna, "Sequence");
2891
2892     rna_def_effect_inputs(srna, effect->inputs);
2893
2894     if (effect->func) {
2895       effect->func(srna);
2896     }
2897   }
2898 }
2899
2900 static void rna_def_modifier(BlenderRNA *brna)
2901 {
2902   StructRNA *srna;
2903   PropertyRNA *prop;
2904
2905   static const EnumPropertyItem mask_input_type_items[] = {
2906       {SEQUENCE_MASK_INPUT_STRIP, "STRIP", 0, "Strip", "Use sequencer strip as mask input"},
2907       {SEQUENCE_MASK_INPUT_ID, "ID", 0, "Mask", "Use mask ID as mask input"},
2908       {0, NULL, 0, NULL, NULL},
2909   };
2910
2911   static const EnumPropertyItem mask_time_items[] = {
2912       {SEQUENCE_MASK_TIME_RELATIVE,
2913        "RELATIVE",
2914        0,
2915        "Relative",
2916        "Mask animation is offset to start of strip"},
2917       {SEQUENCE_MASK_TIME_ABSOLUTE,
2918        "ABSOLUTE",
2919        0,
2920        "Absolute",
2921        "Mask animation is in sync with scene frame"},
2922       {0, NULL, 0, NULL, NULL},
2923   };
2924
2925   srna = RNA_def_struct(brna, "SequenceModifier", NULL);
2926   RNA_def_struct_sdna(srna, "SequenceModifierData");
2927   RNA_def_struct_ui_text(srna, "SequenceModifier", "Modifier for sequence strip");
2928   RNA_def_struct_refine_func(srna, "rna_SequenceModifier_refine");
2929   RNA_def_struct_path_func(srna, "rna_SequenceModifier_path");
2930
2931   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
2932   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_SequenceModifier_name_set");
2933   RNA_def_property_ui_text(prop, "Name", "");
2934   RNA_def_struct_name_property(srna, prop);
2935   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
2936
2937   prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
2938   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2939   RNA_def_property_enum_items(prop, rna_enum_sequence_modifier_type_items);
2940   RNA_def_property_ui_text(prop, "Type", "");
2941   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
2942
2943   prop = RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
2944   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQUENCE_MODIFIER_MUTE);
2945   RNA_def_property_ui_text(prop, "Mute", "Mute this modifier");
2946   RNA_def_property_ui_icon(prop, ICON_HIDE_OFF, -1);
2947   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
2948
2949   prop = RNA_def_property(srna, "show_expanded", PROP_BOOLEAN, PROP_NONE);
2950   RNA_def_property_flag(prop, PROP_NO_DEG_UPDATE);
2951   RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQUENCE_MODIFIER_EXPANDED);
2952   RNA_def_property_ui_text(prop, "Expanded", "Mute expanded settings for the modifier");
2953   RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
2954   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, NULL);
2955
2956   prop = RNA_def_property(srna, "input_mask_type", PROP_ENUM, PROP_NONE);
2957   RNA_def_property_enum_sdna(prop, NULL, "mask_input_type");
2958   RNA_def_property_enum_items(prop, mask_input_type_items);
2959   RNA_def_property_ui_text(prop, "Mask Input Type", "Type of input data used for mask");
2960   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
2961
2962   prop = RNA_def_property(srna, "mask_time", PROP_ENUM, PROP_NONE);
2963   RNA_def_property_enum_sdna(prop, NULL, "mask_time");
2964   RNA_def_property_enum_items(prop, mask_time_items);
2965   RNA_def_property_ui_text(prop, "Mask Time", "Time to use for the Mask animation");
2966   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
2967
2968   prop = RNA_def_property(srna, "input_mask_strip", PROP_POINTER, PROP_NONE);
2969   RNA_def_property_pointer_sdna(prop, NULL, "mask_sequence");
2970   RNA_def_property_pointer_funcs(
2971       prop, NULL, NULL, NULL, "rna_SequenceModifier_otherSequence_poll");
2972   RNA_def_property_flag(prop, PROP_EDITABLE);
2973   RNA_def_property_ui_text(prop, "Mask Strip", "Strip used as mask input for the modifier");
2974   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
2975
2976   prop = RNA_def_property(srna, "input_mask_id", PROP_POINTER, PROP_NONE);
2977   RNA_def_property_pointer_sdna(prop, NULL, "mask_id");
2978   RNA_def_property_flag(prop, PROP_EDITABLE);
2979   RNA_def_property_ui_text(prop, "Mask", "Mask ID used as mask input for the modifier");
2980   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
2981 }
2982
2983 static void rna_def_colorbalance_modifier(BlenderRNA *brna)
2984 {
2985   StructRNA *srna;
2986   PropertyRNA *prop;
2987
2988   srna = RNA_def_struct(brna, "ColorBalanceModifier", "SequenceModifier");
2989   RNA_def_struct_sdna(srna, "ColorBalanceModifierData");
2990   RNA_def_struct_ui_text(
2991       srna, "ColorBalanceModifier", "Color balance modifier for sequence strip");
2992
2993   prop = RNA_def_property(srna, "color_balance", PROP_POINTER, PROP_NONE);
2994   RNA_def_property_struct_type(prop, "SequenceColorBalanceData");
2995
2996   prop = RNA_def_property(srna, "color_multiply", PROP_FLOAT, PROP_UNSIGNED);
2997   RNA_def_property_float_sdna(prop, NULL, "color_multiply");
2998   RNA_def_property_range(prop, 0.0f, 20.0f);
2999   RNA_def_property_float_default(prop, 1.0f);
3000   RNA_def_property_ui_text(prop, "Multiply Colors", "Multiply the intensity of each pixel");
3001   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3002 }
3003
3004 static void rna_def_whitebalance_modifier(BlenderRNA *brna)
3005 {
3006   StructRNA *srna;
3007   PropertyRNA *prop;
3008
3009   srna = RNA_def_struct(brna, "WhiteBalanceModifier", "SequenceModifier");
3010   RNA_def_struct_sdna(srna, "WhiteBalanceModifierData");
3011   RNA_def_struct_ui_text(
3012       srna, "WhiteBalanceModifier", "White balance modifier for sequence strip");
3013
3014   prop = RNA_def_property(srna, "white_value", PROP_FLOAT, PROP_COLOR_GAMMA);
3015   RNA_def_property_range(prop, 0.0, 1.0);
3016   RNA_def_property_float_sdna(prop, NULL, "white_value");
3017   RNA_def_property_ui_text(prop, "White Value", "This color defines white in the strip");
3018   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3019 }
3020
3021 static void rna_def_curves_modifier(BlenderRNA *brna)
3022 {
3023   StructRNA *srna;
3024   PropertyRNA *prop;
3025
3026   srna = RNA_def_struct(brna, "CurvesModifier", "SequenceModifier");
3027   RNA_def_struct_sdna(srna, "CurvesModifierData");
3028   RNA_def_struct_ui_text(srna, "CurvesModifier", "RGB curves modifier for sequence strip");
3029
3030   prop = RNA_def_property(srna, "curve_mapping", PROP_POINTER, PROP_NONE);
3031   RNA_def_property_pointer_sdna(prop, NULL, "curve_mapping");
3032   RNA_def_property_struct_type(prop, "CurveMapping");
3033   RNA_def_property_ui_text(prop, "Curve Mapping", "");
3034   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3035 }
3036
3037 static void rna_def_hue_modifier(BlenderRNA *brna)
3038 {
3039   StructRNA *srna;
3040   PropertyRNA *prop;
3041
3042   srna = RNA_def_struct(brna, "HueCorrectModifier", "SequenceModifier");
3043   RNA_def_struct_sdna(srna, "HueCorrectModifierData");
3044   RNA_def_struct_ui_text(srna, "HueCorrectModifier", "Hue correction modifier for sequence strip");
3045
3046   prop = RNA_def_property(srna, "curve_mapping", PROP_POINTER, PROP_NONE);
3047   RNA_def_property_pointer_sdna(prop, NULL, "curve_mapping");
3048   RNA_def_property_struct_type(prop, "CurveMapping");
3049   RNA_def_property_ui_text(prop, "Curve Mapping", "");
3050   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3051 }
3052
3053 static void rna_def_brightcontrast_modifier(BlenderRNA *brna)
3054 {
3055   StructRNA *srna;
3056   PropertyRNA *prop;
3057
3058   srna = RNA_def_struct(brna, "BrightContrastModifier", "SequenceModifier");
3059   RNA_def_struct_sdna(srna, "BrightContrastModifierData");
3060   RNA_def_struct_ui_text(
3061       srna, "BrightContrastModifier", "Bright/contrast modifier data for sequence strip");
3062
3063   prop = RNA_def_property(srna, "bright", PROP_FLOAT, PROP_UNSIGNED);
3064   RNA_def_property_float_sdna(prop, NULL, "bright");
3065   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
3066   RNA_def_property_ui_text(prop, "Bright", "Adjust the luminosity of the colors");
3067   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3068
3069   prop = RNA_def_property(srna, "contrast", PROP_FLOAT, PROP_UNSIGNED);
3070   RNA_def_property_float_sdna(prop, NULL, "contrast");
3071   RNA_def_property_range(prop, -100.0f, 100.0f);
3072   RNA_def_property_ui_text(prop, "Contrast", "Adjust the difference in luminosity between pixels");
3073   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3074 }
3075
3076 static void rna_def_tonemap_modifier(BlenderRNA *brna)
3077 {
3078   StructRNA *srna;
3079   PropertyRNA *prop;
3080
3081   static const EnumPropertyItem type_items[] = {
3082       {SEQ_TONEMAP_RD_PHOTORECEPTOR, "RD_PHOTORECEPTOR", 0, "R/D Photoreceptor", ""},
3083       {SEQ_TONEMAP_RH_SIMPLE, "RH_SIMPLE", 0, "Rh Simple", ""},
3084       {0, NULL, 0, NULL, NULL},
3085   };
3086
3087   srna = RNA_def_struct(brna, "SequencerTonemapModifierData", "SequenceModifier");
3088   RNA_def_struct_sdna(srna, "SequencerTonemapModifierData");
3089   RNA_def_struct_ui_text(srna, "SequencerTonemapModifierData", "Tone mapping modifier");
3090
3091   prop = RNA_def_property(srna, "tonemap_type", PROP_ENUM, PROP_NONE);
3092   RNA_def_property_enum_sdna(prop, NULL, "type");
3093   RNA_def_property_enum_items(prop, type_items);
3094   RNA_def_property_ui_text(prop, "Tonemap Type", "Tone mapping algorithm");
3095   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3096
3097   prop = RNA_def_property(srna, "key", PROP_FLOAT, PROP_FACTOR);
3098   RNA_def_property_range(prop, 0.0f, 1.0f);
3099   RNA_def_property_ui_text(prop, "Key", "The value the average luminance is mapped to");
3100   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3101
3102   prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
3103   RNA_def_property_range(prop, 0.001f, 10.0f);
3104   RNA_def_property_ui_text(
3105       prop,
3106       "Offset",
3107       "Normally always 1, but can be used as an extra control to alter the brightness curve");
3108   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3109
3110   prop = RNA_def_property(srna, "gamma", PROP_FLOAT, PROP_NONE);
3111   RNA_def_property_range(prop, 0.001f, 3.0f);
3112   RNA_def_property_ui_text(prop, "Gamma", "If not used, set to 1");
3113   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3114
3115   prop = RNA_def_property(srna, "intensity", PROP_FLOAT, PROP_NONE);
3116   RNA_def_property_range(prop, -8.0f, 8.0f);
3117   RNA_def_property_ui_text(
3118       prop, "Intensity", "If less than zero, darkens image; otherwise, makes it brighter");
3119   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3120
3121   prop = RNA_def_property(srna, "contrast", PROP_FLOAT, PROP_FACTOR);
3122   RNA_def_property_range(prop, 0.0f, 1.0f);
3123   RNA_def_property_ui_text(prop, "Contrast", "Set to 0 to use estimate from input image");
3124   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3125
3126   prop = RNA_def_property(srna, "adaptation", PROP_FLOAT, PROP_FACTOR);
3127   RNA_def_property_range(prop, 0.0f, 1.0f);
3128   RNA_def_property_ui_text(prop, "Adaptation", "If 0, global; if 1, based on pixel intensity");
3129   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3130
3131   prop = RNA_def_property(srna, "correction", PROP_FLOAT, PROP_FACTOR);
3132   RNA_def_property_range(prop, 0.0f, 1.0f);
3133   RNA_def_property_ui_text(
3134       prop, "Color Correction", "If 0, same for all channels; if 1, each independent");
3135   RNA_def_property_update(prop, NC_SCENE | ND_SEQUENCER, "rna_SequenceModifier_update");
3136 }
3137
3138 static void rna_def_modifiers(BlenderRNA *brna)
3139 {
3140   rna_def_modifier(brna);
3141
3142   rna_def_colorbalance_modifier(brna);
3143   rna_def_curves_modifier(brna);
3144   rna_def_hue_modifier(brna);
3145   rna_def_brightcontrast_modifier(brna);
3146   rna_def_whitebalance_modifier(brna);
3147   rna_def_tonemap_modifier(brna);
3148 }
3149
3150 void RNA_def_sequencer(BlenderRNA *brna)
3151 {
3152   rna_def_color_balance(brna);
3153
3154   rna_def_strip_element(brna);
3155   rna_def_strip_proxy(brna);
3156   rna_def_strip_color_balance(brna);
3157   rna_def_strip_crop(brna);
3158   rna_def_strip_transform(brna);
3159
3160   rna_def_sequence(brna);
3161   rna_def_editor(brna);
3162
3163   rna_def_image(brna);
3164   rna_def_meta(brna);
3165   rna_def_scene(brna);
3166   rna_def_movie(brna);
3167   rna_def_movieclip(brna);
3168   rna_def_mask(brna);
3169   rna_def_sound(brna);
3170   rna_def_effect(brna);
3171   rna_def_effects(brna);
3172   rna_def_modifiers(brna);
3173 }
3174
3175 #endif