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