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