use bool for rna funcs.
[blender.git] / source / blender / makesrna / intern / rna_sequencer_api.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Blender Foundation (2010)
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/makesrna/intern/rna_sequencer_api.c
24  *  \ingroup RNA
25  */
26
27 #include <stdlib.h>
28 #include <stdio.h>
29 #include <string.h>
30
31 #include "DNA_scene_types.h"
32 #include "DNA_sequence_types.h"
33
34 #include "BLI_utildefines.h"
35
36 #include "RNA_define.h"
37 #include "RNA_access.h"
38 #include "RNA_define.h"
39
40 #include "rna_internal.h"
41
42 #ifdef RNA_RUNTIME
43
44 //#include "DNA_anim_types.h"
45 #include "DNA_image_types.h"
46 #include "DNA_scene_types.h"
47 #include "DNA_sequence_types.h"
48 #include "DNA_mask_types.h"
49 #include "DNA_sound_types.h"
50
51 #include "BLI_path_util.h" /* BLI_split_dirfile */
52
53 #include "BKE_image.h"
54 #include "BKE_library.h" /* id_us_plus */
55 #include "BKE_movieclip.h"
56 #include "BKE_mask.h"
57
58 #include "BKE_report.h"
59 #include "BKE_sequencer.h"
60 #include "BKE_sound.h"
61
62 #include "IMB_imbuf.h"
63 #include "IMB_imbuf_types.h"
64
65 #include "WM_api.h"
66
67 static void rna_Sequence_update_rnafunc(ID *id, Sequence *self, int do_data)
68 {
69         if (do_data) {
70                 BKE_sequencer_update_changed_seq_and_deps((Scene *)id, self, true, true);
71                 // new_tstripdata(self); // need 2.6x version of this.
72         }
73         BKE_sequence_calc((Scene *)id, self);
74         BKE_sequence_calc_disp((Scene *)id, self);
75 }
76
77 static void rna_Sequence_swap_internal(Sequence *seq_self, ReportList *reports, Sequence *seq_other)
78 {
79         const char *error_msg;
80         
81         if (BKE_sequence_swap(seq_self, seq_other, &error_msg) == 0)
82                 BKE_report(reports, RPT_ERROR, error_msg);
83 }
84
85 static Sequence *alloc_generic_sequence(Editing *ed, const char *name, int frame_start,
86                                         int channel, int type, const char *file)
87 {
88         Sequence *seq;
89         Strip *strip;
90         StripElem *se;
91
92         seq = BKE_sequence_alloc(ed->seqbasep, frame_start, channel);
93         seq->type = type;
94
95         BLI_strncpy(seq->name + 2, name, sizeof(seq->name) - 2);
96         BKE_sequence_base_unique_name_recursive(&ed->seqbase, seq);
97
98         seq->strip = strip = MEM_callocN(sizeof(Strip), "strip");
99         seq->strip->us = 1;
100
101         if (file) {
102                 strip->stripdata = se = MEM_callocN(sizeof(StripElem), "stripelem");
103                 BLI_split_dirfile(file, strip->dir, se->name, sizeof(strip->dir), sizeof(se->name));
104
105                 BKE_sequence_init_colorspace(seq);
106         }
107         else {
108                 strip->stripdata = NULL;
109         }
110
111         return seq;
112 }
113
114 static Sequence *rna_Sequences_new_clip(ID *id, Editing *ed,
115                                         const char *name, MovieClip *clip, int channel,
116                                         int frame_start)
117 {
118         Scene *scene = (Scene *)id;
119         Sequence *seq;
120
121         seq = alloc_generic_sequence(ed, name, frame_start, channel, SEQ_TYPE_MOVIECLIP, clip->name);
122         seq->clip = clip;
123         seq->len =  BKE_movieclip_get_duration(clip);
124         id_us_plus((ID *)clip);
125
126         BKE_sequence_calc_disp(scene, seq);
127
128         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
129
130         return seq;
131 }
132
133 static Sequence *rna_Sequences_new_mask(ID *id, Editing *ed,
134                                         const char *name, Mask *mask, int channel,
135                                         int frame_start)
136 {
137         Scene *scene = (Scene *)id;
138         Sequence *seq;
139
140         seq = alloc_generic_sequence(ed, name, frame_start, channel, SEQ_TYPE_MASK, mask->id.name);
141         seq->mask = mask;
142         seq->len = BKE_mask_get_duration(mask);
143         id_us_plus((ID *)mask);
144
145         BKE_sequence_calc_disp(scene, seq);
146
147         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
148
149         return seq;
150 }
151
152 static Sequence *rna_Sequences_new_scene(ID *id, Editing *ed,
153                                          const char *name, Scene *sce_seq, int channel,
154                                          int frame_start)
155 {
156         Scene *scene = (Scene *)id;
157         Sequence *seq;
158
159         seq = alloc_generic_sequence(ed, name, frame_start, channel, SEQ_TYPE_SCENE, NULL);
160         seq->scene = sce_seq;
161         seq->len = sce_seq->r.efra - sce_seq->r.sfra + 1;
162         seq->scene_sound = sound_scene_add_scene_sound(scene, seq, frame_start, frame_start + seq->len, 0);
163         id_us_plus((ID *)sce_seq);
164
165         BKE_sequence_calc_disp(scene, seq);
166
167         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
168
169         return seq;
170 }
171
172 static Sequence *rna_Sequences_new_image(ID *id, Editing *ed, ReportList *reports,
173                                          const char *name, const char *file, int channel,
174                                          int frame_start)
175 {
176         Scene *scene = (Scene *)id;
177         Sequence *seq;
178
179         seq = alloc_generic_sequence(ed, name, frame_start, channel, SEQ_TYPE_IMAGE, file);
180         seq->len = 1;
181
182         if (seq->strip->stripdata->name[0] == '\0') {
183                 BKE_report(reports, RPT_ERROR, "Sequences.new_image: unable to open image file");
184                 BLI_remlink(&ed->seqbase, seq);
185                 BKE_sequence_free(scene, seq);
186                 return NULL;
187         }
188
189         BKE_sequence_calc_disp(scene, seq);
190
191         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
192
193         return seq;
194 }
195
196 static Sequence *rna_Sequences_new_movie(ID *id, Editing *ed, ReportList *reports,
197                                          const char *name, const char *file, int channel,
198                                          int frame_start)
199 {
200         Scene *scene = (Scene *)id;
201         Sequence *seq;
202
203         struct anim *an = openanim(file, IB_rect, 0, NULL);
204
205         if (an == NULL) {
206                 BKE_report(reports, RPT_ERROR, "Sequences.new_movie: unable to open movie file");
207                 return NULL;
208         }
209
210         seq = alloc_generic_sequence(ed, name, frame_start, channel, SEQ_TYPE_MOVIE, file);
211         seq->anim = an;
212         seq->anim_preseek = IMB_anim_get_preseek(an);
213         seq->len = IMB_anim_get_duration(an, IMB_TC_RECORD_RUN);
214
215         BKE_sequence_calc_disp(scene, seq);
216
217         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
218
219         return seq;
220 }
221
222 #ifdef WITH_AUDASPACE
223 static Sequence *rna_Sequences_new_sound(ID *id, Editing *ed, Main *bmain, ReportList *reports,
224                                          const char *name, const char *file, int channel, int frame_start)
225 {
226         Scene *scene = (Scene *)id;
227         Sequence *seq;
228
229         bSound *sound = sound_new_file(bmain, file);
230
231         if (sound == NULL || sound->playback_handle == NULL) {
232                 BKE_report(reports, RPT_ERROR, "Sequences.new_sound: unable to open sound file");
233                 return NULL;
234         }
235
236         seq = alloc_generic_sequence(ed, name, frame_start, channel, SEQ_TYPE_SOUND_RAM, sound->name);
237         seq->sound = sound;
238         seq->len = ceil((double)sound_get_length(sound) * FPS);
239
240         seq->scene_sound = sound_add_scene_sound(scene, seq, frame_start, frame_start + seq->len, 0);
241
242         BKE_sequence_calc_disp(scene, seq);
243
244         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
245
246         return seq;
247 }
248 #else /* WITH_AUDASPACE */
249 static Sequence *rna_Sequences_new_sound(ID *UNUSED(id), Editing *UNUSED(ed), Main *UNUSED(bmain), ReportList *reports,
250                                          const char *UNUSED(name), const char *UNUSED(file), int UNUSED(channel),
251                                          int UNUSED(frame_start))
252 {
253         BKE_report(reports, RPT_ERROR, "Blender compiled without Audaspace support");
254         return NULL;
255 }
256 #endif /* WITH_AUDASPACE */
257
258 static Sequence *rna_Sequences_new_effect(ID *id, Editing *ed, ReportList *reports,
259                                           const char *name, int type, int channel,
260                                           int frame_start, int frame_end,
261                                           Sequence *seq1, Sequence *seq2, Sequence *seq3)
262 {
263         Scene *scene = (Scene *)id;
264         Sequence *seq;
265         struct SeqEffectHandle sh;
266         int num_inputs = BKE_sequence_effect_get_num_inputs(type);
267
268         switch (num_inputs) {
269                 case 0:
270                         if (frame_end <= frame_start) {
271                                 BKE_report(reports, RPT_ERROR, "Sequences.new_effect: end frame not set");
272                                 return NULL;
273                         }
274                         break;
275                 case 1:
276                         if (seq1 == NULL) {
277                                 BKE_report(reports, RPT_ERROR, "Sequences.new_effect: effect takes 1 input sequence");
278                                 return NULL;
279                         }
280                         break;
281                 case 2:
282                         if (seq1 == NULL || seq2 == NULL) {
283                                 BKE_report(reports, RPT_ERROR, "Sequences.new_effect: effect takes 2 input sequences");
284                                 return NULL;
285                         }
286                         break;
287                 case 3:
288                         if (seq1 == NULL || seq2 == NULL || seq3 == NULL) {
289                                 BKE_report(reports, RPT_ERROR, "Sequences.new_effect: effect takes 3 input sequences");
290                                 return NULL;
291                         }
292                         break;
293                 default:
294                         BKE_reportf(reports, RPT_ERROR,
295                                     "Sequences.new_effect: effect expects more than 3 inputs (%d, should never happen!)",
296                                     num_inputs);
297                         return NULL;
298         }
299
300         seq = alloc_generic_sequence(ed, name, frame_start, channel, type, NULL);
301
302         sh = BKE_sequence_get_effect(seq);
303
304         seq->seq1 = seq1;
305         seq->seq2 = seq2;
306         seq->seq3 = seq3;
307
308         sh.init(seq);
309
310         if (!seq1) { /* effect has no deps */
311                 seq->len = 1;
312                 BKE_sequence_tx_set_final_right(seq, frame_end);
313         }
314
315         seq->flag |= SEQ_USE_EFFECT_DEFAULT_FADE;
316
317         BKE_sequence_calc_disp(scene, seq);
318
319         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
320
321         return seq;
322 }
323
324 static void rna_Sequences_remove(ID *id, Editing *ed, ReportList *reports, PointerRNA *seq_ptr)
325 {
326         Sequence *seq = seq_ptr->data;
327         Scene *scene = (Scene *)id;
328
329         if (BLI_remlink_safe(&ed->seqbase, seq) == FALSE) {
330                 BKE_reportf(reports, RPT_ERROR, "Sequence '%s' not in scene '%s'", seq->name + 2, scene->id.name + 2);
331                 return;
332         }
333
334         BKE_sequence_free(scene, seq);
335         RNA_POINTER_INVALIDATE(seq_ptr);
336
337         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
338 }
339
340 static StripElem *rna_SequenceElements_push(ID *id, Sequence *seq, const char *filename)
341 {
342         Scene *scene = (Scene *)id;
343         StripElem *se;
344
345         seq->strip->stripdata = se = MEM_reallocN(seq->strip->stripdata, sizeof(StripElem) * (seq->len + 1));
346         se += seq->len;
347         BLI_strncpy(se->name, filename, sizeof(se->name));
348         seq->len++;
349
350         BKE_sequence_calc_disp(scene, seq);
351
352         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
353
354         return se;
355 }
356
357 static void rna_SequenceElements_pop(ID *id, Sequence *seq, ReportList *reports, int index)
358 {
359         Scene *scene = (Scene *)id;
360         StripElem *new_seq, *se;
361
362         if (seq->len == 1) {
363                 BKE_report(reports, RPT_ERROR, "SequenceElements.pop: cannot pop the last element");
364                 return;
365         }
366
367         /* python style negative indexing */
368         if (index < 0) {
369                 index += seq->len;
370         }
371
372         if (seq->len <= index || index < 0) {
373                 BKE_report(reports, RPT_ERROR, "SequenceElements.pop: index out of range");
374                 return;
375         }
376
377         new_seq = MEM_callocN(sizeof(StripElem) * (seq->len - 1), "SequenceElements_pop");
378         seq->len--;
379
380         se = seq->strip->stripdata;
381         if (index > 0)
382                 memcpy(new_seq, se, sizeof(StripElem) * index);
383
384         if (index < seq->len)
385                 memcpy(&new_seq[index], &se[index + 1], sizeof(StripElem) * (seq->len - index));
386
387         MEM_freeN(seq->strip->stripdata);
388         seq->strip->stripdata = new_seq;
389
390         BKE_sequence_calc_disp(scene, seq);
391
392         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
393 }
394
395
396 #else
397
398 void RNA_api_sequence_strip(StructRNA *srna)
399 {
400         FunctionRNA *func;
401         PropertyRNA *parm;
402
403         func = RNA_def_function(srna, "update", "rna_Sequence_update_rnafunc");
404         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
405         RNA_def_function_ui_description(func, "Update the strip dimensions");
406         parm = RNA_def_boolean(func, "data", false, "Frame",
407                                "Update strip data");
408
409         func = RNA_def_function(srna, "strip_elem_from_frame", "BKE_sequencer_give_stripelem");
410         RNA_def_function_ui_description(func, "Return the strip element from a given frame or None");
411         parm = RNA_def_int(func, "frame", 0, -MAXFRAME, MAXFRAME, "Frame",
412                            "The frame to get the strip element from", -MAXFRAME, MAXFRAME);
413         RNA_def_property_flag(parm, PROP_REQUIRED);
414         RNA_def_function_return(func, RNA_def_pointer(func, "elem", "SequenceElement", "",
415                                                       "strip element of the current frame"));
416
417         func = RNA_def_function(srna, "swap", "rna_Sequence_swap_internal");
418         RNA_def_function_flag(func, FUNC_USE_REPORTS);
419         parm = RNA_def_pointer(func, "other", "Sequence", "Other", "");
420         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
421 }
422
423 void RNA_api_sequence_elements(BlenderRNA *brna, PropertyRNA *cprop)
424 {
425         StructRNA *srna;
426         PropertyRNA *parm;
427         FunctionRNA *func;
428
429         RNA_def_property_srna(cprop, "SequenceElements");
430         srna = RNA_def_struct(brna, "SequenceElements", NULL);
431         RNA_def_struct_sdna(srna, "Sequence");
432         RNA_def_struct_ui_text(srna, "SequenceElements", "Collection of SequenceElement");
433
434         func = RNA_def_function(srna, "push", "rna_SequenceElements_push");
435         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
436         RNA_def_function_ui_description(func, "Push an image from ImageSequence.directory");
437         parm = RNA_def_string(func, "filename", "File", 0, "", "Filepath to image");
438         RNA_def_property_flag(parm, PROP_REQUIRED);
439         /* return type */
440         parm = RNA_def_pointer(func, "elem", "SequenceElement", "", "New SequenceElement");
441         RNA_def_function_return(func, parm);
442
443         func = RNA_def_function(srna, "pop", "rna_SequenceElements_pop");
444         RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
445         RNA_def_function_ui_description(func, "Pop an image off the collection");
446         parm = RNA_def_int(func, "index", -1, INT_MIN, INT_MAX, "", "Index of image to remove", INT_MIN, INT_MAX);
447         RNA_def_property_flag(parm, PROP_REQUIRED);
448 }
449
450 void RNA_api_sequences(BlenderRNA *brna, PropertyRNA *cprop)
451 {
452         StructRNA *srna;
453         PropertyRNA *parm;
454         FunctionRNA *func;
455
456         static EnumPropertyItem seq_effect_items[] = {
457                 {SEQ_TYPE_CROSS, "CROSS", 0, "Cross", ""},
458                 {SEQ_TYPE_ADD, "ADD", 0, "Add", ""},
459                 {SEQ_TYPE_SUB, "SUBTRACT", 0, "Subtract", ""},
460                 {SEQ_TYPE_ALPHAOVER, "ALPHA_OVER", 0, "Alpha Over", ""},
461                 {SEQ_TYPE_ALPHAUNDER, "ALPHA_UNDER", 0, "Alpha Under", ""},
462                 {SEQ_TYPE_GAMCROSS, "GAMMA_CROSS", 0, "Gamma Cross", ""},
463                 {SEQ_TYPE_MUL, "MULTIPLY", 0, "Multiply", ""},
464                 {SEQ_TYPE_OVERDROP, "OVER_DROP", 0, "Over Drop", ""},
465                 {SEQ_TYPE_WIPE, "WIPE", 0, "Wipe", ""},
466                 {SEQ_TYPE_GLOW, "GLOW", 0, "Glow", ""},
467                 {SEQ_TYPE_TRANSFORM, "TRANSFORM", 0, "Transform", ""},
468                 {SEQ_TYPE_COLOR, "COLOR", 0, "Color", ""},
469                 {SEQ_TYPE_SPEED, "SPEED", 0, "Speed", ""},
470                 {SEQ_TYPE_MULTICAM, "MULTICAM", 0, "Multicam Selector", ""},
471                 {SEQ_TYPE_ADJUSTMENT, "ADJUSTMENT", 0, "Adjustment Layer", ""},
472                 {0, NULL, 0, NULL, NULL}
473         };
474
475         RNA_def_property_srna(cprop, "Sequences");
476         srna = RNA_def_struct(brna, "Sequences", NULL);
477         RNA_def_struct_sdna(srna, "Editing");
478         RNA_def_struct_ui_text(srna, "Sequences", "Collection of Sequences");
479
480         func = RNA_def_function(srna, "new_clip", "rna_Sequences_new_clip");
481         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
482         RNA_def_function_ui_description(func, "Add a new movie clip sequence");
483         parm = RNA_def_string(func, "name", "Name", 0, "", "Name for the new sequence");
484         RNA_def_property_flag(parm, PROP_REQUIRED);
485         parm = RNA_def_pointer(func, "clip", "MovieClip", "", "Movie clip to add");
486         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
487         parm = RNA_def_int(func, "channel", 0, 0, MAXSEQ - 1, "Channel",
488                            "The channel for the new sequence", 0, MAXSEQ - 1);
489         RNA_def_property_flag(parm, PROP_REQUIRED);
490         parm = RNA_def_int(func, "frame_start", 0, -MAXFRAME, MAXFRAME, "",
491                            "The start frame for the new sequence", -MAXFRAME, MAXFRAME);
492         RNA_def_property_flag(parm, PROP_REQUIRED);
493         /* return type */
494         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "New Sequence");
495         RNA_def_function_return(func, parm);
496
497         func = RNA_def_function(srna, "new_mask", "rna_Sequences_new_mask");
498         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
499         RNA_def_function_ui_description(func, "Add a new mask sequence");
500         parm = RNA_def_string(func, "name", "Name", 0, "", "Name for the new sequence");
501         RNA_def_property_flag(parm, PROP_REQUIRED);
502         parm = RNA_def_pointer(func, "mask", "Mask", "", "Mask to add");
503         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
504         parm = RNA_def_int(func, "channel", 0, 0, MAXSEQ - 1, "Channel",
505                            "The channel for the new sequence", 0, MAXSEQ - 1);
506         RNA_def_property_flag(parm, PROP_REQUIRED);
507         parm = RNA_def_int(func, "frame_start", 0, -MAXFRAME, MAXFRAME, "",
508                            "The start frame for the new sequence", -MAXFRAME, MAXFRAME);
509         RNA_def_property_flag(parm, PROP_REQUIRED);
510         /* return type */
511         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "New Sequence");
512         RNA_def_function_return(func, parm);
513
514         func = RNA_def_function(srna, "new_scene", "rna_Sequences_new_scene");
515         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
516         RNA_def_function_ui_description(func, "Add a new scene sequence");
517         parm = RNA_def_string(func, "name", "Name", 0, "", "Name for the new sequence");
518         RNA_def_property_flag(parm, PROP_REQUIRED);
519         parm = RNA_def_pointer(func, "scene", "Scene", "", "Scene to add");
520         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
521         parm = RNA_def_int(func, "channel", 0, 0, MAXSEQ - 1, "Channel",
522                            "The channel for the new sequence", 0, MAXSEQ - 1);
523         RNA_def_property_flag(parm, PROP_REQUIRED);
524         parm = RNA_def_int(func, "frame_start", 0, -MAXFRAME, MAXFRAME, "",
525                            "The start frame for the new sequence", -MAXFRAME, MAXFRAME);
526         RNA_def_property_flag(parm, PROP_REQUIRED);
527         /* return type */
528         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "New Sequence");
529         RNA_def_function_return(func, parm);
530
531         func = RNA_def_function(srna, "new_image", "rna_Sequences_new_image");
532         RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
533         RNA_def_function_ui_description(func, "Add a new image sequence");
534         parm = RNA_def_string(func, "name", "Name", 0, "", "Name for the new sequence");
535         RNA_def_property_flag(parm, PROP_REQUIRED);
536         parm = RNA_def_string(func, "filepath", "File", 0, "", "Filepath to image");
537         RNA_def_property_flag(parm, PROP_REQUIRED);
538         parm = RNA_def_int(func, "channel", 0, 0, MAXSEQ - 1, "Channel",
539                            "The channel for the new sequence", 0, MAXSEQ - 1);
540         RNA_def_property_flag(parm, PROP_REQUIRED);
541         parm = RNA_def_int(func, "frame_start", 0, -MAXFRAME, MAXFRAME, "",
542                            "The start frame for the new sequence", -MAXFRAME, MAXFRAME);
543         RNA_def_property_flag(parm, PROP_REQUIRED);
544         /* return type */
545         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "New Sequence");
546         RNA_def_function_return(func, parm);
547
548         func = RNA_def_function(srna, "new_movie", "rna_Sequences_new_movie");
549         RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
550         RNA_def_function_ui_description(func, "Add a new movie sequence");
551         parm = RNA_def_string(func, "name", "Name", 0, "", "Name for the new sequence");
552         RNA_def_property_flag(parm, PROP_REQUIRED);
553         parm = RNA_def_string(func, "filepath", "File", 0, "", "Filepath to movie");
554         RNA_def_property_flag(parm, PROP_REQUIRED);
555         parm = RNA_def_int(func, "channel", 0, 0, MAXSEQ - 1, "Channel",
556                            "The channel for the new sequence", 0, MAXSEQ - 1);
557         RNA_def_property_flag(parm, PROP_REQUIRED);
558         parm = RNA_def_int(func, "frame_start", 0, -MAXFRAME, MAXFRAME, "",
559                            "The start frame for the new sequence", -MAXFRAME, MAXFRAME);
560         RNA_def_property_flag(parm, PROP_REQUIRED);
561         /* return type */
562         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "New Sequence");
563         RNA_def_function_return(func, parm);
564
565         func = RNA_def_function(srna, "new_sound", "rna_Sequences_new_sound");
566         RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID | FUNC_USE_MAIN);
567         RNA_def_function_ui_description(func, "Add a new sound sequence");
568         parm = RNA_def_string(func, "name", "Name", 0, "", "Name for the new sequence");
569         RNA_def_property_flag(parm, PROP_REQUIRED);
570         parm = RNA_def_string(func, "filepath", "File", 0, "", "Filepath to movie");
571         RNA_def_property_flag(parm, PROP_REQUIRED);
572         parm = RNA_def_int(func, "channel", 0, 0, MAXSEQ - 1, "Channel",
573                            "The channel for the new sequence", 0, MAXSEQ - 1);
574         RNA_def_property_flag(parm, PROP_REQUIRED);
575         parm = RNA_def_int(func, "frame_start", 0, -MAXFRAME, MAXFRAME, "",
576                            "The start frame for the new sequence", -MAXFRAME, MAXFRAME);
577         RNA_def_property_flag(parm, PROP_REQUIRED);
578         /* return type */
579         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "New Sequence");
580         RNA_def_function_return(func, parm);
581
582         func = RNA_def_function(srna, "new_effect", "rna_Sequences_new_effect");
583         RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
584         RNA_def_function_ui_description(func, "Add a new effect sequence");
585         parm = RNA_def_string(func, "name", "Name", 0, "", "Name for the new sequence");
586         RNA_def_property_flag(parm, PROP_REQUIRED);
587         parm = RNA_def_enum(func, "type", seq_effect_items, 0, "Type",
588                             "type for the new sequence");
589         RNA_def_property_flag(parm, PROP_REQUIRED);
590         parm = RNA_def_int(func, "channel", 0, 0, MAXSEQ - 1, "Channel",
591                            "The channel for the new sequence", 0, MAXSEQ - 1);
592         /* don't use MAXFRAME since it makes importer scripts fail */
593         RNA_def_property_flag(parm, PROP_REQUIRED);
594         parm = RNA_def_int(func, "frame_start", 0, INT_MIN, INT_MAX, "",
595                            "The start frame for the new sequence", INT_MIN, INT_MAX);
596         RNA_def_property_flag(parm, PROP_REQUIRED);
597         RNA_def_int(func, "frame_end", 0, INT_MIN, INT_MAX, "",
598                     "The end frame for the new sequence", INT_MIN, INT_MAX);
599         RNA_def_pointer(func, "seq1", "Sequence", "", "Sequence 1 for effect");
600         RNA_def_pointer(func, "seq2", "Sequence", "", "Sequence 2 for effect");
601         RNA_def_pointer(func, "seq3", "Sequence", "", "Sequence 3 for effect");
602         /* return type */
603         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "New Sequence");
604         RNA_def_function_return(func, parm);
605
606
607         func = RNA_def_function(srna, "remove", "rna_Sequences_remove");
608         RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_REPORTS);
609         RNA_def_function_ui_description(func, "Remove a Sequence");
610         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "Sequence to remove");
611         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
612         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
613 }
614
615
616 #endif