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