b1ac02ae17fda3ff8a08847b232e2f623bd6d9ec
[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 char *rna_Sequence_path(PointerRNA *ptr)
225 {
226         Sequence *seq= (Sequence*)ptr->data;
227         
228         /* sequencer data comes from scene... 
229          * TODO: would be nice to make SequenceEditor data a datablock of its own (for shorter paths)
230          */
231         return BLI_sprintfN("sequence_editor.sequences[\"%s\"]", seq->name+2);
232 }
233
234 static PointerRNA rna_SequenceEdtior_meta_stack_get(CollectionPropertyIterator *iter)
235 {
236         ListBaseIterator *internal= iter->internal;
237         MetaStack *ms= (MetaStack*)internal->link;
238
239         return rna_pointer_inherit_refine(&iter->parent, &RNA_Sequence, ms->parseq);
240 }
241
242 static void rna_MovieSequence_filename_set(PointerRNA *ptr, const char *value)
243 {
244         Sequence *seq= (Sequence*)(ptr->data);
245         char dir[FILE_MAX], name[FILE_MAX];
246
247         BLI_split_dirfile_basic(value, dir, name);
248         BLI_strncpy(seq->strip->dir, dir, sizeof(seq->strip->dir));
249         BLI_strncpy(seq->strip->stripdata->name, name, sizeof(seq->strip->stripdata->name));
250 }
251
252 static void rna_SoundSequence_filename_set(PointerRNA *ptr, const char *value)
253 {
254         Sequence *seq= (Sequence*)(ptr->data);
255         char dir[FILE_MAX], name[FILE_MAX];
256
257         BLI_split_dirfile_basic(value, dir, name);
258         BLI_strncpy(seq->strip->dir, dir, sizeof(seq->strip->dir));
259         BLI_strncpy(seq->strip->stripdata->name, name, sizeof(seq->strip->stripdata->name));
260 }
261
262 static void rna_SequenceElement_filename_set(PointerRNA *ptr, const char *value)
263 {
264         StripElem *elem= (StripElem*)(ptr->data);
265         char name[FILE_MAX];
266
267         BLI_split_dirfile_basic(value, NULL, name);
268         BLI_strncpy(elem->name, name, sizeof(elem->name));
269 }
270
271 #else
272
273 static void rna_def_strip_element(BlenderRNA *brna)
274 {
275         StructRNA *srna;
276         PropertyRNA *prop;
277         
278         srna = RNA_def_struct(brna, "SequenceElement", NULL);
279         RNA_def_struct_ui_text(srna, "Sequence Element", "Sequence strip data for a single frame.");
280         RNA_def_struct_sdna(srna, "StripElem");
281         
282         prop= RNA_def_property(srna, "filename", PROP_STRING, PROP_FILEPATH);
283         RNA_def_property_string_sdna(prop, NULL, "name");
284         RNA_def_property_ui_text(prop, "Filename", "");
285         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_SequenceElement_filename_set");
286 }
287
288 static void rna_def_strip_crop(BlenderRNA *brna)
289 {
290         StructRNA *srna;
291         PropertyRNA *prop;
292         
293         srna = RNA_def_struct(brna, "SequenceCrop", NULL);
294         RNA_def_struct_ui_text(srna, "Sequence Crop", "Cropping parameters for a sequence strip.");
295         RNA_def_struct_sdna(srna, "StripCrop");
296
297         prop= RNA_def_property(srna, "top", PROP_INT, PROP_UNSIGNED);
298         RNA_def_property_ui_text(prop, "Top", "");
299         RNA_def_property_ui_range(prop, 0, 4096, 1, 0);
300         
301         prop= RNA_def_property(srna, "bottom", PROP_INT, PROP_UNSIGNED);
302         RNA_def_property_ui_text(prop, "Bottom", "");
303         RNA_def_property_ui_range(prop, 0, 4096, 1, 0);
304         
305         prop= RNA_def_property(srna, "left", PROP_INT, PROP_UNSIGNED);
306         RNA_def_property_ui_text(prop, "Left", "");
307         RNA_def_property_ui_range(prop, 0, 4096, 1, 0);
308
309         prop= RNA_def_property(srna, "right", PROP_INT, PROP_UNSIGNED);
310         RNA_def_property_ui_text(prop, "Right", "");
311         RNA_def_property_ui_range(prop, 0, 4096, 1, 0);
312 }
313
314 static void rna_def_strip_transform(BlenderRNA *brna)
315 {
316         StructRNA *srna;
317         PropertyRNA *prop;
318         
319         srna = RNA_def_struct(brna, "SequenceTransform", NULL);
320         RNA_def_struct_ui_text(srna, "Sequence Transform", "Transform parameters for a sequence strip.");
321         RNA_def_struct_sdna(srna, "StripTransform");
322
323         prop= RNA_def_property(srna, "offset_x", PROP_INT, PROP_NONE);
324         RNA_def_property_int_sdna(prop, NULL, "xofs");
325         RNA_def_property_ui_text(prop, "Offset Y", "");
326         RNA_def_property_ui_range(prop, -4096, 4096, 1, 0);
327
328         prop= RNA_def_property(srna, "offset_y", PROP_INT, PROP_NONE);
329         RNA_def_property_int_sdna(prop, NULL, "yofs");
330         RNA_def_property_ui_text(prop, "Offset Y", "");
331         RNA_def_property_ui_range(prop, -4096, 4096, 1, 0);
332 }
333
334 static void rna_def_strip_proxy(BlenderRNA *brna)
335 {
336         StructRNA *srna;
337         PropertyRNA *prop;
338         
339         srna = RNA_def_struct(brna, "SequenceProxy", NULL);
340         RNA_def_struct_ui_text(srna, "Sequence Proxy", "Proxy parameters for a sequence strip.");
341         RNA_def_struct_sdna(srna, "StripProxy");
342         
343         prop= RNA_def_property(srna, "directory", PROP_STRING, PROP_DIRPATH);
344         RNA_def_property_string_sdna(prop, NULL, "dir");
345         RNA_def_property_ui_text(prop, "Directory", "Location to story the proxy file");
346         
347         prop= RNA_def_property(srna, "file", PROP_STRING, PROP_DIRPATH);
348         RNA_def_property_string_sdna(prop, NULL, "file");
349         RNA_def_property_ui_text(prop, "File", "Proxy file name");
350 }
351
352 static void rna_def_strip_color_balance(BlenderRNA *brna)
353 {
354         StructRNA *srna;
355         PropertyRNA *prop;
356
357         srna = RNA_def_struct(brna, "SequenceColorBalance", NULL);
358         RNA_def_struct_ui_text(srna, "Sequence Color Balance", "Color balance parameters for a sequence strip.");
359         RNA_def_struct_sdna(srna, "StripColorBalance");
360
361         prop= RNA_def_property(srna, "lift", PROP_FLOAT, PROP_COLOR);
362         RNA_def_property_ui_text(prop, "Lift", "Color balance lift (shadows).");
363         
364         prop= RNA_def_property(srna, "gamma", PROP_FLOAT, PROP_COLOR);
365         RNA_def_property_ui_text(prop, "Gamma", "Color balance gamma (midtones).");
366         
367         prop= RNA_def_property(srna, "gain", PROP_FLOAT, PROP_COLOR);
368         RNA_def_property_ui_text(prop, "Gain", "Color balance gain (highlights).");
369         
370         prop= RNA_def_property(srna, "inverse_gain", PROP_BOOLEAN, PROP_NONE);
371         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_COLOR_BALANCE_INVERSE_GAIN);
372         RNA_def_property_ui_text(prop, "Inverse Gain", "");
373
374         prop= RNA_def_property(srna, "inverse_gamma", PROP_BOOLEAN, PROP_NONE);
375         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_COLOR_BALANCE_INVERSE_GAMMA);
376         RNA_def_property_ui_text(prop, "Inverse Gamma", "");
377
378         prop= RNA_def_property(srna, "inverse_lift", PROP_BOOLEAN, PROP_NONE);
379         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_COLOR_BALANCE_INVERSE_LIFT);
380         RNA_def_property_ui_text(prop, "Inverse Lift", "");
381         
382         /* not yet used
383         prop= RNA_def_property(srna, "exposure", PROP_FLOAT, PROP_NONE);
384         RNA_def_property_range(prop, 0.0f, 1.0f);
385         RNA_def_property_ui_text(prop, "Exposure", "");
386         
387         prop= RNA_def_property(srna, "saturation", PROP_FLOAT, PROP_NONE);
388         RNA_def_property_range(prop, 0.0f, 1.0f);
389         RNA_def_property_ui_text(prop, "Saturation", "");*/
390 }
391
392 static void rna_def_sequence(BlenderRNA *brna)
393 {
394         StructRNA *srna;
395         PropertyRNA *prop;
396         FunctionRNA *func;
397
398         static const EnumPropertyItem seq_type_items[]= {
399                 {SEQ_IMAGE, "IMAGE", 0, "Image", ""}, 
400                 {SEQ_META, "META", 0, "Meta", ""}, 
401                 {SEQ_SCENE, "SCENE", 0, "Scene", ""}, 
402                 {SEQ_MOVIE, "MOVIE", 0, "Movie", ""}, 
403                 {SEQ_SOUND, "SOUND", 0, "Sound", ""},
404                 {SEQ_EFFECT, "REPLACE", 0, "Replace", ""}, 
405                 {SEQ_CROSS, "CROSS", 0, "Cross", ""}, 
406                 {SEQ_ADD, "ADD", 0, "Add", ""}, 
407                 {SEQ_SUB, "SUBTRACT", 0, "Subtract", ""}, 
408                 {SEQ_ALPHAOVER, "ALPHA_OVER", 0, "Alpha Over", ""}, 
409                 {SEQ_ALPHAUNDER, "ALPHA_UNDER", 0, "Alpha Under", ""}, 
410                 {SEQ_GAMCROSS, "GAMMA_CROSS", 0, "Gamma Cross", ""}, 
411                 {SEQ_MUL, "MULTIPLY", 0, "Multiply", ""}, 
412                 {SEQ_OVERDROP, "OVER_DROP", 0, "Over Drop", ""}, 
413                 {SEQ_PLUGIN, "PLUGIN", 0, "plugin", ""}, 
414                 {SEQ_WIPE, "WIPE", 0, "Wipe", ""}, 
415                 {SEQ_GLOW, "GLOW", 0, "Glow", ""}, 
416                 {SEQ_TRANSFORM, "TRANSFORM", 0, "Transform", ""}, 
417                 {SEQ_COLOR, "COLOR", 0, "Color", ""}, 
418                 {SEQ_SPEED, "SPEED", 0, "Speed", ""}, 
419                 {0, NULL, 0, NULL, NULL}};
420
421         static const EnumPropertyItem blend_mode_items[]= {
422                 {SEQ_BLEND_REPLACE, "REPLACE", 0, "Replace", ""}, 
423                 {SEQ_CROSS, "CROSS", 0, "Cross", ""}, 
424                 {SEQ_ADD, "ADD", 0, "Add", ""}, 
425                 {SEQ_SUB, "SUBTRACT", 0, "Subtract", ""}, 
426                 {SEQ_ALPHAOVER, "ALPHA_OVER", 0, "Alpha Over", ""}, 
427                 {SEQ_ALPHAUNDER, "ALPHA_UNDER", 0, "Alpha Under", ""}, 
428                 {SEQ_GAMCROSS, "GAMMA_CROSS", 0, "Gamma Cross", ""}, 
429                 {SEQ_MUL, "MULTIPLY", 0, "Multiply", ""}, 
430                 {SEQ_OVERDROP, "OVER_DROP", 0, "Over Drop", ""}, 
431                 {0, NULL, 0, NULL, NULL}};
432         
433         srna = RNA_def_struct(brna, "Sequence", NULL);
434         RNA_def_struct_ui_text(srna, "Sequence", "Sequence strip in the sequence editor.");
435         RNA_def_struct_refine_func(srna, "rna_Sequence_refine");
436         RNA_def_struct_path_func(srna, "rna_Sequence_path");
437
438         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
439         RNA_def_property_string_funcs(prop, "rna_Sequence_name_get", "rna_Sequence_name_length", "rna_Sequence_name_set");
440         RNA_def_property_string_maxlength(prop, sizeof(((Sequence*)NULL)->name)-2);
441         RNA_def_property_ui_text(prop, "Name", "");
442         RNA_def_struct_name_property(srna, prop);
443
444         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
445         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
446         RNA_def_property_enum_items(prop, seq_type_items);
447         RNA_def_property_ui_text(prop, "Type", "");
448
449         //prop= RNA_def_property(srna, "ipo", PROP_POINTER, PROP_NONE);
450         //RNA_def_property_ui_text(prop, "Ipo Curves", "Ipo curves used by this sequence.");
451
452         /* flags */
453
454         prop= RNA_def_property(srna, "selected", PROP_BOOLEAN, PROP_NONE);
455         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
456         RNA_def_property_ui_text(prop, "Selected", "");
457
458         prop= RNA_def_property(srna, "left_handle_selected", PROP_BOOLEAN, PROP_NONE);
459         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_LEFTSEL);
460         RNA_def_property_ui_text(prop, "Left Handle Selected", "");
461
462         prop= RNA_def_property(srna, "right_handle_selected", PROP_BOOLEAN, PROP_NONE);
463         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_RIGHTSEL);
464         RNA_def_property_ui_text(prop, "Right Handle Selected", "");
465
466         prop= RNA_def_property(srna, "mute", PROP_BOOLEAN, PROP_NONE);
467         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_MUTE);
468         RNA_def_property_ui_text(prop, "Mute", "");
469         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
470
471         prop= RNA_def_property(srna, "frame_locked", PROP_BOOLEAN, PROP_NONE);
472         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_IPO_FRAME_LOCKED);
473         RNA_def_property_ui_text(prop, "Frame Locked", "Lock the animation curve to the global frame counter.");
474         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
475
476         prop= RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
477         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_LOCK);
478         RNA_def_property_ui_text(prop, "Lock", "Lock strip so that it can't be transformed.");
479
480         /* strip positioning */
481
482         prop= RNA_def_property(srna, "length", PROP_INT, PROP_TIME);
483         RNA_def_property_int_sdna(prop, NULL, "len");
484         RNA_def_property_range(prop, 1, MAXFRAME);
485         RNA_def_property_ui_text(prop, "Length", "The length of the contents of this strip before the handles are applied");
486         RNA_def_property_int_funcs(prop, "rna_SequenceEditor_length_get", "rna_SequenceEditor_length_set",NULL);
487         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
488         
489         prop= RNA_def_property(srna, "start_frame", PROP_INT, PROP_TIME);
490         RNA_def_property_int_sdna(prop, NULL, "start");
491         RNA_def_property_ui_text(prop, "Start Frame", "");
492         RNA_def_property_int_funcs(prop, NULL, "rna_SequenceEditor_start_frame_set",NULL); // overlap tests and calc_seq_disp
493         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
494         
495         prop= RNA_def_property(srna, "start_offset", PROP_INT, PROP_TIME);
496         RNA_def_property_int_sdna(prop, NULL, "startofs");
497         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // overlap tests
498         RNA_def_property_ui_text(prop, "Start Offset", "");
499         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
500         
501         prop= RNA_def_property(srna, "end_offset", PROP_INT, PROP_TIME);
502         RNA_def_property_int_sdna(prop, NULL, "endofs");
503         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // overlap tests
504         RNA_def_property_ui_text(prop, "End offset", "");
505         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
506         
507         prop= RNA_def_property(srna, "start_still", PROP_INT, PROP_TIME);
508         RNA_def_property_int_sdna(prop, NULL, "startstill");
509         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // overlap tests
510         RNA_def_property_range(prop, 0, MAXFRAME);
511         RNA_def_property_ui_text(prop, "Start Still", "");
512         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
513         
514         prop= RNA_def_property(srna, "end_still", PROP_INT, PROP_TIME);
515         RNA_def_property_int_sdna(prop, NULL, "endstill");
516         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // overlap tests
517         RNA_def_property_range(prop, 0, MAXFRAME);
518         RNA_def_property_ui_text(prop, "End Still", "");
519         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
520         
521         prop= RNA_def_property(srna, "channel", PROP_INT, PROP_UNSIGNED);
522         RNA_def_property_int_sdna(prop, NULL, "machine");
523         RNA_def_property_ui_text(prop, "Channel", "Y position of the sequence strip.");
524         RNA_def_property_int_funcs(prop, NULL, "rna_SequenceEditor_channel_set",NULL); // overlap test
525         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
526
527         /* blending */
528
529         prop= RNA_def_property(srna, "blend_mode", PROP_ENUM, PROP_NONE);
530         RNA_def_property_enum_items(prop, blend_mode_items);
531         RNA_def_property_ui_text(prop, "Blend Mode", "");
532         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
533         
534         prop= RNA_def_property(srna, "blend_opacity", PROP_FLOAT, PROP_NONE);
535         RNA_def_property_range(prop, 0.0f, 100.0f);
536         RNA_def_property_ui_text(prop, "Blend Opacity", "");
537         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
538         
539         /* functions */
540         func= RNA_def_function(srna, "getStripElem", "give_stripelem");
541         RNA_def_function_ui_description(func, "Return the strip element from a given frame or None.");
542         prop= RNA_def_int(func, "frame", 0, INT_MIN, INT_MAX, "Frame", "The frame to get the strip element from", INT_MIN, INT_MAX);
543         RNA_def_property_flag(prop, PROP_REQUIRED);
544         RNA_def_function_return(func, RNA_def_pointer(func, "elem", "SequenceElement", "", "strip element of the current frame"));
545 }
546
547 static void rna_def_editor(BlenderRNA *brna)
548 {
549         StructRNA *srna;
550         PropertyRNA *prop;
551         
552         srna = RNA_def_struct(brna, "SequenceEditor", NULL);
553         RNA_def_struct_ui_text(srna, "Sequence Editor", "Sequence editing data for a Scene datablock.");
554         RNA_def_struct_ui_icon(srna, ICON_SEQUENCE);
555         RNA_def_struct_sdna(srna, "Editing");
556
557         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
558         RNA_def_property_string_funcs(prop, "rna_SequenceEditor_name_get", "rna_SequenceEditor_name_length", NULL);
559         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
560         RNA_def_property_ui_text(prop, "Name", "");
561         RNA_def_struct_name_property(srna, prop);
562
563         prop= RNA_def_property(srna, "sequences", PROP_COLLECTION, PROP_NONE);
564         RNA_def_property_collection_sdna(prop, NULL, "seqbase", NULL);
565         RNA_def_property_struct_type(prop, "Sequence");
566         RNA_def_property_ui_text(prop, "Sequences", "");
567
568         prop= RNA_def_property(srna, "meta_stack", PROP_COLLECTION, PROP_NONE);
569         RNA_def_property_collection_sdna(prop, NULL, "metastack", NULL);
570         RNA_def_property_struct_type(prop, "Sequence");
571         RNA_def_property_ui_text(prop, "Meta Stack", "Meta strip stack, last is currently edited meta strip.");
572         RNA_def_property_collection_funcs(prop, 0, 0, 0, "rna_SequenceEdtior_meta_stack_get", 0, 0, 0, 0, 0);
573         
574         prop= RNA_def_property(srna, "active_strip", PROP_POINTER, PROP_NONE);
575         RNA_def_property_pointer_sdna(prop, NULL, "act_seq");
576         RNA_def_property_ui_text(prop, "Active Strip", "Sequencers active strip");
577 }
578
579 static void rna_def_filter_video(StructRNA *srna)
580 {
581         PropertyRNA *prop;
582
583         prop= RNA_def_property(srna, "de_interlace", PROP_BOOLEAN, PROP_NONE);
584         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_FILTERY);
585         RNA_def_property_ui_text(prop, "De-Interlace", "For video movies to remove fields.");
586
587         prop= RNA_def_property(srna, "premultiply", PROP_BOOLEAN, PROP_NONE);
588         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_MAKE_PREMUL);
589         RNA_def_property_ui_text(prop, "Premultiply", "Convert RGB from key alpha to premultiplied alpha.");
590         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
591
592         prop= RNA_def_property(srna, "flip_x", PROP_BOOLEAN, PROP_NONE);
593         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_FLIPX);
594         RNA_def_property_ui_text(prop, "Flip X", "Flip on the X axis.");
595         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
596
597         prop= RNA_def_property(srna, "flip_y", PROP_BOOLEAN, PROP_NONE);
598         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_FLIPY);
599         RNA_def_property_ui_text(prop, "Flip Y", "Flip on the Y axis.");
600         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
601
602         prop= RNA_def_property(srna, "convert_float", PROP_BOOLEAN, PROP_NONE);
603         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_MAKE_FLOAT);
604         RNA_def_property_ui_text(prop, "Convert Float", "Convert input to float data.");
605         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
606
607         prop= RNA_def_property(srna, "reverse_frames", PROP_BOOLEAN, PROP_NONE);
608         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_REVERSE_FRAMES);
609         RNA_def_property_ui_text(prop, "Flip Time", "Reverse frame order.");
610         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
611
612         prop= RNA_def_property(srna, "multiply_colors", PROP_FLOAT, PROP_UNSIGNED);
613         RNA_def_property_float_sdna(prop, NULL, "mul");
614         RNA_def_property_range(prop, 0.0f, 20.0f);
615         RNA_def_property_ui_text(prop, "Multiply Colors", "");
616         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
617
618         prop= RNA_def_property(srna, "strobe", PROP_FLOAT, PROP_NONE);
619         RNA_def_property_range(prop, 1.0f, 30.0f);
620         RNA_def_property_ui_text(prop, "Strobe", "Only display every nth frame.");
621         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
622
623         prop= RNA_def_property(srna, "use_color_balance", PROP_BOOLEAN, PROP_NONE);
624         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_COLOR_BALANCE);
625         RNA_def_property_ui_text(prop, "Use Color Balance", "(3-Way color correction) on input.");
626         RNA_def_property_boolean_funcs(prop, NULL, "rna_SequenceEditor_use_color_balance_set");
627         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
628
629         prop= RNA_def_property(srna, "color_balance", PROP_POINTER, PROP_NONE);
630         RNA_def_property_pointer_sdna(prop, NULL, "strip->color_balance");
631         RNA_def_property_ui_text(prop, "Color Balance", "");
632         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
633
634         prop= RNA_def_property(srna, "use_translation", PROP_BOOLEAN, PROP_NONE);
635         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_TRANSFORM);
636         RNA_def_property_ui_text(prop, "Use Translation", "Translate image before processing.");
637         RNA_def_property_boolean_funcs(prop, NULL, "rna_SequenceEditor_use_translation_set");
638         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
639         
640         prop= RNA_def_property(srna, "transform", PROP_POINTER, PROP_NONE);
641         RNA_def_property_pointer_sdna(prop, NULL, "strip->transform");
642         RNA_def_property_ui_text(prop, "Transform", "");
643         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
644
645         prop= RNA_def_property(srna, "use_crop", PROP_BOOLEAN, PROP_NONE);
646         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_CROP);
647         RNA_def_property_ui_text(prop, "Use Crop", "Crop image before processing.");
648         RNA_def_property_boolean_funcs(prop, NULL, "rna_SequenceEditor_use_crop_set");
649         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
650
651         prop= RNA_def_property(srna, "crop", PROP_POINTER, PROP_NONE);
652         RNA_def_property_pointer_sdna(prop, NULL, "strip->crop");
653         RNA_def_property_ui_text(prop, "Crop", "");
654         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
655 }
656
657 static void rna_def_proxy(StructRNA *srna)
658 {
659         PropertyRNA *prop;
660
661         prop= RNA_def_property(srna, "use_proxy", PROP_BOOLEAN, PROP_NONE);
662         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_PROXY);
663         RNA_def_property_ui_text(prop, "Use Proxy", "Use a preview proxy for this strip.");
664         RNA_def_property_boolean_funcs(prop, NULL, "rna_SequenceEditor_use_proxy_set");
665
666         prop= RNA_def_property(srna, "proxy", PROP_POINTER, PROP_NONE);
667         RNA_def_property_pointer_sdna(prop, NULL, "strip->proxy");
668         RNA_def_property_ui_text(prop, "Proxy", "");
669
670         prop= RNA_def_property(srna, "proxy_custom_directory", PROP_BOOLEAN, PROP_NONE);
671         RNA_def_property_boolean_sdna(prop, NULL, "flag", SEQ_USE_PROXY_CUSTOM_DIR);
672         RNA_def_property_ui_text(prop, "Proxy Custom Directory", "Use a custom directory to store data.");
673 }
674
675 static void rna_def_input(StructRNA *srna)
676 {
677         PropertyRNA *prop;
678
679         prop= RNA_def_property(srna, "animation_start_offset", PROP_INT, PROP_UNSIGNED);
680         RNA_def_property_int_sdna(prop, NULL, "anim_startofs");
681         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // overlap test
682         RNA_def_property_ui_text(prop, "Animation Start Offset", "Animation start offset (trim start).");
683         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
684         
685         prop= RNA_def_property(srna, "animation_end_offset", PROP_INT, PROP_UNSIGNED);
686         RNA_def_property_int_sdna(prop, NULL, "anim_endofs");
687         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // overlap test
688         RNA_def_property_ui_text(prop, "Animation End Offset", "Animation end offset (trim end).");
689         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
690 }
691
692 static void rna_def_image(BlenderRNA *brna)
693 {
694         StructRNA *srna;
695         PropertyRNA *prop;
696         
697         srna = RNA_def_struct(brna, "ImageSequence", "Sequence");
698         RNA_def_struct_ui_text(srna, "Image Sequence", "Sequence strip to load one or more images.");
699         RNA_def_struct_sdna(srna, "Sequence");
700
701         prop= RNA_def_property(srna, "directory", PROP_STRING, PROP_DIRPATH);
702         RNA_def_property_string_sdna(prop, NULL, "strip->dir");
703         RNA_def_property_ui_text(prop, "Directory", "");
704
705         prop= RNA_def_property(srna, "elements", PROP_COLLECTION, PROP_NONE);
706         RNA_def_property_collection_sdna(prop, NULL, "strip->stripdata", "strip->len");
707         RNA_def_property_struct_type(prop, "SequenceElement");
708         RNA_def_property_ui_text(prop, "Elements", "");
709
710
711         rna_def_filter_video(srna);
712         rna_def_proxy(srna);
713         rna_def_input(srna);
714 }
715
716 static void rna_def_meta(BlenderRNA *brna)
717 {
718         StructRNA *srna;
719         PropertyRNA *prop;
720         
721         srna = RNA_def_struct(brna, "MetaSequence", "Sequence");
722         RNA_def_struct_ui_text(srna, "Meta Sequence", "Sequence strip to group other strips as a single sequence strip.");
723         RNA_def_struct_sdna(srna, "Sequence");
724
725         prop = RNA_def_property(srna, "sequences", PROP_COLLECTION, PROP_NONE);
726         RNA_def_property_collection_sdna(prop, NULL, "seqbase", NULL);
727         RNA_def_property_struct_type(prop, "Sequence");
728         RNA_def_property_ui_text(prop, "Sequences", "");
729
730         rna_def_filter_video(srna);
731         rna_def_proxy(srna);
732         rna_def_input(srna);
733 }
734
735 static void rna_def_scene(BlenderRNA *brna)
736 {
737         StructRNA *srna;
738         PropertyRNA *prop;
739         
740         srna = RNA_def_struct(brna, "SceneSequence", "Sequence");
741         RNA_def_struct_ui_text(srna, "Scene Sequence", "Sequence strip to used the rendered image of a scene.");
742         RNA_def_struct_sdna(srna, "Sequence");
743
744         prop= RNA_def_property(srna, "scene", PROP_POINTER, PROP_NONE);
745         RNA_def_property_ui_text(prop, "Scene", "Scene that this sequence uses.");
746
747         rna_def_filter_video(srna);
748         rna_def_proxy(srna);
749         rna_def_input(srna);
750 }
751
752 static void rna_def_movie(BlenderRNA *brna)
753 {
754         StructRNA *srna;
755         PropertyRNA *prop;
756         
757         srna = RNA_def_struct(brna, "MovieSequence", "Sequence");
758         RNA_def_struct_ui_text(srna, "Movie Sequence", "Sequence strip to load a video.");
759         RNA_def_struct_sdna(srna, "Sequence");
760
761         prop= RNA_def_property(srna, "mpeg_preseek", PROP_INT, PROP_NONE);
762         RNA_def_property_int_sdna(prop, NULL, "anim_preseek");
763         RNA_def_property_range(prop, 0, 50);
764         RNA_def_property_ui_text(prop, "MPEG Preseek", "For MPEG movies, preseek this many frames.");
765
766         prop= RNA_def_property(srna, "filename", PROP_STRING, PROP_FILEPATH);
767         RNA_def_property_string_sdna(prop, NULL, "strip->stripdata->name");
768         RNA_def_property_ui_text(prop, "Filename", "");
769         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MovieSequence_filename_set");
770
771         prop= RNA_def_property(srna, "directory", PROP_STRING, PROP_DIRPATH);
772         RNA_def_property_string_sdna(prop, NULL, "strip->dir");
773         RNA_def_property_ui_text(prop, "Directory", "");
774
775         rna_def_filter_video(srna);
776         rna_def_proxy(srna);
777         rna_def_input(srna);
778 }
779
780 static void rna_def_sound(BlenderRNA *brna)
781 {
782         StructRNA *srna;
783         PropertyRNA *prop;
784         
785         srna = RNA_def_struct(brna, "SoundSequence", "Sequence");
786         RNA_def_struct_ui_text(srna, "Sound Sequence", "Sequence strip defining a sound to be played over a period of time.");
787         RNA_def_struct_sdna(srna, "Sequence");
788
789         prop= RNA_def_property(srna, "sound", PROP_POINTER, PROP_NONE);
790         RNA_def_property_struct_type(prop, "Sound");
791         RNA_def_property_ui_text(prop, "Sound", "Sound datablock used by this sequence (RAM audio only).");
792
793         prop= RNA_def_property(srna, "filename", PROP_STRING, PROP_FILEPATH);
794         RNA_def_property_string_sdna(prop, NULL, "strip->stripdata->name");
795         RNA_def_property_ui_text(prop, "Filename", "");
796         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_SoundSequence_filename_set");
797
798         prop= RNA_def_property(srna, "directory", PROP_STRING, PROP_DIRPATH);
799         RNA_def_property_string_sdna(prop, NULL, "strip->dir");
800         RNA_def_property_ui_text(prop, "Directory", "");
801
802         rna_def_input(srna);
803 }
804
805 static void rna_def_effect(BlenderRNA *brna)
806 {
807         StructRNA *srna;
808
809         srna = RNA_def_struct(brna, "EffectSequence", "Sequence");
810         RNA_def_struct_ui_text(srna, "Effect Sequence", "Sequence strip applying an effect on the images created by other strips.");
811         RNA_def_struct_sdna(srna, "Sequence");
812
813         rna_def_proxy(srna);
814 }
815
816 static void rna_def_plugin(BlenderRNA *brna)
817 {
818         StructRNA *srna;
819         PropertyRNA *prop;
820         
821         srna = RNA_def_struct(brna, "PluginSequence", "EffectSequence");
822         RNA_def_struct_ui_text(srna, "Plugin Sequence", "Sequence strip applying an effect, loaded from an external plugin.");
823         RNA_def_struct_sdna_from(srna, "PluginSeq", "plugin");
824
825         prop= RNA_def_property(srna, "filename", PROP_STRING, PROP_FILEPATH);
826         RNA_def_property_string_sdna(prop, NULL, "name");
827         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
828         RNA_def_property_ui_text(prop, "Filename", "");
829         
830         /* plugin properties need custom wrapping code like ID properties */
831 }
832
833 static void rna_def_wipe(BlenderRNA *brna)
834 {
835         StructRNA *srna;
836         PropertyRNA *prop;
837         
838         static const EnumPropertyItem wipe_type_items[]= {
839                 {0, "SINGLE", 0, "Single", ""}, 
840                 {1, "DOUBLE", 0, "Double", ""}, 
841                 /* not used yet {2, "BOX", 0, "Box", ""}, */
842                 /* not used yet {3, "CROSS", 0, "Cross", ""}, */
843                 {4, "IRIS", 0, "Iris", ""}, 
844                 {5, "CLOCK", 0, "Clock", ""},   
845                 {0, NULL, 0, NULL, NULL}
846         };
847
848         static const EnumPropertyItem wipe_direction_items[]= {
849                 {0, "OUT", 0, "Out", ""},
850                 {1, "IN", 0, "In", ""},
851                 {0, NULL, 0, NULL, NULL}
852         };
853
854         srna = RNA_def_struct(brna, "WipeSequence", "EffectSequence");
855         RNA_def_struct_ui_text(srna, "Wipe Sequence", "Sequence strip creating a wipe transition.");
856         RNA_def_struct_sdna_from(srna, "WipeVars", "effectdata");
857
858         prop= RNA_def_property(srna, "blur_width", PROP_FLOAT, PROP_UNSIGNED);
859         RNA_def_property_float_sdna(prop, NULL, "edgeWidth");
860         RNA_def_property_range(prop, 0.0f, 1.0f);
861         RNA_def_property_ui_text(prop, "Blur Width", "Width of the blur edge, in percentage relative to the image size.");
862         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
863         
864         prop= RNA_def_property(srna, "angle", PROP_FLOAT, PROP_NONE);
865         RNA_def_property_float_sdna(prop, NULL, "angle");
866         RNA_def_property_range(prop, -90.0f, 90.0f);
867         RNA_def_property_ui_text(prop, "Angle", "Edge angle.");
868         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
869         
870         prop= RNA_def_property(srna, "direction", PROP_ENUM, PROP_NONE);
871         RNA_def_property_enum_sdna(prop, NULL, "forward");
872         RNA_def_property_enum_items(prop, wipe_direction_items);
873         RNA_def_property_ui_text(prop, "Direction", "Wipe direction.");
874         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
875         
876         prop= RNA_def_property(srna, "transition_type", PROP_ENUM, PROP_NONE);
877         RNA_def_property_enum_sdna(prop, NULL, "wipetype");
878         RNA_def_property_enum_items(prop, wipe_type_items);
879         RNA_def_property_ui_text(prop, "Transition Type", "");
880         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
881 }
882
883 static void rna_def_glow(BlenderRNA *brna)
884 {
885         StructRNA *srna;
886         PropertyRNA *prop;
887         
888         srna = RNA_def_struct(brna, "GlowSequence", "EffectSequence");
889         RNA_def_struct_ui_text(srna, "Glow Sequence", "Sequence strip creating a glow effect.");
890         RNA_def_struct_sdna_from(srna, "GlowVars", "effectdata");
891         
892         prop= RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_NONE);
893         RNA_def_property_float_sdna(prop, NULL, "fMini");
894         RNA_def_property_range(prop, 0.0f, 1.0f);
895         RNA_def_property_ui_text(prop, "Threshold", "Minimum intensity to trigger a glow");
896         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
897         
898         prop= RNA_def_property(srna, "clamp", PROP_FLOAT, PROP_NONE);
899         RNA_def_property_float_sdna(prop, NULL, "fClamp");
900         RNA_def_property_range(prop, 0.0f, 1.0f);
901         RNA_def_property_ui_text(prop, "Clamp", "rightness limit of intensity.");
902         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
903         
904         prop= RNA_def_property(srna, "boost_factor", PROP_FLOAT, PROP_NONE);
905         RNA_def_property_float_sdna(prop, NULL, "fBoost");
906         RNA_def_property_range(prop, 0.0f, 10.0f);
907         RNA_def_property_ui_text(prop, "Boost Factor", "Brightness multiplier.");
908         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
909         
910         prop= RNA_def_property(srna, "blur_distance", PROP_FLOAT, PROP_NONE);
911         RNA_def_property_float_sdna(prop, NULL, "dDist");
912         RNA_def_property_range(prop, 0.5f, 20.0f);
913         RNA_def_property_ui_text(prop, "Blur Distance", "Radius of glow effect.");
914         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
915         
916         prop= RNA_def_property(srna, "quality", PROP_INT, PROP_NONE);
917         RNA_def_property_int_sdna(prop, NULL, "dQuality");
918         RNA_def_property_range(prop, 1, 5);
919         RNA_def_property_ui_text(prop, "Quality", "Accuracy of the blur effect.");
920         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
921         
922         prop= RNA_def_property(srna, "only_boost", PROP_BOOLEAN, PROP_NONE);
923         RNA_def_property_boolean_sdna(prop, NULL, "bNoComp", 0);
924         RNA_def_property_ui_text(prop, "Only Boost", "Show the glow buffer only.");
925         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
926 }
927
928 static void rna_def_transform(BlenderRNA *brna)
929 {
930         StructRNA *srna;
931         PropertyRNA *prop;
932
933         static const EnumPropertyItem interpolation_items[]= {
934                 {0, "NONE", 0, "None", "No interpolation."},
935                 {1, "BILINEAR", 0, "Bilinear", "Bilinear interpolation."},
936                 {2, "BICUBIC", 0, "Bicubic", "Bicubic interpolation."},
937                 {0, NULL, 0, NULL, NULL}
938         };
939
940         static const EnumPropertyItem translation_unit_items[]= {
941                 {0, "PIXELS", 0, "Pixels", ""},
942                 {1, "PERCENT", 0, "Percent", ""},
943                 {0, NULL, 0, NULL, NULL}
944         };
945
946         srna = RNA_def_struct(brna, "TransformSequence", "EffectSequence");
947         RNA_def_struct_ui_text(srna, "Transform Sequence", "Sequence strip applying affine transformations to other strips.");
948         RNA_def_struct_sdna_from(srna, "TransformVars", "effectdata");
949         
950         prop= RNA_def_property(srna, "scale_start_x", PROP_FLOAT, PROP_UNSIGNED);
951         RNA_def_property_float_sdna(prop, NULL, "ScalexIni");
952         RNA_def_property_ui_text(prop, "Scale Start X", "");
953         RNA_def_property_ui_range(prop, 0, 10, 3, 10);
954         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
955         
956         prop= RNA_def_property(srna, "scale_start_y", PROP_FLOAT, PROP_UNSIGNED);
957         RNA_def_property_float_sdna(prop, NULL, "ScaleyIni");
958         RNA_def_property_ui_text(prop, "Scale Start Y", "");
959         RNA_def_property_ui_range(prop, 0, 10, 3, 10);
960         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
961         
962         prop= RNA_def_property(srna, "scale_end_x", PROP_FLOAT, PROP_UNSIGNED);
963         RNA_def_property_float_sdna(prop, NULL, "ScalexFin");
964         RNA_def_property_ui_text(prop, "Scale End X", "");
965         RNA_def_property_ui_range(prop, 0, 10, 3, 10);
966         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
967         
968         prop= RNA_def_property(srna, "scale_end_y", PROP_FLOAT, PROP_UNSIGNED);
969         RNA_def_property_float_sdna(prop, NULL, "ScaleyFin");
970         RNA_def_property_ui_text(prop, "Scale End Y", "");
971         RNA_def_property_ui_range(prop, 0, 10, 3, 10);
972         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
973         
974         prop= RNA_def_property(srna, "translate_start_x", PROP_FLOAT, PROP_NONE);
975         RNA_def_property_float_sdna(prop, NULL, "xIni");
976         RNA_def_property_ui_text(prop, "Translate Start X", "");
977         RNA_def_property_ui_range(prop, -500.0f, 500.0f, 3, 10);
978         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
979         
980         prop= RNA_def_property(srna, "translate_start_y", PROP_FLOAT, PROP_NONE);
981         RNA_def_property_float_sdna(prop, NULL, "yIni");
982         RNA_def_property_ui_text(prop, "Translate Start Y", "");
983         RNA_def_property_ui_range(prop, -500.0f, 500.0f, 3, 10);
984         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
985         
986         prop= RNA_def_property(srna, "translate_end_x", PROP_FLOAT, PROP_NONE);
987         RNA_def_property_float_sdna(prop, NULL, "xFin");
988         RNA_def_property_ui_text(prop, "Translate End X", "");
989         RNA_def_property_ui_range(prop, -500.0f, 500.0f, 3, 10);
990         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
991
992         prop= RNA_def_property(srna, "translate_end_y", PROP_FLOAT, PROP_NONE);
993         RNA_def_property_float_sdna(prop, NULL, "yFin");
994         RNA_def_property_ui_text(prop, "Translate End Y", "");
995         RNA_def_property_ui_range(prop, -500.0f, 500.0f, 3, 10);
996         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
997         
998         prop= RNA_def_property(srna, "rotation_start", PROP_FLOAT, PROP_NONE);
999         RNA_def_property_float_sdna(prop, NULL, "rotIni");
1000         RNA_def_property_range(prop, 0.0f, 360.0f);
1001         RNA_def_property_ui_text(prop, "Rotation Start", "");
1002         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
1003         
1004         prop= RNA_def_property(srna, "rotation_end", PROP_FLOAT, PROP_NONE);
1005         RNA_def_property_float_sdna(prop, NULL, "rotFin");
1006         RNA_def_property_range(prop, 0.0f, 360.0f);
1007         RNA_def_property_ui_text(prop, "Rotation End", "");
1008         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
1009         
1010         prop= RNA_def_property(srna, "translation_unit", PROP_ENUM, PROP_NONE);
1011         RNA_def_property_enum_sdna(prop, NULL, "percent");
1012         RNA_def_property_enum_items(prop, translation_unit_items);
1013         RNA_def_property_ui_text(prop, "Translation Unit", "");
1014         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
1015         
1016         prop= RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
1017         RNA_def_property_enum_items(prop, interpolation_items);
1018         RNA_def_property_ui_text(prop, "Interpolation", "");
1019         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
1020 }
1021
1022 static void rna_def_solid_color(BlenderRNA *brna)
1023 {
1024         StructRNA *srna;
1025         PropertyRNA *prop;
1026         
1027         srna = RNA_def_struct(brna, "ColorSequence", "EffectSequence");
1028         RNA_def_struct_ui_text(srna, "Color Sequence", "Sequence strip creating an image filled with a single color.");
1029         RNA_def_struct_sdna_from(srna, "SolidColorVars", "effectdata");
1030         
1031         prop= RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
1032         RNA_def_property_float_sdna(prop, NULL, "col");
1033         RNA_def_property_ui_text(prop, "Color", "");
1034         RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, NULL);
1035 }
1036
1037 static void rna_def_speed_control(BlenderRNA *brna)
1038 {
1039         StructRNA *srna;
1040         PropertyRNA *prop;
1041
1042         srna = RNA_def_struct(brna, "SpeedControlSequence", "EffectSequence");
1043         RNA_def_struct_ui_text(srna, "SpeedControl Sequence", "Sequence strip to control the speed of other strips.");
1044         RNA_def_struct_sdna_from(srna, "SpeedControlVars", "effectdata");
1045         
1046         prop= RNA_def_property(srna, "global_speed", PROP_FLOAT, PROP_UNSIGNED);
1047         RNA_def_property_float_sdna(prop, NULL, "globalSpeed");
1048         RNA_def_property_ui_text(prop, "Global Speed", "");
1049         RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 0);
1050         
1051         prop= RNA_def_property(srna, "curve_velocity", PROP_BOOLEAN, PROP_NONE);
1052         RNA_def_property_boolean_sdna(prop, NULL, "flags", SEQ_SPEED_INTEGRATE);
1053         RNA_def_property_ui_text(prop, "F-Curve Velocity", "Interpret the F-Curve value as a velocity instead of a frame number.");
1054
1055         prop= RNA_def_property(srna, "frame_blending", PROP_BOOLEAN, PROP_NONE);
1056         RNA_def_property_boolean_sdna(prop, NULL, "flags", SEQ_SPEED_BLEND);
1057         RNA_def_property_ui_text(prop, "Frame Blending", "Blend two frames into the target for a smoother result.");
1058
1059         prop= RNA_def_property(srna, "curve_compress_y", PROP_BOOLEAN, PROP_NONE);
1060         RNA_def_property_boolean_sdna(prop, NULL, "flags", SEQ_SPEED_COMPRESS_IPO_Y);
1061         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.");
1062 }
1063
1064 void RNA_def_sequence(BlenderRNA *brna)
1065 {
1066         rna_def_strip_element(brna);
1067         rna_def_strip_proxy(brna);
1068         rna_def_strip_color_balance(brna);
1069         rna_def_strip_crop(brna);
1070         rna_def_strip_transform(brna);
1071
1072         rna_def_sequence(brna);
1073         rna_def_editor(brna);
1074
1075         rna_def_image(brna);
1076         rna_def_meta(brna);
1077         rna_def_scene(brna);
1078         rna_def_movie(brna);
1079         rna_def_sound(brna);
1080         rna_def_effect(brna);
1081         rna_def_plugin(brna);
1082         rna_def_wipe(brna);
1083         rna_def_glow(brna);
1084         rna_def_transform(brna);
1085         rna_def_solid_color(brna);
1086         rna_def_speed_control(brna);
1087 }
1088
1089 #endif
1090