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