remove warnings
[blender.git] / source / blender / makesrna / intern / rna_sequence.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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, 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_define.h"
29 #include "RNA_types.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_sequence.h"
38
39 #include "MEM_guardedalloc.h"
40
41 #ifdef RNA_RUNTIME
42
43 static int rna_SequenceEditor_name_length(PointerRNA *ptr)
44 {
45         return strlen("Sequence Editor");
46 }
47
48 static void rna_SequenceEditor_name_get(PointerRNA *ptr, char *str)
49 {
50         strcpy(str, "Sequence Editor");
51 }
52
53 static void rna_SequenceEditor_start_frame_set(PointerRNA *ptr, int value)
54 {
55         Sequence *seq= (Sequence*)ptr->data;
56         Scene *sce= (Scene*)ptr->id.data;
57         Editing *ed= seq_give_editing(sce, FALSE);
58         
59         seq->start= value;
60         calc_sequence_disp(seq);
61         
62         if( seq_test_overlap(ed->seqbasep, seq) ) {
63                 shuffle_seq(ed->seqbasep, seq);
64         }
65         sort_seq(sce);
66 }
67
68 static void rna_SequenceEditor_length_set(PointerRNA *ptr, int value)
69 {
70         Sequence *seq= (Sequence*)ptr->data;
71         Scene *sce= (Scene*)ptr->id.data;
72         Editing *ed= seq_give_editing(sce, FALSE);
73         
74         seq_tx_set_final_right(seq, seq->start+value);
75         calc_sequence_disp(seq);
76         
77         if( seq_test_overlap(ed->seqbasep, seq) ) {
78                 shuffle_seq(ed->seqbasep, seq);
79         }
80         sort_seq(sce);
81 }
82
83 static int rna_SequenceEditor_length_get(PointerRNA *ptr)
84 {
85         Sequence *seq= (Sequence*)ptr->data;
86         return seq_tx_get_final_right(seq, 1)-seq_tx_get_final_left(seq, 1);
87 }
88
89 static void rna_SequenceEditor_channel_set(PointerRNA *ptr, int value)
90 {
91         Sequence *seq= (Sequence*)ptr->data;
92         Scene *sce= (Scene*)ptr->id.data;
93         Editing *ed= seq_give_editing(sce, FALSE);
94         
95         seq->machine= value;
96         
97         if( seq_test_overlap(ed->seqbasep, seq) ) {
98                 shuffle_seq(ed->seqbasep, seq);
99         }
100         sort_seq(sce);
101 }
102
103 /* properties that need to allocate structs */
104 static void rna_SequenceEditor_use_color_balance_set(PointerRNA *ptr, int value)
105 {
106         Sequence *seq= (Sequence*)ptr->data;
107         int c;
108         
109         if(value) {
110                 seq->flag |= SEQ_USE_COLOR_BALANCE;
111                 if(seq->strip->color_balance == NULL) {
112                         seq->strip->color_balance = MEM_callocN(sizeof(struct StripColorBalance), "StripColorBalance");
113                         for (c=0; c<3; c++) {
114                                 seq->strip->color_balance->lift[c] = 1.0f;
115                                 seq->strip->color_balance->gamma[c] = 1.0f;
116                                 seq->strip->color_balance->gain[c] = 1.0f;
117                         }
118                 }
119         } else {
120                 seq->flag ^= SEQ_USE_COLOR_BALANCE;
121         }
122 }
123
124 static void rna_SequenceEditor_use_proxy_set(PointerRNA *ptr, int value)
125 {
126         Sequence *seq= (Sequence*)ptr->data;
127         if(value) {
128                 seq->flag |= SEQ_USE_PROXY;
129                 if(seq->strip->proxy == NULL) {
130                         seq->strip->proxy = MEM_callocN(sizeof(struct StripProxy), "StripProxy");
131                 }
132         } else {
133                 seq->flag ^= SEQ_USE_PROXY;
134         }
135 }
136
137 static void rna_SequenceEditor_use_translation_set(PointerRNA *ptr, int value)
138 {
139         Sequence *seq= (Sequence*)ptr->data;
140         if(value) {
141                 seq->flag |= SEQ_USE_TRANSFORM;
142                 if(seq->strip->transform == NULL) {
143                         seq->strip->transform = MEM_callocN(sizeof(struct StripTransform), "StripTransform");
144                 }
145         } else {
146                 seq->flag ^= SEQ_USE_TRANSFORM;
147         }
148 }
149
150 static void rna_SequenceEditor_use_crop_set(PointerRNA *ptr, int value)
151 {
152         Sequence *seq= (Sequence*)ptr->data;
153         if(value) {
154                 seq->flag |= SEQ_USE_CROP;
155                 if(seq->strip->crop == NULL) {
156                         seq->strip->crop = MEM_callocN(sizeof(struct StripCrop), "StripCrop");
157                 }
158         } else {
159                 seq->flag ^= SEQ_USE_CROP;
160         }
161 }
162 /* name functions that ignore the first two characters */
163 static void rna_Sequence_name_get(PointerRNA *ptr, char *value)
164 {
165         Sequence *seq= (Sequence*)ptr->data;
166         BLI_strncpy(value, seq->name+2, sizeof(seq->name)-2);
167 }
168
169 static int rna_Sequence_name_length(PointerRNA *ptr)
170 {
171         Sequence *seq= (Sequence*)ptr->data;
172         return strlen(seq->name+2);
173 }
174
175 static void rna_Sequence_name_set(PointerRNA *ptr, const char *value)
176 {
177         Sequence *seq= (Sequence*)ptr->data;
178         BLI_strncpy(seq->name+2, value, sizeof(seq->name)-2);
179 }
180
181 static StructRNA* rna_Sequence_refine(struct PointerRNA *ptr)
182 {
183         Sequence *seq= (Sequence*)ptr->data;
184
185         switch(seq->type) {
186                 case SEQ_IMAGE:
187                         return &RNA_ImageSequence;
188                 case SEQ_META:
189                         return &RNA_MetaSequence;
190                 case SEQ_SCENE:
191                         return &RNA_SceneSequence;
192                 case SEQ_MOVIE:
193                 case SEQ_MOVIE_AND_HD_SOUND:
194                         return &RNA_MovieSequence;
195                 case SEQ_RAM_SOUND:
196                 case SEQ_HD_SOUND:
197                         return &RNA_SoundSequence;
198                 case SEQ_CROSS:
199                 case SEQ_ADD:
200                 case SEQ_SUB:
201                 case SEQ_ALPHAOVER:
202                 case SEQ_ALPHAUNDER:
203                 case SEQ_GAMCROSS:
204                 case SEQ_MUL:
205                 case SEQ_OVERDROP:
206                         return &RNA_EffectSequence;
207                 case SEQ_PLUGIN:
208                         return &RNA_PluginSequence;
209                 case SEQ_WIPE:
210                         return &RNA_WipeSequence;
211                 case SEQ_GLOW:
212                         return &RNA_GlowSequence;
213                 case SEQ_TRANSFORM:
214                         return &RNA_TransformSequence;
215                 case SEQ_COLOR:
216                         return &RNA_ColorSequence;
217                 case SEQ_SPEED:
218                         return &RNA_SpeedControlSequence;
219                 default:
220                         return &RNA_Sequence;
221         }
222 }
223
224 static PointerRNA rna_SequenceEdtior_meta_stack_get(CollectionPropertyIterator *iter)
225 {
226         ListBaseIterator *internal= iter->internal;
227         MetaStack *ms= (MetaStack*)internal->link;
228
229         return rna_pointer_inherit_refine(&iter->parent, &RNA_Sequence, ms->parseq);
230 }
231
232 #else
233
234 static void rna_def_strip_element(BlenderRNA *brna)
235 {
236         StructRNA *srna;
237         PropertyRNA *prop;
238         
239         srna = RNA_def_struct(brna, "SequenceElement", NULL);
240         RNA_def_struct_ui_text(srna, "Sequence Element", "Sequence strip data for a single frame.");
241         RNA_def_struct_sdna(srna, "StripElem");
242         
243         prop= RNA_def_property(srna, "filename", PROP_STRING, PROP_FILEPATH);
244         RNA_def_property_string_sdna(prop, NULL, "name");
245         RNA_def_property_ui_text(prop, "Filename", "");
246 }
247
248 static void rna_def_strip_crop(BlenderRNA *brna)
249 {
250         StructRNA *srna;
251         PropertyRNA *prop;
252         
253         srna = RNA_def_struct(brna, "SequenceCrop", NULL);
254         RNA_def_struct_ui_text(srna, "Sequence Crop", "Cropping parameters for a sequence strip.");
255         RNA_def_struct_sdna(srna, "StripCrop");
256
257         prop= RNA_def_property(srna, "top", PROP_INT, PROP_UNSIGNED);
258         RNA_def_property_ui_text(prop, "Top", "");
259         RNA_def_property_ui_range(prop, 0, 4096, 1, 0);
260         
261         prop= RNA_def_property(srna, "bottom", PROP_INT, PROP_UNSIGNED);
262         RNA_def_property_ui_text(prop, "Bottom", "");
263         RNA_def_property_ui_range(prop, 0, 4096, 1, 0);
264         
265         prop= RNA_def_property(srna, "left", PROP_INT, PROP_UNSIGNED);
266         RNA_def_property_ui_text(prop, "Left", "");
267         RNA_def_property_ui_range(prop, 0, 4096, 1, 0);
268
269         prop= RNA_def_property(srna, "right", PROP_INT, PROP_UNSIGNED);
270         RNA_def_property_ui_text(prop, "Right", "");
271         RNA_def_property_ui_range(prop, 0, 4096, 1, 0);
272 }
273
274 static void rna_def_strip_transform(BlenderRNA *brna)
275 {
276         StructRNA *srna;
277         PropertyRNA *prop;
278         
279         srna = RNA_def_struct(brna, "SequenceTransform", NULL);
280         RNA_def_struct_ui_text(srna, "Sequence Transform", "Transform parameters for a sequence strip.");
281         RNA_def_struct_sdna(srna, "StripTransform");
282
283         prop= RNA_def_property(srna, "offset_x", PROP_INT, PROP_NONE);
284         RNA_def_property_int_sdna(prop, NULL, "xofs");
285         RNA_def_property_ui_text(prop, "Offset Y", "");
286         RNA_def_property_ui_range(prop, -4096, 4096, 1, 0);
287
288         prop= RNA_def_property(srna, "offset_y", PROP_INT, PROP_NONE);
289         RNA_def_property_int_sdna(prop, NULL, "yofs");
290         RNA_def_property_ui_text(prop, "Offset Y", "");
291         RNA_def_property_ui_range(prop, -4096, 4096, 1, 0);
292 }
293
294 static void rna_def_strip_proxy(BlenderRNA *brna)
295 {
296         StructRNA *srna;
297         PropertyRNA *prop;
298         
299         srna = RNA_def_struct(brna, "SequenceProxy", NULL);
300         RNA_def_struct_ui_text(srna, "Sequence Proxy", "Proxy parameters for a sequence strip.");
301         RNA_def_struct_sdna(srna, "StripProxy");
302         
303         prop= RNA_def_property(srna, "directory", PROP_STRING, PROP_DIRPATH);
304         RNA_def_property_string_sdna(prop, NULL, "dir");
305         RNA_def_property_ui_text(prop, "Directory", "Location to story the proxy file");
306         
307         prop= RNA_def_property(srna, "file", PROP_STRING, PROP_DIRPATH);
308         RNA_def_property_string_sdna(prop, NULL, "file");
309         RNA_def_property_ui_text(prop, "File", "Proxy file name");
310 }
311
312 static void rna_def_strip_color_balance(BlenderRNA *brna)
313 {
314         StructRNA *srna;
315         PropertyRNA *prop;
316
317         srna = RNA_def_struct(brna, "SequenceColorBalance", NULL);
318         RNA_def_struct_ui_text(srna, "Sequence Color Balance", "Color balance parameters for a sequence strip.");
319         RNA_def_struct_sdna(srna, "StripColorBalance");
320
321         prop= RNA_def_property(srna, "lift", PROP_FLOAT, PROP_COLOR);
322         RNA_def_property_ui_text(prop, "Lift", "Color balance lift (shadows).");
323         
324         prop= RNA_def_property(srna, "gamma", PROP_FLOAT, PROP_COLOR);
325         RNA_def_property_ui_text(prop, "Gamma", "Color balance gamma (midtones).");
326         
327         prop= RNA_def_property(srna, "gain", PROP_FLOAT, PROP_COLOR);
328         RNA_def_property_ui_text(prop, "Gain", "Color balance gain (highlights).");
329         
330         prop= RNA_def_property(srna, "inverse_gain", PROP_BOOLEAN, PROP_NONE);
331         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_COLOR_BALANCE_INVERSE_GAIN);
332         RNA_def_property_ui_text(prop, "Inverse Gain", "");
333
334         prop= RNA_def_property(srna, "inverse_gamma", PROP_BOOLEAN, PROP_NONE);
335         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_COLOR_BALANCE_INVERSE_GAMMA);
336         RNA_def_property_ui_text(prop, "Inverse Gamma", "");
337
338         prop= RNA_def_property(srna, "inverse_lift", PROP_BOOLEAN, PROP_NONE);
339         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_COLOR_BALANCE_INVERSE_LIFT);
340         RNA_def_property_ui_text(prop, "Inverse Lift", "");
341         
342         /* not yet used
343         prop= RNA_def_property(srna, "exposure", PROP_FLOAT, PROP_NONE);
344         RNA_def_property_range(prop, 0.0f, 1.0f);
345         RNA_def_property_ui_text(prop, "Exposure", "");
346         
347         prop= RNA_def_property(srna, "saturation", PROP_FLOAT, PROP_NONE);
348         RNA_def_property_range(prop, 0.0f, 1.0f);
349         RNA_def_property_ui_text(prop, "Saturation", "");*/
350 }
351
352 static void rna_def_sequence(BlenderRNA *brna)
353 {
354         StructRNA *srna;
355         PropertyRNA *prop;
356         FunctionRNA *func;
357
358         static const EnumPropertyItem seq_type_items[]= {
359                 {SEQ_IMAGE, "IMAGE", "Image", ""}, 
360                 {SEQ_META, "META", "Meta", ""}, 
361                 {SEQ_SCENE, "SCENE", "Scene", ""}, 
362                 {SEQ_MOVIE, "MOVIE", "Movie", ""}, 
363                 {SEQ_RAM_SOUND, "RAM_SOUND", "Ram Sound", ""}, 
364                 {SEQ_HD_SOUND, "HD_SOUND", "HD Sound", ""}, 
365                 {SEQ_MOVIE_AND_HD_SOUND, "MOVIE_AND_HD_SOUND", "Movie and HD Sound", ""}, 
366                 {SEQ_EFFECT, "REPLACE", "Replace", ""}, 
367                 {SEQ_CROSS, "CROSS", "Cross", ""}, 
368                 {SEQ_ADD, "ADD", "Add", ""}, 
369                 {SEQ_SUB, "SUBTRACT", "Subtract", ""}, 
370                 {SEQ_ALPHAOVER, "ALPHA_OVER", "Alpha Over", ""}, 
371                 {SEQ_ALPHAUNDER, "ALPHA_UNDER", "Alpha Under", ""}, 
372                 {SEQ_GAMCROSS, "GAMMA_CROSS", "Gamma Cross", ""}, 
373                 {SEQ_MUL, "MULTIPLY", "Multiply", ""}, 
374                 {SEQ_OVERDROP, "OVER_DROP", "Over Drop", ""}, 
375                 {SEQ_PLUGIN, "PLUGIN", "plugin", ""}, 
376                 {SEQ_WIPE, "WIPE", "Wipe", ""}, 
377                 {SEQ_GLOW, "GLOW", "Glow", ""}, 
378                 {SEQ_TRANSFORM, "TRANSFORM", "Transform", ""}, 
379                 {SEQ_COLOR, "COLOR", "Color", ""}, 
380                 {SEQ_SPEED, "SPEED", "Speed", ""}, 
381                 {0, NULL, NULL, NULL}};
382
383         static const EnumPropertyItem blend_mode_items[]= {
384                 {SEQ_BLEND_REPLACE, "REPLACE", "Replace", ""}, 
385                 {SEQ_CROSS, "CROSS", "Cross", ""}, 
386                 {SEQ_ADD, "ADD", "Add", ""}, 
387                 {SEQ_SUB, "SUBTRACT", "Subtract", ""}, 
388                 {SEQ_ALPHAOVER, "ALPHA_OVER", "Alpha Over", ""}, 
389                 {SEQ_ALPHAUNDER, "ALPHA_UNDER", "Alpha Under", ""}, 
390                 {SEQ_GAMCROSS, "GAMMA_CROSS", "Gamma Cross", ""}, 
391                 {SEQ_MUL, "MULTIPLY", "Multiply", ""}, 
392                 {SEQ_OVERDROP, "OVER_DROP", "Over Drop", ""}, 
393                 {0, NULL, NULL, NULL}};
394         
395         srna = RNA_def_struct(brna, "Sequence", NULL);
396         RNA_def_struct_ui_text(srna, "Sequence", "Sequence strip in the sequence editor.");
397         RNA_def_struct_refine_func(srna, "rna_Sequence_refine");
398
399         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
400         RNA_def_property_string_funcs(prop, "rna_Sequence_name_get", "rna_Sequence_name_length", "rna_Sequence_name_set");
401         RNA_def_property_string_maxlength(prop, sizeof(((Sequence*)NULL)->name)-2);
402         RNA_def_property_ui_text(prop, "Name", "");
403         RNA_def_struct_name_property(srna, prop);
404
405         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
406         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
407         RNA_def_property_enum_items(prop, seq_type_items);
408         RNA_def_property_ui_text(prop, "Type", "");
409
410         //prop= RNA_def_property(srna, "ipo", PROP_POINTER, PROP_NONE);
411         //RNA_def_property_ui_text(prop, "Ipo Curves", "Ipo curves used by this sequence.");
412
413         /* flags */
414
415         prop= RNA_def_property(srna, "selected", PROP_BOOLEAN, PROP_NONE);
416         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
417         RNA_def_property_ui_text(prop, "Selected", "");
418
419         prop= RNA_def_property(srna, "left_handle_selected", PROP_BOOLEAN, PROP_NONE);
420         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_LEFTSEL);
421         RNA_def_property_ui_text(prop, "Left Handle Selected", "");
422
423         prop= RNA_def_property(srna, "right_handle_selected", PROP_BOOLEAN, PROP_NONE);
424         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_RIGHTSEL);
425         RNA_def_property_ui_text(prop, "Right Handle Selected", "");
426
427         prop= RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
428         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_MUTE);
429         RNA_def_property_ui_text(prop, "Mute", "");
430
431         prop= RNA_def_property(srna, "frame_locked", PROP_BOOLEAN, PROP_NONE);
432         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_IPO_FRAME_LOCKED);
433         RNA_def_property_ui_text(prop, "Frame Locked", "Lock the animation curve to the global frame counter.");
434
435         prop= RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
436         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_LOCK);
437         RNA_def_property_ui_text(prop, "Lock", "Lock strip so that it can't be transformed.");
438
439         /* strip positioning */
440
441         prop= RNA_def_property(srna, "length", PROP_INT, PROP_UNSIGNED);
442         RNA_def_property_int_sdna(prop, NULL, "len");
443         RNA_def_property_range(prop, 1, MAXFRAME);
444         RNA_def_property_ui_text(prop, "Length", "The length of the contents of this strip before the handles are applied");
445         RNA_def_property_int_funcs(prop, "rna_SequenceEditor_length_get", "rna_SequenceEditor_length_set",NULL);
446
447         prop= RNA_def_property(srna, "start_frame", PROP_INT, PROP_UNSIGNED);
448         RNA_def_property_int_sdna(prop, NULL, "start");
449         RNA_def_property_ui_text(prop, "Start Frame", "");
450         RNA_def_property_int_funcs(prop, NULL, "rna_SequenceEditor_start_frame_set",NULL); // overlap tests and calc_seq_disp
451         
452         prop= RNA_def_property(srna, "start_offset", PROP_INT, PROP_UNSIGNED);
453         RNA_def_property_int_sdna(prop, NULL, "startofs");
454         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // overlap tests
455         RNA_def_property_ui_text(prop, "Start Offset", "");
456         
457         prop= RNA_def_property(srna, "end_offset", PROP_INT, PROP_UNSIGNED);
458         RNA_def_property_int_sdna(prop, NULL, "endofs");
459         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // overlap tests
460         RNA_def_property_ui_text(prop, "End offset", "");
461         
462         prop= RNA_def_property(srna, "start_still", PROP_INT, PROP_UNSIGNED);
463         RNA_def_property_int_sdna(prop, NULL, "startstill");
464         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // overlap tests
465         RNA_def_property_range(prop, 0, MAXFRAME);
466         RNA_def_property_ui_text(prop, "Start Still", "");
467         
468         prop= RNA_def_property(srna, "end_still", PROP_INT, PROP_UNSIGNED);
469         RNA_def_property_int_sdna(prop, NULL, "endstill");
470         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // overlap tests
471         RNA_def_property_range(prop, 0, MAXFRAME);
472         RNA_def_property_ui_text(prop, "End Still", "");
473         
474         prop= RNA_def_property(srna, "channel", PROP_INT, PROP_UNSIGNED);
475         RNA_def_property_int_sdna(prop, NULL, "machine");
476         RNA_def_property_ui_text(prop, "Channel", "Y position of the sequence strip.");
477         RNA_def_property_int_funcs(prop, NULL, "rna_SequenceEditor_channel_set",NULL); // overlap test
478
479         /* blending */
480
481         prop= RNA_def_property(srna, "blend_mode", PROP_ENUM, PROP_NONE);
482         RNA_def_property_enum_items(prop, blend_mode_items);
483         RNA_def_property_ui_text(prop, "Blend Mode", "");
484         
485         prop= RNA_def_property(srna, "blend_opacity", PROP_FLOAT, PROP_NONE);
486         RNA_def_property_range(prop, 0.0f, 100.0f);
487         RNA_def_property_ui_text(prop, "Blend Opacity", "");
488         
489         /* funcsions */
490         func= RNA_def_function(srna, "getStripElem", "give_stripelem");
491         RNA_def_function_ui_description(func, "Return the strip element from a given frame or None.");
492         prop= RNA_def_int(func, "frame", 0, INT_MIN, INT_MAX, "Frame", "The frame to get the strip element from", INT_MIN, INT_MAX);
493         RNA_def_property_flag(prop, PROP_REQUIRED);
494         RNA_def_function_return(func, RNA_def_pointer(func, "elem", "SequenceElement", "", "strip element of the current frame"));
495 }
496
497 void rna_def_editor(BlenderRNA *brna)
498 {
499         StructRNA *srna;
500         PropertyRNA *prop;
501         
502         srna = RNA_def_struct(brna, "SequenceEditor", NULL);
503         RNA_def_struct_ui_text(srna, "Sequence Editor", "Sequence editing data for a Scene datablock.");
504         RNA_def_struct_ui_icon(srna, ICON_SEQUENCE);
505         RNA_def_struct_sdna(srna, "Editing");
506
507         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
508         RNA_def_property_string_funcs(prop, "rna_SequenceEditor_name_get", "rna_SequenceEditor_name_length", NULL);
509         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
510         RNA_def_property_ui_text(prop, "Name", "");
511         RNA_def_struct_name_property(srna, prop);
512
513         prop= RNA_def_property(srna, "sequences", PROP_COLLECTION, PROP_NONE);
514         RNA_def_property_collection_sdna(prop, NULL, "seqbase", NULL);
515         RNA_def_property_struct_type(prop, "Sequence");
516         RNA_def_property_ui_text(prop, "Sequences", "");
517
518         prop= RNA_def_property(srna, "meta_stack", PROP_COLLECTION, PROP_NONE);
519         RNA_def_property_collection_sdna(prop, NULL, "metastack", NULL);
520         RNA_def_property_struct_type(prop, "Sequence");
521         RNA_def_property_ui_text(prop, "Meta Stack", "Meta strip stack, last is currently edited meta strip.");
522         RNA_def_property_collection_funcs(prop, 0, 0, 0, "rna_SequenceEdtior_meta_stack_get", 0, 0, 0);
523         
524         prop= RNA_def_property(srna, "active_strip", PROP_POINTER, PROP_NONE);
525         RNA_def_property_pointer_sdna(prop, NULL, "act_seq");
526         RNA_def_property_ui_text(prop, "Active Strip", "Sequencers active strip");
527 }
528
529 static void rna_def_filter_video(StructRNA *srna)
530 {
531         PropertyRNA *prop;
532
533         prop= RNA_def_property(srna, "de_interlace", PROP_BOOLEAN, PROP_NONE);
534         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_FILTERY);
535         RNA_def_property_ui_text(prop, "De-Interlace", "For video movies to remove fields.");
536
537         prop= RNA_def_property(srna, "premultiply", PROP_BOOLEAN, PROP_NONE);
538         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_MAKE_PREMUL);
539         RNA_def_property_ui_text(prop, "Premultiply", "Convert RGB from key alpha to premultiplied alpha.");
540
541         prop= RNA_def_property(srna, "flip_x", PROP_BOOLEAN, PROP_NONE);
542         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_FLIPX);
543         RNA_def_property_ui_text(prop, "Flip X", "Flip on the X axis.");
544
545         prop= RNA_def_property(srna, "flip_y", PROP_BOOLEAN, PROP_NONE);
546         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_FLIPY);
547         RNA_def_property_ui_text(prop, "Flip Y", "Flip on the Y axis.");
548
549         prop= RNA_def_property(srna, "convert_float", PROP_BOOLEAN, PROP_NONE);
550         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_MAKE_FLOAT);
551         RNA_def_property_ui_text(prop, "Convert Float", "Convert input to float data.");
552
553         prop= RNA_def_property(srna, "reverse_frames", PROP_BOOLEAN, PROP_NONE);
554         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_REVERSE_FRAMES);
555         RNA_def_property_ui_text(prop, "Flip Time", "Reverse frame order.");
556
557         prop= RNA_def_property(srna, "multiply_colors", PROP_FLOAT, PROP_UNSIGNED);
558         RNA_def_property_float_sdna(prop, NULL, "mul");
559         RNA_def_property_range(prop, 0.0f, 20.0f);
560         RNA_def_property_ui_text(prop, "Multiply Colors", "");
561
562         prop= RNA_def_property(srna, "strobe", PROP_FLOAT, PROP_NONE);
563         RNA_def_property_range(prop, 1.0f, 30.0f);
564         RNA_def_property_ui_text(prop, "Strobe", "Only display every nth frame.");
565
566         prop= RNA_def_property(srna, "use_color_balance", PROP_BOOLEAN, PROP_NONE);
567         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_COLOR_BALANCE);
568         RNA_def_property_ui_text(prop, "Use Color Balance", "(3-Way color correction) on input.");
569         RNA_def_property_boolean_funcs(prop, NULL, "rna_SequenceEditor_use_color_balance_set");
570
571         prop= RNA_def_property(srna, "color_balance", PROP_POINTER, PROP_NONE);
572         RNA_def_property_pointer_sdna(prop, NULL, "strip->color_balance");
573         RNA_def_property_ui_text(prop, "Color Balance", "");
574
575         prop= RNA_def_property(srna, "use_translation", PROP_BOOLEAN, PROP_NONE);
576         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_TRANSFORM);
577         RNA_def_property_ui_text(prop, "Use Translation", "Translate image before processing.");
578         RNA_def_property_boolean_funcs(prop, NULL, "rna_SequenceEditor_use_translation_set");
579         
580         prop= RNA_def_property(srna, "transform", PROP_POINTER, PROP_NONE);
581         RNA_def_property_pointer_sdna(prop, NULL, "strip->transform");
582         RNA_def_property_ui_text(prop, "Transform", "");
583
584         prop= RNA_def_property(srna, "use_crop", PROP_BOOLEAN, PROP_NONE);
585         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_CROP);
586         RNA_def_property_ui_text(prop, "Use Crop", "Crop image before processing.");
587         RNA_def_property_boolean_funcs(prop, NULL, "rna_SequenceEditor_use_crop_set");
588
589         prop= RNA_def_property(srna, "crop", PROP_POINTER, PROP_NONE);
590         RNA_def_property_pointer_sdna(prop, NULL, "strip->crop");
591         RNA_def_property_ui_text(prop, "Crop", "");
592 }
593
594 static void rna_def_filter_sound(StructRNA *srna)
595 {
596         PropertyRNA *prop;
597
598         prop= RNA_def_property(srna, "sound_gain", PROP_FLOAT, PROP_NONE);
599         RNA_def_property_float_sdna(prop, NULL, "level");
600         RNA_def_property_range(prop, -96.0f, 6.0f);
601         RNA_def_property_ui_text(prop, "Sound Gain", "Sound level in dB (0 = full volume).");
602         
603         prop= RNA_def_property(srna, "sound_pan", PROP_FLOAT, PROP_NONE);
604         RNA_def_property_float_sdna(prop, NULL, "pan");
605         RNA_def_property_range(prop, -1.0f, 1.0f);
606         RNA_def_property_ui_text(prop, "Sound Pan", "Stereo sound balance.");
607 }
608
609 static void rna_def_proxy(StructRNA *srna)
610 {
611         PropertyRNA *prop;
612
613         prop= RNA_def_property(srna, "use_proxy", PROP_BOOLEAN, PROP_NONE);
614         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_PROXY);
615         RNA_def_property_ui_text(prop, "Use Proxy", "Use a preview proxy for this strip.");
616         RNA_def_property_boolean_funcs(prop, NULL, "rna_SequenceEditor_use_proxy_set");
617
618         prop= RNA_def_property(srna, "proxy", PROP_POINTER, PROP_NONE);
619         RNA_def_property_pointer_sdna(prop, NULL, "strip->proxy");
620         RNA_def_property_ui_text(prop, "Proxy", "");
621
622         prop= RNA_def_property(srna, "proxy_custom_directory", PROP_BOOLEAN, PROP_NONE);
623         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_PROXY_CUSTOM_DIR);
624         RNA_def_property_ui_text(prop, "Proxy Custom Directory", "Use a custom directory to store data.");
625 }
626
627 static void rna_def_input(StructRNA *srna)
628 {
629         PropertyRNA *prop;
630
631         prop= RNA_def_property(srna, "animation_start_offset", PROP_INT, PROP_UNSIGNED);
632         RNA_def_property_int_sdna(prop, NULL, "anim_startofs");
633         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // overlap test
634         RNA_def_property_ui_text(prop, "Animation Start Offset", "Animation start offset (trim start).");
635         
636         prop= RNA_def_property(srna, "animation_end_offset", PROP_INT, PROP_UNSIGNED);
637         RNA_def_property_int_sdna(prop, NULL, "anim_endofs");
638         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // overlap test
639         RNA_def_property_ui_text(prop, "Animation End Offset", "Animation end offset (trim end).");
640 }
641
642 static void rna_def_image(BlenderRNA *brna)
643 {
644         StructRNA *srna;
645         PropertyRNA *prop;
646         
647         srna = RNA_def_struct(brna, "ImageSequence", "Sequence");
648         RNA_def_struct_ui_text(srna, "Image Sequence", "Sequence strip to load one or more images.");
649         RNA_def_struct_sdna(srna, "Sequence");
650
651         prop= RNA_def_property(srna, "directory", PROP_STRING, PROP_DIRPATH);
652         RNA_def_property_string_sdna(prop, NULL, "strip->dir");
653         RNA_def_property_ui_text(prop, "Directory", "");
654
655         prop= RNA_def_property(srna, "elements", PROP_COLLECTION, PROP_NONE);
656         RNA_def_property_collection_sdna(prop, NULL, "strip->stripdata", "strip->len");
657         RNA_def_property_struct_type(prop, "SequenceElement");
658         RNA_def_property_ui_text(prop, "Elements", "");
659
660
661         rna_def_filter_video(srna);
662         rna_def_proxy(srna);
663         rna_def_input(srna);
664 }
665
666 static void rna_def_meta(BlenderRNA *brna)
667 {
668         StructRNA *srna;
669         PropertyRNA *prop;
670         
671         srna = RNA_def_struct(brna, "MetaSequence", "Sequence");
672         RNA_def_struct_ui_text(srna, "Meta Sequence", "Sequence strip to group other strips as a single sequence strip.");
673         RNA_def_struct_sdna(srna, "Sequence");
674
675         prop = RNA_def_property(srna, "sequences", PROP_COLLECTION, PROP_NONE);
676         RNA_def_property_collection_sdna(prop, NULL, "seqbase", NULL);
677         RNA_def_property_struct_type(prop, "Sequence");
678         RNA_def_property_ui_text(prop, "Sequences", "");
679
680         rna_def_filter_video(srna);
681         rna_def_proxy(srna);
682         rna_def_input(srna);
683 }
684
685 static void rna_def_scene(BlenderRNA *brna)
686 {
687         StructRNA *srna;
688         PropertyRNA *prop;
689         
690         srna = RNA_def_struct(brna, "SceneSequence", "Sequence");
691         RNA_def_struct_ui_text(srna, "Scene Sequence", "Sequence strip to used the rendered image of a scene.");
692         RNA_def_struct_sdna(srna, "Sequence");
693
694         prop= RNA_def_property(srna, "scene", PROP_POINTER, PROP_NONE);
695         RNA_def_property_ui_text(prop, "Scene", "Scene that this sequence uses.");
696
697         rna_def_filter_video(srna);
698         rna_def_proxy(srna);
699         rna_def_input(srna);
700 }
701
702 static void rna_def_movie(BlenderRNA *brna)
703 {
704         StructRNA *srna;
705         PropertyRNA *prop;
706         
707         srna = RNA_def_struct(brna, "MovieSequence", "Sequence");
708         RNA_def_struct_ui_text(srna, "Movie Sequence", "Sequence strip to load a video.");
709         RNA_def_struct_sdna(srna, "Sequence");
710
711         prop= RNA_def_property(srna, "mpeg_preseek", PROP_INT, PROP_NONE);
712         RNA_def_property_int_sdna(prop, NULL, "anim_preseek");
713         RNA_def_property_range(prop, 0, 50);
714         RNA_def_property_ui_text(prop, "MPEG Preseek", "For MPEG movies, preseek this many frames.");
715
716         prop= RNA_def_property(srna, "filename", PROP_STRING, PROP_FILEPATH);
717         RNA_def_property_string_sdna(prop, NULL, "strip->stripdata->name");
718         RNA_def_property_ui_text(prop, "Filename", "");
719
720         prop= RNA_def_property(srna, "directory", PROP_STRING, PROP_DIRPATH);
721         RNA_def_property_string_sdna(prop, NULL, "strip->dir");
722         RNA_def_property_ui_text(prop, "Directory", "");
723
724         rna_def_filter_video(srna);
725         rna_def_proxy(srna);
726         rna_def_input(srna);
727 }
728
729 static void rna_def_sound(BlenderRNA *brna)
730 {
731         StructRNA *srna;
732         PropertyRNA *prop;
733         
734         srna = RNA_def_struct(brna, "SoundSequence", "Sequence");
735         RNA_def_struct_ui_text(srna, "Sound Sequence", "Sequence strip defining a sound to be played over a period of time.");
736         RNA_def_struct_sdna(srna, "Sequence");
737
738         prop= RNA_def_property(srna, "sound", PROP_POINTER, PROP_NONE);
739         RNA_def_property_struct_type(prop, "UnknownType");
740         RNA_def_property_ui_text(prop, "Sound", "Sound datablock used by this sequence (RAM audio only).");
741
742         prop= RNA_def_property(srna, "filename", PROP_STRING, PROP_FILEPATH);
743         RNA_def_property_string_sdna(prop, NULL, "strip->stripdata->name");
744         RNA_def_property_ui_text(prop, "Filename", "");
745
746         prop= RNA_def_property(srna, "directory", PROP_STRING, PROP_DIRPATH);
747         RNA_def_property_string_sdna(prop, NULL, "strip->dir");
748         RNA_def_property_ui_text(prop, "Directory", "");
749
750         rna_def_filter_sound(srna);
751         rna_def_input(srna);
752 }
753
754 static void rna_def_effect(BlenderRNA *brna)
755 {
756         StructRNA *srna;
757
758         srna = RNA_def_struct(brna, "EffectSequence", "Sequence");
759         RNA_def_struct_ui_text(srna, "Effect Sequence", "Sequence strip applying an effect on the images created by other strips.");
760         RNA_def_struct_sdna(srna, "Sequence");
761
762         rna_def_proxy(srna);
763 }
764
765 static void rna_def_plugin(BlenderRNA *brna)
766 {
767         StructRNA *srna;
768         PropertyRNA *prop;
769         
770         srna = RNA_def_struct(brna, "PluginSequence", "EffectSequence");
771         RNA_def_struct_ui_text(srna, "Plugin Sequence", "Sequence strip applying an effect, loaded from an external plugin.");
772         RNA_def_struct_sdna_from(srna, "PluginSeq", "plugin");
773
774         prop= RNA_def_property(srna, "filename", PROP_STRING, PROP_FILEPATH);
775         RNA_def_property_string_sdna(prop, NULL, "name");
776         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
777         RNA_def_property_ui_text(prop, "Filename", "");
778         
779         /* plugin properties need custom wrapping code like ID properties */
780 }
781
782 static void rna_def_wipe(BlenderRNA *brna)
783 {
784         StructRNA *srna;
785         PropertyRNA *prop;
786         
787         static const EnumPropertyItem wipe_type_items[]= {
788                 {0, "SINGLE", "Single", ""}, 
789                 {1, "DOUBLE", "Double", ""}, 
790                 /* not used yet {2, "BOX", "Box", ""}, */
791                 /* not used yet {3, "CROSS", "Cross", ""}, */
792                 {4, "IRIS", "Iris", ""}, 
793                 {5, "CLOCK", "Clock", ""},      
794                 {0, NULL, NULL, NULL}
795         };
796
797         static const EnumPropertyItem wipe_direction_items[]= {
798                 {0, "OUT", "Out", ""},
799                 {1, "IN", "In", ""},
800                 {0, NULL, NULL, NULL}
801         };
802
803         srna = RNA_def_struct(brna, "WipeSequence", "EffectSequence");
804         RNA_def_struct_ui_text(srna, "Wipe Sequence", "Sequence strip creating a wipe transition.");
805         RNA_def_struct_sdna_from(srna, "WipeVars", "effectdata");
806
807         prop= RNA_def_property(srna, "blur_width", PROP_FLOAT, PROP_UNSIGNED);
808         RNA_def_property_float_sdna(prop, NULL, "edgeWidth");
809         RNA_def_property_range(prop, 0.0f, 1.0f);
810         RNA_def_property_ui_text(prop, "Blur Width", "Width of the blur edge, in percentage relative to the image size.");
811         
812         prop= RNA_def_property(srna, "angle", PROP_FLOAT, PROP_NONE);
813         RNA_def_property_float_sdna(prop, NULL, "angle");
814         RNA_def_property_range(prop, -90.0f, 90.0f);
815         RNA_def_property_ui_text(prop, "Angle", "Edge angle.");
816         
817         prop= RNA_def_property(srna, "direction", PROP_ENUM, PROP_NONE);
818         RNA_def_property_enum_sdna(prop, NULL, "forward");
819         RNA_def_property_enum_items(prop, wipe_direction_items);
820         RNA_def_property_ui_text(prop, "Direction", "Wipe direction.");
821         
822         prop= RNA_def_property(srna, "transition_type", PROP_ENUM, PROP_NONE);
823         RNA_def_property_enum_sdna(prop, NULL, "wipetype");
824         RNA_def_property_enum_items(prop, wipe_type_items);
825         RNA_def_property_ui_text(prop, "Transition Type", "");
826 }
827
828 static void rna_def_glow(BlenderRNA *brna)
829 {
830         StructRNA *srna;
831         PropertyRNA *prop;
832         
833         srna = RNA_def_struct(brna, "GlowSequence", "EffectSequence");
834         RNA_def_struct_ui_text(srna, "Glow Sequence", "Sequence strip creating a glow effect.");
835         RNA_def_struct_sdna_from(srna, "GlowVars", "effectdata");
836         
837         prop= RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_NONE);
838         RNA_def_property_float_sdna(prop, NULL, "fMini");
839         RNA_def_property_range(prop, 0.0f, 1.0f);
840         RNA_def_property_ui_text(prop, "Threshold", "Minimum intensity to trigger a glow");
841         
842         prop= RNA_def_property(srna, "clamp", PROP_FLOAT, PROP_NONE);
843         RNA_def_property_float_sdna(prop, NULL, "fClamp");
844         RNA_def_property_range(prop, 0.0f, 1.0f);
845         RNA_def_property_ui_text(prop, "Clamp", "rightness limit of intensity.");
846         
847         prop= RNA_def_property(srna, "boost_factor", PROP_FLOAT, PROP_NONE);
848         RNA_def_property_float_sdna(prop, NULL, "fBoost");
849         RNA_def_property_range(prop, 0.0f, 10.0f);
850         RNA_def_property_ui_text(prop, "Boost Factor", "Brightness multiplier.");
851         
852         prop= RNA_def_property(srna, "blur_distance", PROP_FLOAT, PROP_NONE);
853         RNA_def_property_float_sdna(prop, NULL, "dDist");
854         RNA_def_property_range(prop, 0.5f, 20.0f);
855         RNA_def_property_ui_text(prop, "Blur Distance", "Radius of glow effect.");
856         
857         prop= RNA_def_property(srna, "quality", PROP_INT, PROP_NONE);
858         RNA_def_property_int_sdna(prop, NULL, "dQuality");
859         RNA_def_property_range(prop, 1, 5);
860         RNA_def_property_ui_text(prop, "Quality", "Accuracy of the blur effect.");
861         
862         prop= RNA_def_property(srna, "only_boost", PROP_BOOLEAN, PROP_NONE);
863         RNA_def_property_boolean_sdna(prop, NULL, "bNoComp", 0);
864         RNA_def_property_ui_text(prop, "Only Boost", "Show the glow buffer only.");
865 }
866
867 static void rna_def_transform(BlenderRNA *brna)
868 {
869         StructRNA *srna;
870         PropertyRNA *prop;
871
872         static const EnumPropertyItem interpolation_items[]= {
873                 {0, "NONE", "None", "No interpolation."},
874                 {1, "BILINEAR", "Bilinear", "Bilinear interpolation."},
875                 {2, "BICUBIC", "Bicubic", "Bicubic interpolation."},
876                 {0, NULL, NULL, NULL}
877         };
878
879         static const EnumPropertyItem translation_unit_items[]= {
880                 {0, "PIXELS", "Pixels", ""},
881                 {1, "PERCENT", "Percent", ""},
882                 {0, NULL, NULL, NULL}
883         };
884
885         srna = RNA_def_struct(brna, "TransformSequence", "EffectSequence");
886         RNA_def_struct_ui_text(srna, "Transform Sequence", "Sequence strip applying affine transformations to other strips.");
887         RNA_def_struct_sdna_from(srna, "TransformVars", "effectdata");
888         
889         prop= RNA_def_property(srna, "scale_start_x", PROP_FLOAT, PROP_UNSIGNED);
890         RNA_def_property_float_sdna(prop, NULL, "ScalexIni");
891         RNA_def_property_ui_text(prop, "Scale Start X", "");
892         RNA_def_property_ui_range(prop, 0, 10, 3, 10);
893         
894         prop= RNA_def_property(srna, "scale_start_y", PROP_FLOAT, PROP_UNSIGNED);
895         RNA_def_property_float_sdna(prop, NULL, "ScaleyIni");
896         RNA_def_property_ui_text(prop, "Scale Start Y", "");
897         RNA_def_property_ui_range(prop, 0, 10, 3, 10);
898
899         prop= RNA_def_property(srna, "scale_end_x", PROP_FLOAT, PROP_UNSIGNED);
900         RNA_def_property_float_sdna(prop, NULL, "ScalexFin");
901         RNA_def_property_ui_text(prop, "Scale End X", "");
902         RNA_def_property_ui_range(prop, 0, 10, 3, 10);
903         
904         prop= RNA_def_property(srna, "scale_end_y", PROP_FLOAT, PROP_UNSIGNED);
905         RNA_def_property_float_sdna(prop, NULL, "ScaleyFin");
906         RNA_def_property_ui_text(prop, "Scale End Y", "");
907         RNA_def_property_ui_range(prop, 0, 10, 3, 10);
908         
909         prop= RNA_def_property(srna, "translate_start_x", PROP_FLOAT, PROP_NONE);
910         RNA_def_property_float_sdna(prop, NULL, "xIni");
911         RNA_def_property_ui_text(prop, "Translate Start X", "");
912         RNA_def_property_ui_range(prop, -500.0f, 500.0f, 3, 10);
913
914         prop= RNA_def_property(srna, "translate_start_y", PROP_FLOAT, PROP_NONE);
915         RNA_def_property_float_sdna(prop, NULL, "yIni");
916         RNA_def_property_ui_text(prop, "Translate Start Y", "");
917         RNA_def_property_ui_range(prop, -500.0f, 500.0f, 3, 10);
918
919         prop= RNA_def_property(srna, "translate_end_x", PROP_FLOAT, PROP_NONE);
920         RNA_def_property_float_sdna(prop, NULL, "xFin");
921         RNA_def_property_ui_text(prop, "Translate End X", "");
922         RNA_def_property_ui_range(prop, -500.0f, 500.0f, 3, 10);
923
924         prop= RNA_def_property(srna, "translate_end_y", PROP_FLOAT, PROP_NONE);
925         RNA_def_property_float_sdna(prop, NULL, "yFin");
926         RNA_def_property_ui_text(prop, "Translate End Y", "");
927         RNA_def_property_ui_range(prop, -500.0f, 500.0f, 3, 10);
928         
929         prop= RNA_def_property(srna, "rotation_start", PROP_FLOAT, PROP_NONE);
930         RNA_def_property_float_sdna(prop, NULL, "rotIni");
931         RNA_def_property_range(prop, 0.0f, 360.0f);
932         RNA_def_property_ui_text(prop, "Rotation Start", "");
933         
934         prop= RNA_def_property(srna, "rotation_end", PROP_FLOAT, PROP_NONE);
935         RNA_def_property_float_sdna(prop, NULL, "rotFin");
936         RNA_def_property_range(prop, 0.0f, 360.0f);
937         RNA_def_property_ui_text(prop, "Rotation End", "");
938         
939         prop= RNA_def_property(srna, "translation_unit", PROP_ENUM, PROP_NONE);
940         RNA_def_property_enum_sdna(prop, NULL, "percent");
941         RNA_def_property_enum_items(prop, translation_unit_items);
942         RNA_def_property_ui_text(prop, "Translation Unit", "");
943         
944         prop= RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
945         RNA_def_property_enum_items(prop, interpolation_items);
946         RNA_def_property_ui_text(prop, "Interpolation", "");
947 }
948
949 static void rna_def_solid_color(BlenderRNA *brna)
950 {
951         StructRNA *srna;
952         PropertyRNA *prop;
953         
954         srna = RNA_def_struct(brna, "ColorSequence", "EffectSequence");
955         RNA_def_struct_ui_text(srna, "Color Sequence", "Sequence strip creating an image filled with a single color.");
956         RNA_def_struct_sdna_from(srna, "SolidColorVars", "effectdata");
957         
958         prop= RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
959         RNA_def_property_float_sdna(prop, NULL, "col");
960         RNA_def_property_ui_text(prop, "Color", "");
961 }
962
963 static void rna_def_speed_control(BlenderRNA *brna)
964 {
965         StructRNA *srna;
966         PropertyRNA *prop;
967
968         srna = RNA_def_struct(brna, "SpeedControlSequence", "EffectSequence");
969         RNA_def_struct_ui_text(srna, "SpeedControl Sequence", "Sequence strip to control the speed of other strips.");
970         RNA_def_struct_sdna_from(srna, "SpeedControlVars", "effectdata");
971         
972         prop= RNA_def_property(srna, "global_speed", PROP_FLOAT, PROP_UNSIGNED);
973         RNA_def_property_float_sdna(prop, NULL, "globalSpeed");
974         RNA_def_property_ui_text(prop, "Global Speed", "");
975         RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 0);
976         
977         prop= RNA_def_property(srna, "curve_velocity", PROP_BOOLEAN, PROP_NONE);
978         RNA_def_property_boolean_sdna(prop, NULL, "flags", SEQ_SPEED_INTEGRATE);
979         RNA_def_property_ui_text(prop, "F-Curve Velocity", "Interpret the F-Curve value as a velocity instead of a frame number.");
980
981         prop= RNA_def_property(srna, "frame_blending", PROP_BOOLEAN, PROP_NONE);
982         RNA_def_property_boolean_sdna(prop, NULL, "flags", SEQ_SPEED_BLEND);
983         RNA_def_property_ui_text(prop, "Frame Blending", "Blend two frames into the target for a smoother result.");
984
985         prop= RNA_def_property(srna, "curve_compress_y", PROP_BOOLEAN, PROP_NONE);
986         RNA_def_property_boolean_sdna(prop, NULL, "flags", SEQ_SPEED_COMPRESS_IPO_Y);
987         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.");
988 }
989
990 void RNA_def_sequence(BlenderRNA *brna)
991 {
992         rna_def_strip_element(brna);
993         rna_def_strip_proxy(brna);
994         rna_def_strip_color_balance(brna);
995         rna_def_strip_crop(brna);
996         rna_def_strip_transform(brna);
997
998         rna_def_sequence(brna);
999         rna_def_editor(brna);
1000
1001         rna_def_image(brna);
1002         rna_def_meta(brna);
1003         rna_def_scene(brna);
1004         rna_def_movie(brna);
1005         rna_def_sound(brna);
1006         rna_def_effect(brna);
1007         rna_def_plugin(brna);
1008         rna_def_wipe(brna);
1009         rna_def_glow(brna);
1010         rna_def_transform(brna);
1011         rna_def_solid_color(brna);
1012         rna_def_speed_control(brna);
1013 }
1014
1015 #endif
1016