Fix #32755: Stripes in Metastrip can not be moved on other channel with mouse (grab...
[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), int UNUSED(start_frame))
238 {
239         BKE_report(reports, RPT_ERROR, "Blender compiled without Audaspace support.");
240         return NULL;
241 }
242 #endif /* WITH_AUDASPACE */
243
244 static Sequence *rna_Sequences_new_effect(ID *id, Editing *ed, ReportList *reports,
245                                           const char *name, int type, int channel,
246                                           int start_frame, int end_frame,
247                                           Sequence *seq1, Sequence *seq2, Sequence *seq3)
248 {
249         Scene *scene = (Scene *)id;
250         Sequence *seq;
251         struct SeqEffectHandle sh;
252
253         switch (BKE_sequence_effect_get_num_inputs(type)) {
254                 case 0:
255                         if (end_frame <= start_frame) {
256                                 BKE_report(reports, RPT_ERROR,
257                                            "Sequences.new_effect: End frame not set");
258                                 return NULL;
259                         }
260                         break;
261                 case 1:
262                         if (seq1 == NULL) {
263                                 BKE_report(reports, RPT_ERROR,
264                                            "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,
271                                            "Sequences.new_effect: Effect takes 2 input sequences");
272                                 return NULL;
273                         }
274                         break;
275                 case 3:
276                         if (seq1 == NULL || seq2 == NULL || seq3 == NULL) {
277                                 BKE_report(reports, RPT_ERROR,
278                                            "Sequences.new_effect: Effect takes 3 input sequences");
279                                 return NULL;
280                         }
281                         break;
282                 default:
283                         BKE_report(reports, RPT_ERROR,
284                                    "Sequences.new_effect: BKE_sequence_effect_get_num_inputs() > 3 (should never happen)");
285                         return NULL;
286         }
287
288         seq = alloc_generic_sequence(ed, name, start_frame, channel, type, NULL);
289
290         sh = BKE_sequence_get_effect(seq);
291
292         seq->seq1 = seq1;
293         seq->seq2 = seq2;
294         seq->seq3 = seq3;
295
296         sh.init(seq);
297
298         if (!seq1) { /* effect has no deps */
299                 seq->len = 1;
300                 BKE_sequence_tx_set_final_right(seq, end_frame);
301         }
302
303         seq->flag |= SEQ_USE_EFFECT_DEFAULT_FADE;
304
305         BKE_sequence_calc_disp(scene, seq);
306
307         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
308
309         return seq;
310 }
311
312 static void rna_Sequences_remove(ID *id, Editing *ed, Sequence *seq)
313 {
314         Scene *scene = (Scene *)id;
315
316         BLI_remlink(&ed->seqbase, seq);
317         BKE_sequence_free(scene, seq);
318
319         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
320 }
321
322 static StripElem *rna_SequenceElements_push(ID *id, Sequence *seq, const char *filename)
323 {
324         Scene *scene = (Scene *)id;
325         StripElem *se;
326
327         seq->strip->stripdata = se = MEM_reallocN(seq->strip->stripdata, sizeof(StripElem) * (seq->len + 1));
328         se += seq->len;
329         BLI_strncpy(se->name, filename, sizeof(se->name));
330         seq->len++;
331
332         BKE_sequence_calc_disp(scene, seq);
333
334         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
335
336         return se;
337 }
338
339 static void rna_SequenceElements_pop(ID *id, Sequence *seq, ReportList *reports, int index)
340 {
341         Scene *scene = (Scene *)id;
342         StripElem *new_seq, *se;
343
344         if (seq->len == 1) {
345                 BKE_report(reports, RPT_ERROR, "SequenceElements.pop: can not pop the last element");
346                 return;
347         }
348
349         /* python style negative indexing */
350         if (index < 0) {
351                 index += seq->len;
352         }
353
354         if (seq->len <= index || index < 0) {
355                 BKE_report(reports, RPT_ERROR, "SequenceElements.pop: index out of range");
356                 return;
357         }
358
359         new_seq = MEM_callocN(sizeof(StripElem) * (seq->len - 1), "SequenceElements_pop");
360         seq->len--;
361
362         se = seq->strip->stripdata;
363         if (index > 0)
364                 memcpy(new_seq, se, sizeof(StripElem) * index);
365
366         if (index < seq->len)
367                 memcpy(&new_seq[index], &se[index + 1], sizeof(StripElem) * (seq->len - index));
368
369         MEM_freeN(seq->strip->stripdata);
370         seq->strip->stripdata = new_seq;
371
372         BKE_sequence_calc_disp(scene, seq);
373
374         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
375 }
376
377
378 #else
379
380 void RNA_api_sequence_strip(StructRNA *srna)
381 {
382         FunctionRNA *func;
383         PropertyRNA *parm;
384
385         func = RNA_def_function(srna, "getStripElem", "BKE_sequencer_give_stripelem");
386         RNA_def_function_ui_description(func, "Return the strip element from a given frame or None");
387         parm = RNA_def_int(func, "frame", 0, -MAXFRAME, MAXFRAME, "Frame",
388                            "The frame to get the strip element from", -MAXFRAME, MAXFRAME);
389         RNA_def_property_flag(parm, PROP_REQUIRED);
390         RNA_def_function_return(func, RNA_def_pointer(func, "elem", "SequenceElement", "",
391                                                       "strip element of the current frame"));
392
393         func = RNA_def_function(srna, "swap", "rna_Sequence_swap_internal");
394         RNA_def_function_flag(func, FUNC_USE_REPORTS);
395         parm = RNA_def_pointer(func, "other", "Sequence", "Other", "");
396         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
397 }
398
399 void RNA_api_sequence_elements(BlenderRNA *brna, PropertyRNA *cprop)
400 {
401         StructRNA *srna;
402         PropertyRNA *parm;
403         FunctionRNA *func;
404
405         RNA_def_property_srna(cprop, "SequenceElements");
406         srna = RNA_def_struct(brna, "SequenceElements", NULL);
407         RNA_def_struct_sdna(srna, "Sequence");
408         RNA_def_struct_ui_text(srna, "SequenceElements", "Collection of SequenceElement");
409
410         func = RNA_def_function(srna, "push", "rna_SequenceElements_push");
411         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
412         RNA_def_function_ui_description(func, "Push an image from ImageSequence.directory");
413         parm = RNA_def_string(func, "filename", "File", 0, "", "Filepath to image");
414         RNA_def_property_flag(parm, PROP_REQUIRED);
415         /* return type */
416         parm = RNA_def_pointer(func, "elem", "SequenceElement", "", "New SequenceElement");
417         RNA_def_function_return(func, parm);
418
419         func = RNA_def_function(srna, "pop", "rna_SequenceElements_pop");
420         RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
421         RNA_def_function_ui_description(func, "Pop an image off the collection");
422         parm = RNA_def_int(func, "index", -1, INT_MIN, INT_MAX, "", "Index of image to remove", INT_MIN, INT_MAX);
423         RNA_def_property_flag(parm, PROP_REQUIRED);
424 }
425
426 void RNA_api_sequences(BlenderRNA *brna, PropertyRNA *cprop)
427 {
428         StructRNA *srna;
429         PropertyRNA *parm;
430         FunctionRNA *func;
431
432         static EnumPropertyItem seq_effect_items[] = {
433                 {SEQ_TYPE_CROSS, "CROSS", 0, "Cross", ""},
434                 {SEQ_TYPE_ADD, "ADD", 0, "Add", ""},
435                 {SEQ_TYPE_SUB, "SUBTRACT", 0, "Subtract", ""},
436                 {SEQ_TYPE_ALPHAOVER, "ALPHA_OVER", 0, "Alpha Over", ""},
437                 {SEQ_TYPE_ALPHAUNDER, "ALPHA_UNDER", 0, "Alpha Under", ""},
438                 {SEQ_TYPE_GAMCROSS, "GAMMA_CROSS", 0, "Gamma Cross", ""},
439                 {SEQ_TYPE_MUL, "MULTIPLY", 0, "Multiply", ""},
440                 {SEQ_TYPE_OVERDROP, "OVER_DROP", 0, "Over Drop", ""},
441                 {SEQ_TYPE_WIPE, "WIPE", 0, "Wipe", ""},
442                 {SEQ_TYPE_GLOW, "GLOW", 0, "Glow", ""},
443                 {SEQ_TYPE_TRANSFORM, "TRANSFORM", 0, "Transform", ""},
444                 {SEQ_TYPE_COLOR, "COLOR", 0, "Color", ""},
445                 {SEQ_TYPE_SPEED, "SPEED", 0, "Speed", ""},
446                 {SEQ_TYPE_MULTICAM, "MULTICAM", 0, "Multicam Selector", ""},
447                 {SEQ_TYPE_ADJUSTMENT, "ADJUSTMENT", 0, "Adjustment Layer", ""},
448                 {0, NULL, 0, NULL, NULL}
449         };
450
451         RNA_def_property_srna(cprop, "Sequences");
452         srna = RNA_def_struct(brna, "Sequences", NULL);
453         RNA_def_struct_sdna(srna, "Editing");
454         RNA_def_struct_ui_text(srna, "Sequences", "Collection of Sequences");
455
456         func = RNA_def_function(srna, "new_clip", "rna_Sequences_new_clip");
457         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
458         RNA_def_function_ui_description(func, "Add a new movie clip sequence");
459         parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the sequence");
460         RNA_def_property_flag(parm, PROP_REQUIRED);
461         parm = RNA_def_pointer(func, "clip", "MovieClip", "", "Movie clip to add");
462         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
463         parm = RNA_def_int(func, "channel", 0, 0, MAXSEQ - 1, "Channel",
464                            "The channel for the new sequence", 0, MAXSEQ - 1);
465         RNA_def_property_flag(parm, PROP_REQUIRED);
466         parm = RNA_def_int(func, "start_frame", 0, -MAXFRAME, MAXFRAME, "",
467                            "The start frame for the new sequence", -MAXFRAME, MAXFRAME);
468         RNA_def_property_flag(parm, PROP_REQUIRED);
469         /* return type */
470         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "New Sequence");
471         RNA_def_function_return(func, parm);
472
473         func = RNA_def_function(srna, "new_mask", "rna_Sequences_new_mask");
474         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
475         RNA_def_function_ui_description(func, "Add a new movie clip sequence");
476         parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the sequence");
477         RNA_def_property_flag(parm, PROP_REQUIRED);
478         parm = RNA_def_pointer(func, "mask", "Mask", "", "Mask to add");
479         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
480         parm = RNA_def_int(func, "channel", 0, 0, MAXSEQ - 1, "Channel",
481                            "The channel for the new sequence", 0, MAXSEQ - 1);
482         RNA_def_property_flag(parm, PROP_REQUIRED);
483         parm = RNA_def_int(func, "start_frame", 0, -MAXFRAME, MAXFRAME, "",
484                            "The start frame for the new sequence", -MAXFRAME, MAXFRAME);
485         RNA_def_property_flag(parm, PROP_REQUIRED);
486         /* return type */
487         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "New Sequence");
488         RNA_def_function_return(func, parm);
489
490         func = RNA_def_function(srna, "new_scene", "rna_Sequences_new_scene");
491         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
492         RNA_def_function_ui_description(func, "Add a new scene sequence");
493         parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the sequence");
494         RNA_def_property_flag(parm, PROP_REQUIRED);
495         parm = RNA_def_pointer(func, "scene", "Scene", "", "Scene to add");
496         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
497         parm = RNA_def_int(func, "channel", 0, 0, MAXSEQ - 1, "Channel",
498                            "The channel for the new sequence", 0, MAXSEQ - 1);
499         RNA_def_property_flag(parm, PROP_REQUIRED);
500         parm = RNA_def_int(func, "start_frame", 0, -MAXFRAME, MAXFRAME, "",
501                            "The start frame for the new sequence", -MAXFRAME, MAXFRAME);
502         RNA_def_property_flag(parm, PROP_REQUIRED);
503         /* return type */
504         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "New Sequence");
505         RNA_def_function_return(func, parm);
506
507         func = RNA_def_function(srna, "new_image", "rna_Sequences_new_image");
508         RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
509         RNA_def_function_ui_description(func, "Add a new image sequence");
510         parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the sequence");
511         RNA_def_property_flag(parm, PROP_REQUIRED);
512         parm = RNA_def_string(func, "filepath", "File", 0, "", "Filepath to image");
513         RNA_def_property_flag(parm, PROP_REQUIRED);
514         parm = RNA_def_int(func, "channel", 0, 0, MAXSEQ - 1, "Channel",
515                            "The channel for the new sequence", 0, MAXSEQ - 1);
516         RNA_def_property_flag(parm, PROP_REQUIRED);
517         parm = RNA_def_int(func, "start_frame", 0, -MAXFRAME, MAXFRAME, "",
518                            "The start frame for the new sequence", -MAXFRAME, MAXFRAME);
519         RNA_def_property_flag(parm, PROP_REQUIRED);
520         /* return type */
521         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "New Sequence");
522         RNA_def_function_return(func, parm);
523
524         func = RNA_def_function(srna, "new_movie", "rna_Sequences_new_movie");
525         RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
526         RNA_def_function_ui_description(func, "Add a new movie sequence");
527         parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the sequence");
528         RNA_def_property_flag(parm, PROP_REQUIRED);
529         parm = RNA_def_string(func, "filepath", "File", 0, "", "Filepath to movie");
530         RNA_def_property_flag(parm, PROP_REQUIRED);
531         parm = RNA_def_int(func, "channel", 0, 0, MAXSEQ - 1, "Channel",
532                            "The channel for the new sequence", 0, MAXSEQ - 1);
533         RNA_def_property_flag(parm, PROP_REQUIRED);
534         parm = RNA_def_int(func, "start_frame", 0, -MAXFRAME, MAXFRAME, "",
535                            "The start frame for the new sequence", -MAXFRAME, MAXFRAME);
536         RNA_def_property_flag(parm, PROP_REQUIRED);
537         /* return type */
538         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "New Sequence");
539         RNA_def_function_return(func, parm);
540
541         func = RNA_def_function(srna, "new_sound", "rna_Sequences_new_sound");
542         RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID | FUNC_USE_MAIN);
543         RNA_def_function_ui_description(func, "Add a new movie clip sequence");
544         parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the sequence");
545         RNA_def_property_flag(parm, PROP_REQUIRED);
546         parm = RNA_def_string(func, "filepath", "File", 0, "", "Filepath to movie");
547         RNA_def_property_flag(parm, PROP_REQUIRED);
548         parm = RNA_def_int(func, "channel", 0, 0, MAXSEQ - 1, "Channel",
549                            "The channel for the new sequence", 0, MAXSEQ - 1);
550         RNA_def_property_flag(parm, PROP_REQUIRED);
551         parm = RNA_def_int(func, "start_frame", 0, -MAXFRAME, MAXFRAME, "",
552                            "The start frame for the new sequence", -MAXFRAME, MAXFRAME);
553         RNA_def_property_flag(parm, PROP_REQUIRED);
554         /* return type */
555         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "New Sequence");
556         RNA_def_function_return(func, parm);
557
558         func = RNA_def_function(srna, "new_effect", "rna_Sequences_new_effect");
559         RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
560         RNA_def_function_ui_description(func, "Add a new effect sequence");
561         parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the sequence");
562         RNA_def_property_flag(parm, PROP_REQUIRED);
563         parm = RNA_def_enum(func, "type", seq_effect_items, 0, "Type",
564                             "type for the new sequence");
565         RNA_def_property_flag(parm, PROP_REQUIRED);
566         parm = RNA_def_int(func, "channel", 0, 0, MAXSEQ - 1, "Channel",
567                            "The channel for the new sequence", 0, MAXSEQ - 1);
568         RNA_def_property_flag(parm, PROP_REQUIRED);
569         parm = RNA_def_int(func, "start_frame", 0, -MAXFRAME, MAXFRAME, "",
570                            "The start frame for the new sequence", -MAXFRAME, MAXFRAME);
571         RNA_def_property_flag(parm, PROP_REQUIRED);
572         parm = RNA_def_int(func, "end_frame", 0, -MAXFRAME, MAXFRAME, "",
573                            "The end frame for the new sequence", -MAXFRAME, MAXFRAME);
574         parm = RNA_def_pointer(func, "seq1", "Sequence", "", "Sequence 1 for effect");
575         parm = RNA_def_pointer(func, "seq2", "Sequence", "", "Sequence 2 for effect");
576         parm = RNA_def_pointer(func, "seq3", "Sequence", "", "Sequence 3 for effect");
577         /* return type */
578         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "New Sequence");
579         RNA_def_function_return(func, parm);
580
581
582         func = RNA_def_function(srna, "remove", "rna_Sequences_remove");
583         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
584         RNA_def_function_ui_description(func, "Remove a Sequence");
585         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "Sequence to remove");
586         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
587 }
588
589
590 #endif