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