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