- saturation option for sequencer strips, runs before multiply and color balance.
[blender.git] / source / blender / makesrna / intern / rna_sequencer.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * Contributor(s): Blender Foundation (2008)
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 #include <stdlib.h>
26 #include <limits.h>
27
28 #include "RNA_access.h"
29 #include "RNA_define.h"
30
31 #include "rna_internal.h"
32
33 #include "DNA_anim_types.h"
34 #include "DNA_object_types.h"
35 #include "DNA_scene_types.h"
36 #include "DNA_sequence_types.h"
37
38 #include "BKE_animsys.h"
39 #include "BKE_sequencer.h"
40
41 #include "MEM_guardedalloc.h"
42
43 #include "WM_types.h"
44 #include "BLI_math.h"
45
46 #ifdef RNA_RUNTIME
47
48 static float to_dB(float x)
49 {
50         return logf(x * x + 1e-30f) * 4.34294480f;
51 }
52
53 static float from_dB(float x)
54 {
55         return expf(x * 0.11512925f);
56 }
57
58 /* build a temp referene to the parent */
59 static void meta_tmp_ref(Sequence *seq_par, Sequence *seq)
60 {
61         for (; seq; seq= seq->next) {
62                 seq->tmp= seq_par;
63                 if(seq->type == SEQ_META) {
64                         meta_tmp_ref(seq, seq->seqbase.first);
65                 }
66         }
67 }
68
69 static void rna_SequenceEditor_sequences_all_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
70 {
71         Scene *scene= (Scene*)ptr->id.data;
72         Editing *ed= seq_give_editing(scene, FALSE);
73
74         meta_tmp_ref(NULL, ed->seqbase.first);
75
76         rna_iterator_listbase_begin(iter, &ed->seqbase, NULL);
77 }
78
79 static void rna_SequenceEditor_sequences_all_next(CollectionPropertyIterator *iter)
80 {
81         ListBaseIterator *internal= iter->internal;
82         Sequence *seq= (Sequence*)internal->link;
83
84         if(seq->seqbase.first)
85                 internal->link= (Link*)seq->seqbase.first;
86         else if(seq->next)
87                 internal->link= (Link*)seq->next;
88         else {
89                 internal->link= NULL;
90
91                 do {
92                         seq= seq->tmp; // XXX - seq's dont reference their parents!
93                         if(seq && seq->next) {
94                                 internal->link= (Link*)seq->next;
95                                 break;
96                         }
97                 } while(seq);
98         }
99
100         iter->valid= (internal->link != NULL);
101 }
102
103 /* internal use */
104 static void rna_Sequence_frame_change_update(Scene *scene, Sequence *seq)
105 {
106         Editing *ed= seq_give_editing(scene, FALSE);
107         ListBase *seqbase= seq_seqbase(&ed->seqbase, seq);
108         calc_sequence_disp(scene, seq);
109
110         if(seq_test_overlap(seqbase, seq)) {
111                 shuffle_seq(seqbase, seq, scene); // XXX - BROKEN!, uses context seqbasep
112         }
113         sort_seq(scene);
114 }
115
116 static void rna_Sequence_start_frame_set(PointerRNA *ptr, int value)
117 {
118         Sequence *seq= (Sequence*)ptr->data;
119         Scene *scene= (Scene*)ptr->id.data;
120         
121         seq->start= value;
122         rna_Sequence_frame_change_update(scene, seq);
123 }
124
125 static void rna_Sequence_start_frame_final_set(PointerRNA *ptr, int value)
126 {
127         Sequence *seq= (Sequence*)ptr->data;
128         Scene *scene= (Scene*)ptr->id.data;
129
130         seq_tx_set_final_left(seq, value);
131         seq_single_fix(seq);
132         rna_Sequence_frame_change_update(scene, seq);
133 }
134
135 static void rna_Sequence_end_frame_final_set(PointerRNA *ptr, int value)
136 {
137         Sequence *seq= (Sequence*)ptr->data;
138         Scene *scene= (Scene*)ptr->id.data;
139
140         seq_tx_set_final_right(seq, value);
141         seq_single_fix(seq);
142         rna_Sequence_frame_change_update(scene, seq);
143 }
144
145 static void rna_Sequence_anim_startofs_final_set(PointerRNA *ptr, int value)
146 {
147         Sequence *seq= (Sequence*)ptr->data;
148         Scene *scene= (Scene*)ptr->id.data;
149
150         seq->anim_startofs = MIN2(value, seq->len + seq->anim_startofs);
151
152         reload_sequence_new_file(scene, seq, FALSE);
153         rna_Sequence_frame_change_update(scene, seq);
154 }
155
156 static void rna_Sequence_anim_endofs_final_set(PointerRNA *ptr, int value)
157 {
158         Sequence *seq= (Sequence*)ptr->data;
159         Scene *scene= (Scene*)ptr->id.data;
160
161         seq->anim_endofs = MIN2(value, seq->len + seq->anim_endofs);
162
163         reload_sequence_new_file(scene, seq, FALSE);
164         rna_Sequence_frame_change_update(scene, seq);
165 }
166
167 static void rna_Sequence_frame_length_set(PointerRNA *ptr, int value)
168 {
169         Sequence *seq= (Sequence*)ptr->data;
170         Scene *scene= (Scene*)ptr->id.data;
171         
172         seq_tx_set_final_right(seq, seq->start+value);
173         rna_Sequence_frame_change_update(scene, seq);
174 }
175
176 static int rna_Sequence_frame_length_get(PointerRNA *ptr)
177 {
178         Sequence *seq= (Sequence*)ptr->data;
179         return seq_tx_get_final_right(seq, 0)-seq_tx_get_final_left(seq, 0);
180 }
181
182 static void rna_Sequence_channel_set(PointerRNA *ptr, int value)
183 {
184         Sequence *seq= (Sequence*)ptr->data;
185         Scene *scene= (Scene*)ptr->id.data;
186         Editing *ed= seq_give_editing(scene, FALSE);
187         ListBase *seqbase= seq_seqbase(&ed->seqbase, seq);
188
189         seq->machine= value;
190         
191         if( seq_test_overlap(seqbase, seq) ) {
192                 shuffle_seq(seqbase, seq, scene);  // XXX - BROKEN!, uses context seqbasep
193         }
194         sort_seq(scene);
195 }
196
197 /* properties that need to allocate structs */
198 static void rna_Sequence_use_color_balance_set(PointerRNA *ptr, int value)
199 {
200         Sequence *seq= (Sequence*)ptr->data;
201         int c;
202         
203         if(value) {
204                 seq->flag |= SEQ_USE_COLOR_BALANCE;
205                 if(seq->strip->color_balance == NULL) {
206                         seq->strip->color_balance = MEM_callocN(sizeof(struct StripColorBalance), "StripColorBalance");
207                         for (c=0; c<3; c++) {
208                                 seq->strip->color_balance->lift[c] = 1.0f;
209                                 seq->strip->color_balance->gamma[c] = 1.0f;
210                                 seq->strip->color_balance->gain[c] = 1.0f;
211                         }
212                 }
213         } else {
214                 seq->flag ^= SEQ_USE_COLOR_BALANCE;
215         }
216 }
217
218 static void rna_Sequence_use_proxy_set(PointerRNA *ptr, int value)
219 {
220         Sequence *seq= (Sequence*)ptr->data;
221         if(value) {
222                 seq->flag |= SEQ_USE_PROXY;
223                 if(seq->strip->proxy == NULL) {
224                         seq->strip->proxy = MEM_callocN(sizeof(struct StripProxy), "StripProxy");
225                 }
226         } else {
227                 seq->flag ^= SEQ_USE_PROXY;
228         }
229 }
230
231 static void rna_Sequence_use_translation_set(PointerRNA *ptr, int value)
232 {
233         Sequence *seq= (Sequence*)ptr->data;
234         if(value) {
235                 seq->flag |= SEQ_USE_TRANSFORM;
236                 if(seq->strip->transform == NULL) {
237                         seq->strip->transform = MEM_callocN(sizeof(struct StripTransform), "StripTransform");
238                 }
239         } else {
240                 seq->flag ^= SEQ_USE_TRANSFORM;
241         }
242 }
243
244 static void rna_Sequence_use_crop_set(PointerRNA *ptr, int value)
245 {
246         Sequence *seq= (Sequence*)ptr->data;
247         if(value) {
248                 seq->flag |= SEQ_USE_CROP;
249                 if(seq->strip->crop == NULL) {
250                         seq->strip->crop = MEM_callocN(sizeof(struct StripCrop), "StripCrop");
251                 }
252         } else {
253                 seq->flag ^= SEQ_USE_CROP;
254         }
255 }
256 /* name functions that ignore the first two characters */
257 static void rna_Sequence_name_get(PointerRNA *ptr, char *value)
258 {
259         Sequence *seq= (Sequence*)ptr->data;
260         BLI_strncpy(value, seq->name+2, sizeof(seq->name)-2);
261 }
262
263 static int rna_Sequence_name_length(PointerRNA *ptr)
264 {
265         Sequence *seq= (Sequence*)ptr->data;
266         return strlen(seq->name+2);
267 }
268
269 static void rna_Sequence_name_set(PointerRNA *ptr, const char *value)
270 {
271         Scene *scene= (Scene*)ptr->id.data;
272         Sequence *seq= (Sequence*)ptr->data;
273         char oldname[sizeof(seq->name)];
274         AnimData *adt;
275         
276         /* make a copy of the old name first */
277         BLI_strncpy(oldname, seq->name+2, sizeof(seq->name)-2);
278         
279         /* copy the new name into the name slot */
280         BLI_strncpy(seq->name+2, value, sizeof(seq->name)-2);
281         
282         /* make sure the name is unique */
283         seqbase_unique_name_recursive(&scene->ed->seqbase, seq);
284         
285         /* fix all the animation data which may link to this */
286
287         /* dont rename everywhere because these are per scene */
288         /* BKE_all_animdata_fix_paths_rename("sequence_editor.sequences_all", oldname, seq->name+2); */
289         adt= BKE_animdata_from_id(&scene->id);
290         if(adt)
291                 BKE_animdata_fix_paths_rename(&scene->id, adt, "sequence_editor.sequences_all", oldname, seq->name+2, 0, 0, 1);
292 }
293
294 static StructRNA* rna_Sequence_refine(struct PointerRNA *ptr)
295 {
296         Sequence *seq= (Sequence*)ptr->data;
297
298         switch(seq->type) {
299                 case SEQ_IMAGE:
300                         return &RNA_ImageSequence;
301                 case SEQ_META:
302                         return &RNA_MetaSequence;
303                 case SEQ_SCENE:
304                         return &RNA_SceneSequence;
305                 case SEQ_MOVIE:
306                         return &RNA_MovieSequence;
307                 case SEQ_SOUND:
308                         return &RNA_SoundSequence;
309                 case SEQ_CROSS:
310                 case SEQ_ADD:
311                 case SEQ_SUB:
312                 case SEQ_ALPHAOVER:
313                 case SEQ_ALPHAUNDER:
314                 case SEQ_GAMCROSS:
315                 case SEQ_MUL:
316                 case SEQ_OVERDROP:
317                         return &RNA_EffectSequence;
318                 case SEQ_MULTICAM:
319                         return &RNA_MulticamSequence;
320                 case SEQ_PLUGIN:
321                         return &RNA_PluginSequence;
322                 case SEQ_WIPE:
323                         return &RNA_WipeSequence;
324                 case SEQ_GLOW:
325                         return &RNA_GlowSequence;
326                 case SEQ_TRANSFORM:
327                         return &RNA_TransformSequence;
328                 case SEQ_COLOR:
329                         return &RNA_ColorSequence;
330                 case SEQ_SPEED:
331                         return &RNA_SpeedControlSequence;
332                 default:
333                         return &RNA_Sequence;
334         }
335 }
336
337 static char *rna_Sequence_path(PointerRNA *ptr)
338 {
339         Sequence *seq= (Sequence*)ptr->data;
340         
341         /* sequencer data comes from scene... 
342          * TODO: would be nice to make SequenceEditor data a datablock of its own (for shorter paths)
343          */
344         if (seq->name+2)
345                 return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"]", seq->name+2);
346         else
347                 return BLI_strdup("");
348 }
349
350 static PointerRNA rna_SequenceEditor_meta_stack_get(CollectionPropertyIterator *iter)
351 {
352         ListBaseIterator *internal= iter->internal;
353         MetaStack *ms= (MetaStack*)internal->link;
354
355         return rna_pointer_inherit_refine(&iter->parent, &RNA_Sequence, ms->parseq);
356 }
357
358 /* TODO, expose seq path setting as a higher level sequencer BKE function */
359 static void rna_Sequence_filepath_set(PointerRNA *ptr, const char *value)
360 {
361         Sequence *seq= (Sequence*)(ptr->data);
362         char dir[FILE_MAX], name[FILE_MAX];
363
364         if(seq->type == SEQ_SOUND && seq->sound) {
365                 /* for sound strips we need to update the sound as well.
366                  * arguably, this could load in a new sound rather then modify an existing one.
367                  * but while using the sequencer its most likely your not using the sound in the game engine too.
368                  */
369                 PointerRNA id_ptr;
370                 RNA_id_pointer_create((ID *)seq->sound, &id_ptr);
371                 RNA_string_set(&id_ptr, "filepath", value);
372         }
373
374         BLI_split_dirfile(value, dir, name);
375         BLI_strncpy(seq->strip->dir, dir, sizeof(seq->strip->dir));
376         BLI_strncpy(seq->strip->stripdata->name, name, sizeof(seq->strip->stripdata->name));
377 }
378
379 static void rna_Sequence_filepath_get(PointerRNA *ptr, char *value)
380 {
381         Sequence *seq= (Sequence*)(ptr->data);
382         char path[FILE_MAX];
383
384         BLI_join_dirfile(path, seq->strip->dir, seq->strip->stripdata->name);
385         BLI_strncpy(value, path, strlen(path)+1);
386 }
387
388 static int rna_Sequence_filepath_length(PointerRNA *ptr)
389 {
390         Sequence *seq= (Sequence*)(ptr->data);
391         char path[FILE_MAX];
392
393         BLI_join_dirfile(path, seq->strip->dir, seq->strip->stripdata->name);
394         return strlen(path)+1;
395 }
396
397 static void rna_Sequence_proxy_filepath_set(PointerRNA *ptr, const char *value)
398 {
399         StripProxy *proxy= (StripProxy*)(ptr->data);
400         char dir[FILE_MAX], name[FILE_MAX];
401
402         BLI_split_dirfile(value, dir, name);
403         BLI_strncpy(proxy->dir, dir, sizeof(proxy->dir));
404         BLI_strncpy(proxy->file, name, sizeof(proxy->file));
405 }
406
407 static void rna_Sequence_proxy_filepath_get(PointerRNA *ptr, char *value)
408 {
409         StripProxy *proxy= (StripProxy*)(ptr->data);
410         char path[FILE_MAX];
411
412         BLI_join_dirfile(path, proxy->dir, proxy->file);
413         BLI_strncpy(value, path, strlen(path)+1);
414 }
415
416 static int rna_Sequence_proxy_filepath_length(PointerRNA *ptr)
417 {
418         StripProxy *proxy= (StripProxy*)(ptr->data);
419         char path[FILE_MAX];
420
421         BLI_join_dirfile(path, proxy->dir, proxy->file);
422         return strlen(path)+1;
423 }
424
425 static float rna_Sequence_attenuation_get(PointerRNA *ptr)
426 {
427         Sequence *seq= (Sequence*)(ptr->data);
428
429         return to_dB(seq->volume);
430 }
431
432 static void rna_Sequence_attenuation_set(PointerRNA *ptr, float value)
433 {
434         Sequence *seq= (Sequence*)(ptr->data);
435
436         seq->volume = from_dB(value);
437 }
438
439
440 /*static void rna_SoundSequence_filename_set(PointerRNA *ptr, const char *value)
441 {
442         Sequence *seq= (Sequence*)(ptr->data);
443         char dir[FILE_MAX], name[FILE_MAX];
444
445         BLI_split_dirfile(value, dir, name);
446         BLI_strncpy(seq->strip->dir, dir, sizeof(seq->strip->dir));
447         BLI_strncpy(seq->strip->stripdata->name, name, sizeof(seq->strip->stripdata->name));
448 }
449
450 static void rna_SequenceElement_filename_set(PointerRNA *ptr, const char *value)
451 {
452         StripElem *elem= (StripElem*)(ptr->data);
453         char name[FILE_MAX];
454
455         BLI_split_dirfile(value, NULL, name);
456         BLI_strncpy(elem->name, name, sizeof(elem->name));
457 }*/
458
459 static void rna_Sequence_update(Main *bmain, Scene *scene, PointerRNA *ptr)
460 {
461         Editing *ed= seq_give_editing(scene, FALSE);
462
463         free_imbuf_seq(scene, &ed->seqbase, FALSE);
464
465         if(RNA_struct_is_a(ptr->type, &RNA_SoundSequence))
466                 seq_update_sound(scene, ptr->data);
467 }
468
469 static void rna_Sequence_mute_update(Main *bmain, Scene *scene, PointerRNA *ptr)
470 {
471         Editing *ed= seq_give_editing(scene, FALSE);
472
473         seq_update_muting(scene, ed);
474         rna_Sequence_update(bmain, scene, ptr);
475 }
476
477 static void rna_Sequence_filepath_update(Main *bmain, Scene *scene, PointerRNA *ptr)
478 {
479         Sequence *seq= (Sequence*)(ptr->data);
480         reload_sequence_new_file(scene, seq, TRUE);
481         calc_sequence(scene, seq);
482         rna_Sequence_update(bmain, scene, ptr);
483 }
484
485 /* do_versions? */
486 static float rna_Sequence_opacity_get(PointerRNA *ptr) {
487         return ((Sequence*)(ptr->data))->blend_opacity / 100.0f;
488 }
489 static void rna_Sequence_opacity_set(PointerRNA *ptr, float value) {
490         ((Sequence*)(ptr->data))->blend_opacity = value * 100.0f;
491 }
492
493
494 static int colbalance_seq_cmp_cb(Sequence *seq, void *arg_pt)
495 {
496         struct { Sequence *seq; void *color_balance; } *data= arg_pt;
497
498         if(seq->strip && seq->strip->color_balance == data->color_balance) {
499                 data->seq= seq;
500                 return -1; /* done so bail out */
501         }
502         return 1;
503 }
504 static char *rna_SequenceColorBalance_path(PointerRNA *ptr)
505 {
506         Scene *scene= ptr->id.data;
507         Editing *ed= seq_give_editing(scene, FALSE);
508         Sequence *seq;
509
510         struct { Sequence *seq; void *color_balance; } data;
511         data.seq= NULL;
512         data.color_balance= ptr->data;
513
514         /* irritating we need to search for our sequence! */
515         seqbase_recursive_apply(&ed->seqbase, colbalance_seq_cmp_cb, &data);
516         seq= data.seq;
517
518         if (seq && seq->name+2)
519                 return BLI_sprintfN("sequence_editor.sequences_all[\"%s\"].color_balance", seq->name+2);
520         else
521                 return BLI_strdup("");
522 }
523
524 static void rna_SequenceEditor_overlay_lock_set(PointerRNA *ptr, int value)
525 {
526         Scene *scene= ptr->id.data;
527         Editing *ed= seq_give_editing(scene, FALSE);
528
529         if(ed==NULL)
530                 return;
531
532         /* convert from abs to relative and back */
533         if((ed->over_flag & SEQ_EDIT_OVERLAY_ABS)==0 && value) {
534                 ed->over_cfra= scene->r.cfra + ed->over_ofs;
535                 ed->over_flag |= SEQ_EDIT_OVERLAY_ABS;
536         }
537         else if((ed->over_flag & SEQ_EDIT_OVERLAY_ABS) && !value) {
538                 ed->over_ofs= ed->over_cfra - scene->r.cfra;
539                 ed->over_flag &= ~SEQ_EDIT_OVERLAY_ABS;
540         }
541 }
542
543 static int rna_SequenceEditor_overlay_frame_get(PointerRNA *ptr)
544 {
545         Scene *scene= (Scene *)ptr->id.data;
546         Editing *ed= seq_give_editing(scene, FALSE);
547
548         if(ed==NULL)
549                 return scene->r.cfra;
550
551         if(ed->over_flag & SEQ_EDIT_OVERLAY_ABS)
552                 return ed->over_cfra - scene->r.cfra;
553         else
554                 return ed->over_ofs;
555
556 }
557
558 static void rna_SequenceEditor_overlay_frame_set(PointerRNA *ptr, int value)
559 {
560         Scene *scene= (Scene *)ptr->id.data;
561         Editing *ed= seq_give_editing(scene, FALSE);
562
563         if(ed==NULL)
564                 return;
565
566
567         if(ed->over_flag & SEQ_EDIT_OVERLAY_ABS)
568                 ed->over_cfra= (scene->r.cfra + value);
569         else
570                 ed->over_ofs= value;
571 }
572
573 #else
574
575 static void rna_def_strip_element(BlenderRNA *brna)
576 {
577         StructRNA *srna;
578         PropertyRNA *prop;
579         
580         srna = RNA_def_struct(brna, "SequenceElement", NULL);
581         RNA_def_struct_ui_text(srna, "Sequence Element", "Sequence strip data for a single frame");
582         RNA_def_struct_sdna(srna, "StripElem");
583         
584         prop= RNA_def_property(srna, "filename", PROP_STRING, PROP_FILENAME);
585         RNA_def_property_string_sdna(prop, NULL, "name");
586         RNA_def_property_ui_text(prop, "Filename", "");
587         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
588 }
589
590 static void rna_def_strip_crop(BlenderRNA *brna)
591 {
592         StructRNA *srna;
593         PropertyRNA *prop;
594         
595         srna = RNA_def_struct(brna, "SequenceCrop", NULL);
596         RNA_def_struct_ui_text(srna, "Sequence Crop", "Cropping parameters for a sequence strip");
597         RNA_def_struct_sdna(srna, "StripCrop");
598
599         prop= RNA_def_property(srna, "top", PROP_INT, PROP_UNSIGNED);
600         RNA_def_property_ui_text(prop, "Top", "");
601         RNA_def_property_ui_range(prop, 0, 4096, 1, 0);
602         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
603         
604         prop= RNA_def_property(srna, "bottom", PROP_INT, PROP_UNSIGNED);
605         RNA_def_property_ui_text(prop, "Bottom", "");
606         RNA_def_property_ui_range(prop, 0, 4096, 1, 0);
607         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
608         
609         prop= RNA_def_property(srna, "left", PROP_INT, PROP_UNSIGNED);
610         RNA_def_property_ui_text(prop, "Left", "");
611         RNA_def_property_ui_range(prop, 0, 4096, 1, 0);
612         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
613
614         prop= RNA_def_property(srna, "right", PROP_INT, PROP_UNSIGNED);
615         RNA_def_property_ui_text(prop, "Right", "");
616         RNA_def_property_ui_range(prop, 0, 4096, 1, 0);
617         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
618 }
619
620 static void rna_def_strip_transform(BlenderRNA *brna)
621 {
622         StructRNA *srna;
623         PropertyRNA *prop;
624         
625         srna = RNA_def_struct(brna, "SequenceTransform", NULL);
626         RNA_def_struct_ui_text(srna, "Sequence Transform", "Transform parameters for a sequence strip");
627         RNA_def_struct_sdna(srna, "StripTransform");
628
629         prop= RNA_def_property(srna, "offset_x", PROP_INT, PROP_NONE);
630         RNA_def_property_int_sdna(prop, NULL, "xofs");
631         RNA_def_property_ui_text(prop, "Offset X", "");
632         RNA_def_property_ui_range(prop, -4096, 4096, 1, 0);
633         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
634
635         prop= RNA_def_property(srna, "offset_y", PROP_INT, PROP_NONE);
636         RNA_def_property_int_sdna(prop, NULL, "yofs");
637         RNA_def_property_ui_text(prop, "Offset Y", "");
638         RNA_def_property_ui_range(prop, -4096, 4096, 1, 0);
639         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
640 }
641
642 static void rna_def_strip_proxy(BlenderRNA *brna)
643 {
644         StructRNA *srna;
645         PropertyRNA *prop;
646         
647         srna = RNA_def_struct(brna, "SequenceProxy", NULL);
648         RNA_def_struct_ui_text(srna, "Sequence Proxy", "Proxy parameters for a sequence strip");
649         RNA_def_struct_sdna(srna, "StripProxy");
650         
651         prop= RNA_def_property(srna, "directory", PROP_STRING, PROP_DIRPATH);
652         RNA_def_property_string_sdna(prop, NULL, "dir");
653         RNA_def_property_ui_text(prop, "Directory", "Location to store the proxy files");
654         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
655         
656         prop= RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
657         RNA_def_property_ui_text(prop, "Path", "Location of custom proxy file");
658         RNA_def_property_string_funcs(prop, "rna_Sequence_proxy_filepath_get", "rna_Sequence_proxy_filepath_length", "rna_Sequence_proxy_filepath_set");
659
660         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
661 }
662
663 static void rna_def_strip_color_balance(BlenderRNA *brna)
664 {
665         StructRNA *srna;
666         PropertyRNA *prop;
667
668         srna = RNA_def_struct(brna, "SequenceColorBalance", NULL);
669         RNA_def_struct_ui_text(srna, "Sequence Color Balance", "Color balance parameters for a sequence strip");
670         RNA_def_struct_sdna(srna, "StripColorBalance");
671
672         prop= RNA_def_property(srna, "lift", PROP_FLOAT, PROP_COLOR);
673         RNA_def_property_ui_text(prop, "Lift", "Color balance lift (shadows)");
674         RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
675         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
676         
677         prop= RNA_def_property(srna, "gamma", PROP_FLOAT, PROP_COLOR);
678         RNA_def_property_ui_text(prop, "Gamma", "Color balance gamma (midtones)");
679         RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
680         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
681         
682         prop= RNA_def_property(srna, "gain", PROP_FLOAT, PROP_COLOR);
683         RNA_def_property_ui_text(prop, "Gain", "Color balance gain (highlights)");
684         RNA_def_property_ui_range(prop, 0, 2, 0.1, 3);
685         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
686         
687         prop= RNA_def_property(srna, "inverse_gain", PROP_BOOLEAN, PROP_NONE);
688         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_COLOR_BALANCE_INVERSE_GAIN);
689         RNA_def_property_ui_text(prop, "Inverse Gain", "");
690         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
691
692         prop= RNA_def_property(srna, "inverse_gamma", PROP_BOOLEAN, PROP_NONE);
693         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_COLOR_BALANCE_INVERSE_GAMMA);
694         RNA_def_property_ui_text(prop, "Inverse Gamma", "");
695         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
696
697         prop= RNA_def_property(srna, "inverse_lift", PROP_BOOLEAN, PROP_NONE);
698         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_COLOR_BALANCE_INVERSE_LIFT);
699         RNA_def_property_ui_text(prop, "Inverse Lift", "");
700         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
701
702         RNA_def_struct_path_func(srna, "rna_SequenceColorBalance_path");
703
704         /* not yet used
705         prop= RNA_def_property(srna, "exposure", PROP_FLOAT, PROP_NONE);
706         RNA_def_property_range(prop, 0.0f, 1.0f);
707         RNA_def_property_ui_text(prop, "Exposure", "");
708         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
709         
710         prop= RNA_def_property(srna, "saturation", PROP_FLOAT, PROP_NONE);
711         RNA_def_property_range(prop, 0.0f, 1.0f);
712         RNA_def_property_ui_text(prop, "Saturation", "");
713         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update"); */
714 }
715
716 static void rna_def_sequence(BlenderRNA *brna)
717 {
718         StructRNA *srna;
719         PropertyRNA *prop;
720
721         static const EnumPropertyItem seq_type_items[]= {
722                 {SEQ_IMAGE, "IMAGE", 0, "Image", ""}, 
723                 {SEQ_META, "META", 0, "Meta", ""}, 
724                 {SEQ_SCENE, "SCENE", 0, "Scene", ""}, 
725                 {SEQ_MOVIE, "MOVIE", 0, "Movie", ""}, 
726                 {SEQ_SOUND, "SOUND", 0, "Sound", ""},
727                 {SEQ_CROSS, "CROSS", 0, "Cross", ""}, 
728                 {SEQ_ADD, "ADD", 0, "Add", ""}, 
729                 {SEQ_SUB, "SUBTRACT", 0, "Subtract", ""}, 
730                 {SEQ_ALPHAOVER, "ALPHA_OVER", 0, "Alpha Over", ""}, 
731                 {SEQ_ALPHAUNDER, "ALPHA_UNDER", 0, "Alpha Under", ""}, 
732                 {SEQ_GAMCROSS, "GAMMA_CROSS", 0, "Gamma Cross", ""}, 
733                 {SEQ_MUL, "MULTIPLY", 0, "Multiply", ""}, 
734                 {SEQ_OVERDROP, "OVER_DROP", 0, "Over Drop", ""}, 
735                 {SEQ_PLUGIN, "PLUGIN", 0, "plugin", ""}, 
736                 {SEQ_WIPE, "WIPE", 0, "Wipe", ""}, 
737                 {SEQ_GLOW, "GLOW", 0, "Glow", ""}, 
738                 {SEQ_TRANSFORM, "TRANSFORM", 0, "Transform", ""}, 
739                 {SEQ_COLOR, "COLOR", 0, "Color", ""}, 
740                 {SEQ_SPEED, "SPEED", 0, "Speed", ""}, 
741                 {SEQ_MULTICAM, "MULTICAM", 0, "Multicam Selector", ""},
742                 {0, NULL, 0, NULL, NULL}};
743
744         static const EnumPropertyItem blend_mode_items[]= {
745                 {SEQ_BLEND_REPLACE, "REPLACE", 0, "Replace", ""}, 
746                 {SEQ_CROSS, "CROSS", 0, "Cross", ""}, 
747                 {SEQ_ADD, "ADD", 0, "Add", ""}, 
748                 {SEQ_SUB, "SUBTRACT", 0, "Subtract", ""}, 
749                 {SEQ_ALPHAOVER, "ALPHA_OVER", 0, "Alpha Over", ""}, 
750                 {SEQ_ALPHAUNDER, "ALPHA_UNDER", 0, "Alpha Under", ""}, 
751                 {SEQ_GAMCROSS, "GAMMA_CROSS", 0, "Gamma Cross", ""}, 
752                 {SEQ_MUL, "MULTIPLY", 0, "Multiply", ""}, 
753                 {SEQ_OVERDROP, "OVER_DROP", 0, "Over Drop", ""}, 
754                 {0, NULL, 0, NULL, NULL}};
755         
756         srna = RNA_def_struct(brna, "Sequence", NULL);
757         RNA_def_struct_ui_text(srna, "Sequence", "Sequence strip in the sequence editor");
758         RNA_def_struct_refine_func(srna, "rna_Sequence_refine");
759         RNA_def_struct_path_func(srna, "rna_Sequence_path");
760
761         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
762         RNA_def_property_string_funcs(prop, "rna_Sequence_name_get", "rna_Sequence_name_length", "rna_Sequence_name_set");
763         RNA_def_property_string_maxlength(prop, sizeof(((Sequence*)NULL)->name)-2);
764         RNA_def_property_ui_text(prop, "Name", "");
765         RNA_def_struct_name_property(srna, prop);
766         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
767
768         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
769         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
770         RNA_def_property_enum_items(prop, seq_type_items);
771         RNA_def_property_ui_text(prop, "Type", "");
772         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
773
774         //prop= RNA_def_property(srna, "ipo", PROP_POINTER, PROP_NONE);
775         //RNA_def_property_ui_text(prop, "IPO Curves", "IPO curves used by this sequence");
776
777         /* flags */
778
779         prop= RNA_def_property(srna, "selected", PROP_BOOLEAN, PROP_NONE);
780         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
781         RNA_def_property_ui_text(prop, "Selected", "");
782         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER|NA_SELECTED, NULL);
783
784         prop= RNA_def_property(srna, "left_handle_selected", PROP_BOOLEAN, PROP_NONE);
785         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_LEFTSEL);
786         RNA_def_property_ui_text(prop, "Left Handle Selected", "");
787         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER|NA_SELECTED, NULL);
788
789         prop= RNA_def_property(srna, "right_handle_selected", PROP_BOOLEAN, PROP_NONE);
790         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_RIGHTSEL);
791         RNA_def_property_ui_text(prop, "Right Handle Selected", "");
792         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER|NA_SELECTED, NULL);
793
794         prop= RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
795         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_MUTE);
796         RNA_def_property_ui_text(prop, "Mute", "");
797         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_mute_update");
798
799         prop= RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
800         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_LOCK);
801         RNA_def_property_ui_text(prop, "Lock", "Lock strip so that it can't be transformed");
802         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
803
804         /* strip positioning */
805
806         prop= RNA_def_property(srna, "frame_final_length", PROP_INT, PROP_TIME);
807         RNA_def_property_range(prop, 1, MAXFRAME);
808         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
809         RNA_def_property_ui_text(prop, "Length", "The length of the contents of this strip before the handles are applied");
810         RNA_def_property_int_funcs(prop, "rna_Sequence_frame_length_get", "rna_Sequence_frame_length_set",NULL);
811         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
812
813         prop= RNA_def_property(srna, "frame_length", PROP_INT, PROP_TIME);
814         RNA_def_property_int_sdna(prop, NULL, "len");
815         RNA_def_property_clear_flag(prop, PROP_EDITABLE|PROP_ANIMATABLE);
816         RNA_def_property_range(prop, 1, MAXFRAME);
817         RNA_def_property_ui_text(prop, "Length", "The length of the contents of this strip before the handles are applied");
818         
819         prop= RNA_def_property(srna, "frame_start", PROP_INT, PROP_TIME);
820         RNA_def_property_int_sdna(prop, NULL, "start");
821         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
822         RNA_def_property_ui_text(prop, "Start Frame", "");
823         RNA_def_property_int_funcs(prop, NULL, "rna_Sequence_start_frame_set",NULL); // overlap tests and calc_seq_disp
824         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
825         
826         prop= RNA_def_property(srna, "frame_final_start", PROP_INT, PROP_TIME);
827         RNA_def_property_int_sdna(prop, NULL, "startdisp");
828         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
829         RNA_def_property_ui_text(prop, "Start Frame", "Start frame displayed in the sequence editor after offsets are applied, setting this is equivalent to moving the handle, not the actual start frame");
830         RNA_def_property_int_funcs(prop, NULL, "rna_Sequence_start_frame_final_set", NULL); // overlap tests and calc_seq_disp
831         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
832
833         prop= RNA_def_property(srna, "frame_final_end", PROP_INT, PROP_TIME);
834         RNA_def_property_int_sdna(prop, NULL, "enddisp");
835         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
836         RNA_def_property_ui_text(prop, "End Frame", "End frame displayed in the sequence editor after offsets are applied");
837         RNA_def_property_int_funcs(prop, NULL, "rna_Sequence_end_frame_final_set", NULL); // overlap tests and calc_seq_disp
838         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
839
840         prop= RNA_def_property(srna, "frame_offset_start", PROP_INT, PROP_TIME);
841         RNA_def_property_int_sdna(prop, NULL, "startofs");
842         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // overlap tests
843         RNA_def_property_ui_text(prop, "Start Offset", "");
844         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
845         
846         prop= RNA_def_property(srna, "frame_offset_end", PROP_INT, PROP_TIME);
847         RNA_def_property_int_sdna(prop, NULL, "endofs");
848         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // overlap tests
849         RNA_def_property_ui_text(prop, "End Offset", "");
850         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
851         
852         prop= RNA_def_property(srna, "frame_still_start", PROP_INT, PROP_TIME);
853         RNA_def_property_int_sdna(prop, NULL, "startstill");
854         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // overlap tests
855         RNA_def_property_range(prop, 0, MAXFRAME);
856         RNA_def_property_ui_text(prop, "Start Still", "");
857         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
858         
859         prop= RNA_def_property(srna, "frame_still_end", PROP_INT, PROP_TIME);
860         RNA_def_property_int_sdna(prop, NULL, "endstill");
861         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // overlap tests
862         RNA_def_property_range(prop, 0, MAXFRAME);
863         RNA_def_property_ui_text(prop, "End Still", "");
864         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
865         
866         prop= RNA_def_property(srna, "channel", PROP_INT, PROP_UNSIGNED);
867         RNA_def_property_int_sdna(prop, NULL, "machine");
868         RNA_def_property_range(prop, 0, MAXSEQ-1);
869         RNA_def_property_ui_text(prop, "Channel", "Y position of the sequence strip");
870         RNA_def_property_int_funcs(prop, NULL, "rna_Sequence_channel_set",NULL); // overlap test
871         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
872
873         /* blending */
874
875         prop= RNA_def_property(srna, "blend_mode", PROP_ENUM, PROP_NONE);
876         RNA_def_property_enum_items(prop, blend_mode_items);
877         RNA_def_property_ui_text(prop, "Blend Mode", "");
878         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
879         
880         prop= RNA_def_property(srna, "blend_opacity", PROP_FLOAT, PROP_FACTOR);
881         RNA_def_property_range(prop, 0.0f, 1.0f);
882         RNA_def_property_ui_text(prop, "Blend Opacity", "");
883         RNA_def_property_float_funcs(prop, "rna_Sequence_opacity_get", "rna_Sequence_opacity_set", NULL); // stupid 0-100 -> 0-1
884         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
885         
886         prop= RNA_def_property(srna, "effect_fader", PROP_FLOAT, PROP_NONE);
887         RNA_def_property_range(prop, 0.0f, 1.0f);
888         RNA_def_property_float_sdna(prop, NULL, "effect_fader");
889         RNA_def_property_ui_text(prop, "Effect fader position", "");
890         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
891
892         prop= RNA_def_property(srna, "use_effect_default_fade", PROP_BOOLEAN, PROP_NONE);
893         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_EFFECT_DEFAULT_FADE);
894         RNA_def_property_ui_text(prop, "Use Default Fade", "Fade effect using the built-in default (usually make transition as long as effect strip)");
895         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
896         
897
898         prop= RNA_def_property(srna, "speed_fader", PROP_FLOAT, PROP_NONE);
899         RNA_def_property_float_sdna(prop, NULL, "speed_fader");
900         RNA_def_property_ui_text(prop, "Speed effect fader position", "");
901         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
902
903         RNA_api_sequence_strip(srna);
904 }
905
906 static void rna_def_editor(BlenderRNA *brna)
907 {
908         StructRNA *srna;
909         PropertyRNA *prop;
910         
911         srna = RNA_def_struct(brna, "SequenceEditor", NULL);
912         RNA_def_struct_ui_text(srna, "Sequence Editor", "Sequence editing data for a Scene datablock");
913         RNA_def_struct_ui_icon(srna, ICON_SEQUENCE);
914         RNA_def_struct_sdna(srna, "Editing");
915
916         prop= RNA_def_property(srna, "sequences", PROP_COLLECTION, PROP_NONE);
917         RNA_def_property_collection_sdna(prop, NULL, "seqbase", NULL);
918         RNA_def_property_struct_type(prop, "Sequence");
919         RNA_def_property_ui_text(prop, "Sequences", "");
920
921         prop= RNA_def_property(srna, "sequences_all", PROP_COLLECTION, PROP_NONE);
922         RNA_def_property_collection_sdna(prop, NULL, "seqbase", NULL);
923         RNA_def_property_struct_type(prop, "Sequence");
924         RNA_def_property_ui_text(prop, "Sequences", "");
925         RNA_def_property_collection_funcs(prop, "rna_SequenceEditor_sequences_all_begin", "rna_SequenceEditor_sequences_all_next", 0, 0, 0, 0, 0);
926
927         prop= RNA_def_property(srna, "meta_stack", PROP_COLLECTION, PROP_NONE);
928         RNA_def_property_collection_sdna(prop, NULL, "metastack", NULL);
929         RNA_def_property_struct_type(prop, "Sequence");
930         RNA_def_property_ui_text(prop, "Meta Stack", "Meta strip stack, last is currently edited meta strip");
931         RNA_def_property_collection_funcs(prop, 0, 0, 0, "rna_SequenceEditor_meta_stack_get", 0, 0, 0);
932         
933         prop= RNA_def_property(srna, "active_strip", PROP_POINTER, PROP_NONE);
934         RNA_def_property_pointer_sdna(prop, NULL, "act_seq");
935         RNA_def_property_flag(prop, PROP_EDITABLE);
936
937         prop= RNA_def_property(srna, "show_overlay", PROP_BOOLEAN, PROP_NONE);
938         RNA_def_property_boolean_sdna(prop, NULL, "over_flag", SEQ_EDIT_OVERLAY_SHOW);
939         RNA_def_property_ui_text(prop, "Draw Axes", "Partial overlay ontop of the sequencer");
940         RNA_def_property_update(prop, NC_SPACE|ND_SPACE_SEQUENCER, NULL);
941
942         prop= RNA_def_property(srna, "overlay_lock", PROP_BOOLEAN, PROP_NONE);
943         RNA_def_property_boolean_sdna(prop, NULL, "over_flag", SEQ_EDIT_OVERLAY_ABS);
944         RNA_def_property_ui_text(prop, "Overlay Lock", "");
945         RNA_def_property_boolean_funcs(prop, NULL, "rna_SequenceEditor_overlay_lock_set");
946         RNA_def_property_update(prop, NC_SPACE|ND_SPACE_SEQUENCER, NULL);
947
948         /* access to fixed and relative frame */
949         prop= RNA_def_property(srna, "overlay_frame", PROP_INT, PROP_NONE);
950         RNA_def_property_ui_text(prop, "Overlay Offset", "");
951         RNA_def_property_int_funcs(prop, "rna_SequenceEditor_overlay_frame_get", "rna_SequenceEditor_overlay_frame_set", NULL);
952         RNA_def_property_update(prop, NC_SPACE|ND_SPACE_SEQUENCER, NULL);
953         RNA_def_property_ui_text(prop, "Active Strip", "Sequencers active strip");
954 }
955
956 static void rna_def_filter_video(StructRNA *srna)
957 {
958         PropertyRNA *prop;
959
960         prop= RNA_def_property(srna, "de_interlace", PROP_BOOLEAN, PROP_NONE);
961         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_FILTERY);
962         RNA_def_property_ui_text(prop, "De-Interlace", "For video movies to remove fields");
963
964         prop= RNA_def_property(srna, "premultiply", PROP_BOOLEAN, PROP_NONE);
965         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_MAKE_PREMUL);
966         RNA_def_property_ui_text(prop, "Premultiply", "Convert RGB from key alpha to premultiplied alpha");
967         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
968
969         prop= RNA_def_property(srna, "flip_x", PROP_BOOLEAN, PROP_NONE);
970         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_FLIPX);
971         RNA_def_property_ui_text(prop, "Flip X", "Flip on the X axis");
972         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
973
974         prop= RNA_def_property(srna, "flip_y", PROP_BOOLEAN, PROP_NONE);
975         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_FLIPY);
976         RNA_def_property_ui_text(prop, "Flip Y", "Flip on the Y axis");
977         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
978
979         prop= RNA_def_property(srna, "convert_float", PROP_BOOLEAN, PROP_NONE);
980         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_MAKE_FLOAT);
981         RNA_def_property_ui_text(prop, "Convert Float", "Convert input to float data");
982         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
983
984         prop= RNA_def_property(srna, "reverse_frames", PROP_BOOLEAN, PROP_NONE);
985         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_REVERSE_FRAMES);
986         RNA_def_property_ui_text(prop, "Flip Time", "Reverse frame order");
987         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
988
989         prop= RNA_def_property(srna, "multiply_colors", PROP_FLOAT, PROP_UNSIGNED);
990         RNA_def_property_float_sdna(prop, NULL, "mul");
991         RNA_def_property_range(prop, 0.0f, 20.0f);
992         RNA_def_property_ui_text(prop, "Multiply Colors", "");
993         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
994
995         prop= RNA_def_property(srna, "color_saturation", PROP_FLOAT, PROP_UNSIGNED);
996         RNA_def_property_float_sdna(prop, NULL, "sat");
997         RNA_def_property_range(prop, 0.0f, 20.0f);
998         RNA_def_property_ui_range(prop, 0.0f, 2.0f, 3, 3);
999         RNA_def_property_ui_text(prop, "Saturation", "");
1000         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1001
1002         prop= RNA_def_property(srna, "strobe", PROP_FLOAT, PROP_NONE);
1003         RNA_def_property_range(prop, 1.0f, 30.0f);
1004         RNA_def_property_ui_text(prop, "Strobe", "Only display every nth frame");
1005         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1006
1007         prop= RNA_def_property(srna, "use_color_balance", PROP_BOOLEAN, PROP_NONE);
1008         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_COLOR_BALANCE);
1009         RNA_def_property_ui_text(prop, "Use Color Balance", "(3-Way color correction) on input");
1010         RNA_def_property_boolean_funcs(prop, NULL, "rna_Sequence_use_color_balance_set");
1011         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1012
1013         prop= RNA_def_property(srna, "color_balance", PROP_POINTER, PROP_NONE);
1014         RNA_def_property_pointer_sdna(prop, NULL, "strip->color_balance");
1015         RNA_def_property_ui_text(prop, "Color Balance", "");
1016
1017         prop= RNA_def_property(srna, "use_translation", PROP_BOOLEAN, PROP_NONE);
1018         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_TRANSFORM);
1019         RNA_def_property_ui_text(prop, "Use Translation", "Translate image before processing");
1020         RNA_def_property_boolean_funcs(prop, NULL, "rna_Sequence_use_translation_set");
1021         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1022
1023         prop= RNA_def_property(srna, "transform", PROP_POINTER, PROP_NONE);
1024         RNA_def_property_pointer_sdna(prop, NULL, "strip->transform");
1025         RNA_def_property_ui_text(prop, "Transform", "");
1026
1027         prop= RNA_def_property(srna, "use_crop", PROP_BOOLEAN, PROP_NONE);
1028         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_CROP);
1029         RNA_def_property_ui_text(prop, "Use Crop", "Crop image before processing");
1030         RNA_def_property_boolean_funcs(prop, NULL, "rna_Sequence_use_crop_set");
1031         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1032
1033         prop= RNA_def_property(srna, "crop", PROP_POINTER, PROP_NONE);
1034         RNA_def_property_pointer_sdna(prop, NULL, "strip->crop");
1035         RNA_def_property_ui_text(prop, "Crop", "");
1036 }
1037
1038 static void rna_def_proxy(StructRNA *srna)
1039 {
1040         PropertyRNA *prop;
1041
1042         prop= RNA_def_property(srna, "use_proxy", PROP_BOOLEAN, PROP_NONE);
1043         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_PROXY);
1044         RNA_def_property_ui_text(prop, "Use Proxy", "Use a preview proxy for this strip");
1045         RNA_def_property_boolean_funcs(prop, NULL, "rna_Sequence_use_proxy_set");
1046
1047         prop= RNA_def_property(srna, "proxy", PROP_POINTER, PROP_NONE);
1048         RNA_def_property_pointer_sdna(prop, NULL, "strip->proxy");
1049         RNA_def_property_ui_text(prop, "Proxy", "");
1050
1051         prop= RNA_def_property(srna, "proxy_custom_directory", PROP_BOOLEAN, PROP_NONE);
1052         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_PROXY_CUSTOM_DIR);
1053         RNA_def_property_ui_text(prop, "Proxy Custom Directory", "Use a custom directory to store data");
1054         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1055
1056         prop= RNA_def_property(srna, "proxy_custom_file", PROP_BOOLEAN, PROP_NONE);
1057         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_PROXY_CUSTOM_FILE);
1058         RNA_def_property_ui_text(prop, "Proxy Custom File", "Use a custom file to read proxy data from");
1059         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1060 }
1061
1062 static void rna_def_input(StructRNA *srna)
1063 {
1064         PropertyRNA *prop;
1065
1066         prop= RNA_def_property(srna, "animation_start_offset", PROP_INT, PROP_UNSIGNED);
1067         RNA_def_property_int_sdna(prop, NULL, "anim_startofs");
1068         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1069         RNA_def_property_int_funcs(prop, NULL, "rna_Sequence_anim_startofs_final_set", NULL); // overlap tests
1070
1071         RNA_def_property_ui_text(prop, "Animation Start Offset", "Animation start offset (trim start)");
1072         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1073         
1074         prop= RNA_def_property(srna, "animation_end_offset", PROP_INT, PROP_UNSIGNED);
1075         RNA_def_property_int_sdna(prop, NULL, "anim_endofs");
1076         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1077         RNA_def_property_int_funcs(prop, NULL, "rna_Sequence_anim_endofs_final_set", NULL); // overlap tests
1078         RNA_def_property_ui_text(prop, "Animation End Offset", "Animation end offset (trim end)");
1079         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1080 }
1081
1082 static void rna_def_image(BlenderRNA *brna)
1083 {
1084         StructRNA *srna;
1085         PropertyRNA *prop;
1086         
1087         srna = RNA_def_struct(brna, "ImageSequence", "Sequence");
1088         RNA_def_struct_ui_text(srna, "Image Sequence", "Sequence strip to load one or more images");
1089         RNA_def_struct_sdna(srna, "Sequence");
1090
1091         prop= RNA_def_property(srna, "directory", PROP_STRING, PROP_DIRPATH);
1092         RNA_def_property_string_sdna(prop, NULL, "strip->dir");
1093         RNA_def_property_ui_text(prop, "Directory", "");
1094         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1095
1096         prop= RNA_def_property(srna, "elements", PROP_COLLECTION, PROP_NONE);
1097         RNA_def_property_collection_sdna(prop, NULL, "strip->stripdata", "strip->len");
1098         RNA_def_property_struct_type(prop, "SequenceElement");
1099         RNA_def_property_ui_text(prop, "Elements", "");
1100
1101         rna_def_filter_video(srna);
1102         rna_def_proxy(srna);
1103         rna_def_input(srna);
1104 }
1105
1106 static void rna_def_meta(BlenderRNA *brna)
1107 {
1108         StructRNA *srna;
1109         PropertyRNA *prop;
1110         
1111         srna = RNA_def_struct(brna, "MetaSequence", "Sequence");
1112         RNA_def_struct_ui_text(srna, "Meta Sequence", "Sequence strip to group other strips as a single sequence strip");
1113         RNA_def_struct_sdna(srna, "Sequence");
1114
1115         prop = RNA_def_property(srna, "sequences", PROP_COLLECTION, PROP_NONE);
1116         RNA_def_property_collection_sdna(prop, NULL, "seqbase", NULL);
1117         RNA_def_property_struct_type(prop, "Sequence");
1118         RNA_def_property_ui_text(prop, "Sequences", "");
1119
1120         rna_def_filter_video(srna);
1121         rna_def_proxy(srna);
1122         rna_def_input(srna);
1123 }
1124
1125 static void rna_def_scene(BlenderRNA *brna)
1126 {
1127         StructRNA *srna;
1128         PropertyRNA *prop;
1129         
1130         srna = RNA_def_struct(brna, "SceneSequence", "Sequence");
1131         RNA_def_struct_ui_text(srna, "Scene Sequence", "Sequence strip to used the rendered image of a scene");
1132         RNA_def_struct_sdna(srna, "Sequence");
1133
1134         prop= RNA_def_property(srna, "scene", PROP_POINTER, PROP_NONE);
1135         RNA_def_property_flag(prop, PROP_EDITABLE);
1136         RNA_def_property_ui_text(prop, "Scene", "Scene that this sequence uses");
1137         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1138
1139         prop= RNA_def_property(srna, "scene_camera", PROP_POINTER, PROP_NONE);
1140         RNA_def_property_flag(prop, PROP_EDITABLE);
1141         RNA_def_property_ui_text(prop, "Camera Override", "Override the scenes active camera");
1142         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1143
1144         rna_def_filter_video(srna);
1145         rna_def_proxy(srna);
1146         rna_def_input(srna);
1147 }
1148
1149 static void rna_def_movie(BlenderRNA *brna)
1150 {
1151         StructRNA *srna;
1152         PropertyRNA *prop;
1153         
1154         srna = RNA_def_struct(brna, "MovieSequence", "Sequence");
1155         RNA_def_struct_ui_text(srna, "Movie Sequence", "Sequence strip to load a video");
1156         RNA_def_struct_sdna(srna, "Sequence");
1157
1158         prop= RNA_def_property(srna, "mpeg_preseek", PROP_INT, PROP_NONE);
1159         RNA_def_property_int_sdna(prop, NULL, "anim_preseek");
1160         RNA_def_property_range(prop, 0, 50);
1161         RNA_def_property_ui_text(prop, "MPEG Preseek", "For MPEG movies, preseek this many frames");
1162         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1163
1164         prop= RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
1165         RNA_def_property_ui_text(prop, "File", "");
1166         RNA_def_property_string_funcs(prop, "rna_Sequence_filepath_get", "rna_Sequence_filepath_length",
1167                                                                                 "rna_Sequence_filepath_set");
1168         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_filepath_update");
1169
1170         rna_def_filter_video(srna);
1171         rna_def_proxy(srna);
1172         rna_def_input(srna);
1173 }
1174
1175 static void rna_def_sound(BlenderRNA *brna)
1176 {
1177         StructRNA *srna;
1178         PropertyRNA *prop;
1179         
1180         srna = RNA_def_struct(brna, "SoundSequence", "Sequence");
1181         RNA_def_struct_ui_text(srna, "Sound Sequence", "Sequence strip defining a sound to be played over a period of time");
1182         RNA_def_struct_sdna(srna, "Sequence");
1183
1184         prop= RNA_def_property(srna, "sound", PROP_POINTER, PROP_NONE);
1185         RNA_def_property_struct_type(prop, "Sound");
1186         RNA_def_property_ui_text(prop, "Sound", "Sound datablock used by this sequence");
1187         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1188
1189         prop= RNA_def_property(srna, "volume", PROP_FLOAT, PROP_NONE);
1190         RNA_def_property_float_sdna(prop, NULL, "volume");
1191         RNA_def_property_range(prop, 0.0f, 100.0f);
1192         RNA_def_property_ui_text(prop, "Volume", "Playback volume of the sound");
1193         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1194
1195         prop= RNA_def_property(srna, "attenuation", PROP_FLOAT, PROP_NONE);
1196         RNA_def_property_range(prop, -100.0f, +40.0f);
1197         RNA_def_property_ui_text(prop, "Attenuation/db", "Attenuation in dezibel");
1198         RNA_def_property_float_funcs(prop, "rna_Sequence_attenuation_get", "rna_Sequence_attenuation_set", NULL); 
1199
1200         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1201
1202         prop= RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
1203         RNA_def_property_ui_text(prop, "File", "");
1204         RNA_def_property_string_funcs(prop, "rna_Sequence_filepath_get", "rna_Sequence_filepath_length", 
1205                                                                                 "rna_Sequence_filepath_set");
1206         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1207         
1208         rna_def_input(srna);
1209 }
1210
1211 static void rna_def_effect(BlenderRNA *brna)
1212 {
1213         StructRNA *srna;
1214
1215         srna = RNA_def_struct(brna, "EffectSequence", "Sequence");
1216         RNA_def_struct_ui_text(srna, "Effect Sequence", "Sequence strip applying an effect on the images created by other strips");
1217         RNA_def_struct_sdna(srna, "Sequence");
1218
1219         rna_def_filter_video(srna);
1220         rna_def_proxy(srna);
1221 }
1222
1223 static void rna_def_multicam(BlenderRNA *brna)
1224 {
1225         StructRNA *srna;
1226         PropertyRNA *prop;
1227         
1228         srna = RNA_def_struct(brna, "MulticamSequence", "Sequence");
1229         RNA_def_struct_ui_text(srna, "Multicam Select Sequence", "Sequence strip to perform multicam editing: select channel from below");
1230         RNA_def_struct_sdna(srna, "Sequence");
1231
1232         prop= RNA_def_property(srna, "multicam_source", PROP_INT, PROP_UNSIGNED);
1233         RNA_def_property_int_sdna(prop, NULL, "multicam_source");
1234         RNA_def_property_range(prop, 0, MAXSEQ-1);
1235         RNA_def_property_ui_text(prop, "Multicam Source Channel", "");
1236         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1237
1238         rna_def_filter_video(srna);
1239         rna_def_proxy(srna);
1240         rna_def_input(srna);
1241 }
1242
1243 static void rna_def_plugin(BlenderRNA *brna)
1244 {
1245         StructRNA *srna;
1246         PropertyRNA *prop;
1247         
1248         srna = RNA_def_struct(brna, "PluginSequence", "EffectSequence");
1249         RNA_def_struct_ui_text(srna, "Plugin Sequence", "Sequence strip applying an effect, loaded from an external plugin");
1250         RNA_def_struct_sdna_from(srna, "PluginSeq", "plugin");
1251
1252         prop= RNA_def_property(srna, "filename", PROP_STRING, PROP_FILEPATH);
1253         RNA_def_property_string_sdna(prop, NULL, "name");
1254         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1255         RNA_def_property_ui_text(prop, "Filename", "");
1256         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1257         
1258         /* plugin properties need custom wrapping code like ID properties */
1259 }
1260
1261 static void rna_def_wipe(BlenderRNA *brna)
1262 {
1263         StructRNA *srna;
1264         PropertyRNA *prop;
1265         
1266         static const EnumPropertyItem wipe_type_items[]= {
1267                 {0, "SINGLE", 0, "Single", ""}, 
1268                 {1, "DOUBLE", 0, "Double", ""}, 
1269                 /* not used yet {2, "BOX", 0, "Box", ""}, */
1270                 /* not used yet {3, "CROSS", 0, "Cross", ""}, */
1271                 {4, "IRIS", 0, "Iris", ""}, 
1272                 {5, "CLOCK", 0, "Clock", ""},   
1273                 {0, NULL, 0, NULL, NULL}
1274         };
1275
1276         static const EnumPropertyItem wipe_direction_items[]= {
1277                 {0, "OUT", 0, "Out", ""},
1278                 {1, "IN", 0, "In", ""},
1279                 {0, NULL, 0, NULL, NULL}
1280         };
1281
1282         srna = RNA_def_struct(brna, "WipeSequence", "EffectSequence");
1283         RNA_def_struct_ui_text(srna, "Wipe Sequence", "Sequence strip creating a wipe transition");
1284         RNA_def_struct_sdna_from(srna, "WipeVars", "effectdata");
1285
1286         prop= RNA_def_property(srna, "blur_width", PROP_FLOAT, PROP_UNSIGNED);
1287         RNA_def_property_float_sdna(prop, NULL, "edgeWidth");
1288         RNA_def_property_range(prop, 0.0f, 1.0f);
1289         RNA_def_property_ui_text(prop, "Blur Width", "Width of the blur edge, in percentage relative to the image size");
1290         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1291         
1292         prop= RNA_def_property(srna, "angle", PROP_FLOAT, PROP_NONE);
1293         RNA_def_property_float_sdna(prop, NULL, "angle");
1294         RNA_def_property_range(prop, -90.0f, 90.0f);
1295         RNA_def_property_ui_text(prop, "Angle", "Edge angle");
1296         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1297         
1298         prop= RNA_def_property(srna, "direction", PROP_ENUM, PROP_NONE);
1299         RNA_def_property_enum_sdna(prop, NULL, "forward");
1300         RNA_def_property_enum_items(prop, wipe_direction_items);
1301         RNA_def_property_ui_text(prop, "Direction", "Wipe direction");
1302         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1303         
1304         prop= RNA_def_property(srna, "transition_type", PROP_ENUM, PROP_NONE);
1305         RNA_def_property_enum_sdna(prop, NULL, "wipetype");
1306         RNA_def_property_enum_items(prop, wipe_type_items);
1307         RNA_def_property_ui_text(prop, "Transition Type", "");
1308         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1309 }
1310
1311 static void rna_def_glow(BlenderRNA *brna)
1312 {
1313         StructRNA *srna;
1314         PropertyRNA *prop;
1315         
1316         srna = RNA_def_struct(brna, "GlowSequence", "EffectSequence");
1317         RNA_def_struct_ui_text(srna, "Glow Sequence", "Sequence strip creating a glow effect");
1318         RNA_def_struct_sdna_from(srna, "GlowVars", "effectdata");
1319         
1320         prop= RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_NONE);
1321         RNA_def_property_float_sdna(prop, NULL, "fMini");
1322         RNA_def_property_range(prop, 0.0f, 1.0f);
1323         RNA_def_property_ui_text(prop, "Threshold", "Minimum intensity to trigger a glow");
1324         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1325         
1326         prop= RNA_def_property(srna, "clamp", PROP_FLOAT, PROP_NONE);
1327         RNA_def_property_float_sdna(prop, NULL, "fClamp");
1328         RNA_def_property_range(prop, 0.0f, 1.0f);
1329         RNA_def_property_ui_text(prop, "Clamp", "rightness limit of intensity");
1330         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1331         
1332         prop= RNA_def_property(srna, "boost_factor", PROP_FLOAT, PROP_NONE);
1333         RNA_def_property_float_sdna(prop, NULL, "fBoost");
1334         RNA_def_property_range(prop, 0.0f, 10.0f);
1335         RNA_def_property_ui_text(prop, "Boost Factor", "Brightness multiplier");
1336         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1337         
1338         prop= RNA_def_property(srna, "blur_distance", PROP_FLOAT, PROP_NONE);
1339         RNA_def_property_float_sdna(prop, NULL, "dDist");
1340         RNA_def_property_range(prop, 0.5f, 20.0f);
1341         RNA_def_property_ui_text(prop, "Blur Distance", "Radius of glow effect");
1342         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1343         
1344         prop= RNA_def_property(srna, "quality", PROP_INT, PROP_NONE);
1345         RNA_def_property_int_sdna(prop, NULL, "dQuality");
1346         RNA_def_property_range(prop, 1, 5);
1347         RNA_def_property_ui_text(prop, "Quality", "Accuracy of the blur effect");
1348         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1349         
1350         prop= RNA_def_property(srna, "only_boost", PROP_BOOLEAN, PROP_NONE);
1351         RNA_def_property_boolean_sdna(prop, NULL, "bNoComp", 0);
1352         RNA_def_property_ui_text(prop, "Only Boost", "Show the glow buffer only");
1353         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1354 }
1355
1356 static void rna_def_transform(BlenderRNA *brna)
1357 {
1358         StructRNA *srna;
1359         PropertyRNA *prop;
1360
1361         static const EnumPropertyItem interpolation_items[]= {
1362                 {0, "NONE", 0, "None", "No interpolation"},
1363                 {1, "BILINEAR", 0, "Bilinear", "Bilinear interpolation"},
1364                 {2, "BICUBIC", 0, "Bicubic", "Bicubic interpolation"},
1365                 {0, NULL, 0, NULL, NULL}
1366         };
1367
1368         static const EnumPropertyItem translation_unit_items[]= {
1369                 {0, "PIXELS", 0, "Pixels", ""},
1370                 {1, "PERCENT", 0, "Percent", ""},
1371                 {0, NULL, 0, NULL, NULL}
1372         };
1373
1374         srna = RNA_def_struct(brna, "TransformSequence", "EffectSequence");
1375         RNA_def_struct_ui_text(srna, "Transform Sequence", "Sequence strip applying affine transformations to other strips");
1376         RNA_def_struct_sdna_from(srna, "TransformVars", "effectdata");
1377         
1378         prop= RNA_def_property(srna, "scale_start_x", PROP_FLOAT, PROP_UNSIGNED);
1379         RNA_def_property_float_sdna(prop, NULL, "ScalexIni");
1380         RNA_def_property_ui_text(prop, "Scale X", "");
1381         RNA_def_property_ui_range(prop, 0, 10, 3, 10);
1382         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1383         
1384         prop= RNA_def_property(srna, "scale_start_y", PROP_FLOAT, PROP_UNSIGNED);
1385         RNA_def_property_float_sdna(prop, NULL, "ScaleyIni");
1386         RNA_def_property_ui_text(prop, "Scale Y", "");
1387         RNA_def_property_ui_range(prop, 0, 10, 3, 10);
1388         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1389         
1390         prop= RNA_def_property(srna, "uniform_scale", PROP_BOOLEAN, PROP_NONE);
1391         RNA_def_property_boolean_sdna(prop, NULL, "uniform_scale", 0);
1392         RNA_def_property_ui_text(prop, "Uniform Scale", "Scale uniformly, preserving aspect ratio");
1393         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1394         
1395         prop= RNA_def_property(srna, "translate_start_x", PROP_FLOAT, PROP_NONE);
1396         RNA_def_property_float_sdna(prop, NULL, "xIni");
1397         RNA_def_property_ui_text(prop, "Translate X", "");
1398         RNA_def_property_ui_range(prop, -500.0f, 500.0f, 3, 10);
1399         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1400         
1401         prop= RNA_def_property(srna, "translate_start_y", PROP_FLOAT, PROP_NONE);
1402         RNA_def_property_float_sdna(prop, NULL, "yIni");
1403         RNA_def_property_ui_text(prop, "Translate Y", "");
1404         RNA_def_property_ui_range(prop, -500.0f, 500.0f, 3, 10);
1405         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1406         
1407         prop= RNA_def_property(srna, "rotation_start", PROP_FLOAT, PROP_NONE);
1408         RNA_def_property_float_sdna(prop, NULL, "rotIni");
1409         RNA_def_property_range(prop, -360.0f, 360.0f);
1410         RNA_def_property_ui_text(prop, "Rotation", "");
1411         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1412         
1413         prop= RNA_def_property(srna, "translation_unit", PROP_ENUM, PROP_NONE);
1414         RNA_def_property_enum_sdna(prop, NULL, "percent");
1415         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); /* not meant to be animated */
1416         RNA_def_property_enum_items(prop, translation_unit_items);
1417         RNA_def_property_ui_text(prop, "Translation Unit", "");
1418         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1419         
1420         prop= RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
1421         RNA_def_property_enum_items(prop, interpolation_items);
1422         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); /* not meant to be animated */
1423         RNA_def_property_ui_text(prop, "Interpolation", "");
1424         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1425 }
1426
1427 static void rna_def_solid_color(BlenderRNA *brna)
1428 {
1429         StructRNA *srna;
1430         PropertyRNA *prop;
1431
1432         srna = RNA_def_struct(brna, "ColorSequence", "EffectSequence");
1433         RNA_def_struct_ui_text(srna, "Color Sequence", "Sequence strip creating an image filled with a single g");
1434         RNA_def_struct_sdna_from(srna, "SolidColorVars", "effectdata");
1435         
1436         prop= RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
1437         RNA_def_property_float_sdna(prop, NULL, "col");
1438         RNA_def_property_ui_text(prop, "Color", "");
1439         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1440 }
1441
1442 static void rna_def_speed_control(BlenderRNA *brna)
1443 {
1444         StructRNA *srna;
1445         PropertyRNA *prop;
1446
1447         srna = RNA_def_struct(brna, "SpeedControlSequence", "EffectSequence");
1448         RNA_def_struct_ui_text(srna, "SpeedControl Sequence", "Sequence strip to control the speed of other strips");
1449         RNA_def_struct_sdna_from(srna, "SpeedControlVars", "effectdata");
1450         
1451         prop= RNA_def_property(srna, "global_speed", PROP_FLOAT, PROP_UNSIGNED);
1452         RNA_def_property_float_sdna(prop, NULL, "globalSpeed");
1453         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); /* seq->facf0 is used to animate this */
1454         RNA_def_property_ui_text(prop, "Global Speed", "");
1455         RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 0);
1456         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1457         
1458         prop= RNA_def_property(srna, "curve_velocity", PROP_BOOLEAN, PROP_NONE);
1459         RNA_def_property_boolean_sdna(prop, NULL, "flags", SEQ_SPEED_INTEGRATE);
1460         RNA_def_property_ui_text(prop, "F-Curve Velocity", "Interpret the F-Curve value as a velocity instead of a frame number");
1461         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1462
1463         prop= RNA_def_property(srna, "frame_blending", PROP_BOOLEAN, PROP_NONE);
1464         RNA_def_property_boolean_sdna(prop, NULL, "flags", SEQ_SPEED_BLEND);
1465         RNA_def_property_ui_text(prop, "Frame Blending", "Blend two frames into the target for a smoother result");
1466         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1467
1468         prop= RNA_def_property(srna, "curve_compress_y", PROP_BOOLEAN, PROP_NONE);
1469         RNA_def_property_boolean_sdna(prop, NULL, "flags", SEQ_SPEED_COMPRESS_IPO_Y);
1470         RNA_def_property_ui_text(prop, "F-Curve Compress Y", "Scale F-Curve value to get the target frame number, F-Curve value runs from 0.0 to 1.0");
1471         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
1472 }
1473
1474 void RNA_def_sequencer(BlenderRNA *brna)
1475 {
1476         rna_def_strip_element(brna);
1477         rna_def_strip_proxy(brna);
1478         rna_def_strip_color_balance(brna);
1479         rna_def_strip_crop(brna);
1480         rna_def_strip_transform(brna);
1481
1482         rna_def_sequence(brna);
1483         rna_def_editor(brna);
1484
1485         rna_def_image(brna);
1486         rna_def_meta(brna);
1487         rna_def_scene(brna);
1488         rna_def_movie(brna);
1489         rna_def_sound(brna);
1490         rna_def_effect(brna);
1491         rna_def_multicam(brna);
1492         rna_def_plugin(brna);
1493         rna_def_wipe(brna);
1494         rna_def_glow(brna);
1495         rna_def_transform(brna);
1496         rna_def_solid_color(brna);
1497         rna_def_speed_control(brna);
1498 }
1499
1500 #endif
1501