Massive Code cleanup:
[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 "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 extern EnumPropertyItem blend_mode_items[];
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_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
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 (seq_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 = alloc_sequence(ed->seqbasep, start_frame, channel);
81         seq->type = type;
82
83         BLI_strncpy(seq->name + 2, name, sizeof(seq->name) - 2);
84         seqbase_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, ReportList *reports,
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_MOVIECLIP, clip->name);
108         seq->clip = clip;
109         seq->len =  BKE_movieclip_get_duration(clip);
110         id_us_plus((ID *)clip);
111
112         calc_sequence_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_scene(ID *id, Editing *ed, ReportList *reports,
120                                          const char *name, Scene *sce_seq, 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_SCENE, NULL);
127         seq->scene = sce_seq;
128         seq->len = sce_seq->r.efra - sce_seq->r.sfra + 1;
129         seq->scene_sound = sound_scene_add_scene_sound(scene, seq, start_frame, start_frame + seq->len, 0);
130         id_us_plus((ID *)sce_seq);
131
132         calc_sequence_disp(scene, seq);
133
134         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
135
136         return seq;
137 }
138
139 static Sequence *rna_Sequences_new_image(ID *id, Editing *ed, ReportList *reports,
140                                          const char *name, const char *file, int channel,
141                                          int start_frame)
142 {
143         Scene *scene = (Scene *)id;
144         Sequence *seq;
145
146         seq = alloc_generic_sequence(ed, name, start_frame, channel, SEQ_IMAGE, file);
147         seq->len = 1;
148
149         if (seq->strip->stripdata->name[0] == '\0') {
150                 BKE_report(reports, RPT_ERROR, "Sequences.new_image: unable to open image file");
151                 BLI_remlink(&ed->seqbase, seq);
152                 seq_free_sequence(scene, seq);
153                 return NULL;
154         }
155
156         calc_sequence_disp(scene, seq);
157
158         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
159
160         return seq;
161 }
162
163 static Sequence *rna_Sequences_new_movie(ID *id, Editing *ed, ReportList *reports,
164                                          const char *name, const char *file, int channel,
165                                          int start_frame)
166 {
167         Scene *scene = (Scene *)id;
168         Sequence *seq;
169
170         struct anim *an = openanim(file, IB_rect, 0);
171
172         if (an == NULL) {
173                 BKE_report(reports, RPT_ERROR, "Sequences.new_movie: unable to open movie file");
174                 return NULL;
175         }
176
177         seq = alloc_generic_sequence(ed, name, start_frame, channel, SEQ_MOVIE, file);
178         seq->anim = an;
179         seq->anim_preseek = IMB_anim_get_preseek(an);
180         seq->len = IMB_anim_get_duration(an, IMB_TC_RECORD_RUN);
181
182         calc_sequence_disp(scene, seq);
183
184         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
185
186         return seq;
187 }
188
189 #ifdef WITH_AUDASPACE
190 static Sequence *rna_Sequences_new_sound(ID *id, Editing *ed, Main *bmain, ReportList *reports,
191                                          const char *name, const char *file, int channel, int start_frame)
192 {
193         Scene *scene = (Scene *)id;
194         Sequence *seq;
195
196         bSound *sound = sound_new_file(bmain, file);
197
198         if (sound == NULL || sound->playback_handle == NULL) {
199                 BKE_report(reports, RPT_ERROR, "Sequences.new_sound: unable to open sound file");
200                 return NULL;
201         }
202
203         seq = alloc_generic_sequence(ed, name, start_frame, channel, SEQ_SOUND, sound->name);
204         seq->sound = sound;
205         seq->len = ceil((double)sound_get_length(sound) * FPS);
206
207         seq->scene_sound = sound_add_scene_sound(scene, seq, start_frame, start_frame + seq->len, 0);
208
209         calc_sequence_disp(scene, seq);
210
211         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
212
213         return seq;
214 }
215 #else /* WITH_AUDASPACE */
216 static Sequence *rna_Sequences_new_sound(ID *UNUSED(id), Editing *UNUSED(ed), Main *UNUSED(bmain), ReportList *reports,
217                                          const char *UNUSED(name), const char *UNUSED(file), int UNUSED(channel), int UNUSED(start_frame))
218 {
219         BKE_report(reports, RPT_ERROR, "Blender compiled without Audaspace support.");
220         return NULL;
221 }
222 #endif /* WITH_AUDASPACE */
223
224 static Sequence *rna_Sequences_new_effect(ID *id, Editing *ed, ReportList *reports,
225                                           const char *name, int type, int channel,
226                                           int start_frame, int end_frame,
227                                           Sequence *seq1, Sequence *seq2, Sequence *seq3)
228 {
229         Scene *scene = (Scene *)id;
230         Sequence *seq;
231         struct SeqEffectHandle sh;
232
233         switch (get_sequence_effect_num_inputs(type)) {
234                 case 0:
235                         if (end_frame <= start_frame) {
236                                 BKE_report(reports, RPT_ERROR,
237                                            "Sequences.new_effect: End frame not set");
238                                 return NULL;
239                         }
240                         break;
241                 case 1:
242                         if (seq1 == NULL) {
243                                 BKE_report(reports, RPT_ERROR,
244                                            "Sequences.new_effect: Effect takes 1 input sequence");
245                                 return NULL;
246                         }
247                         break;
248                 case 2:
249                         if (seq1 == NULL || seq2 == NULL) {
250                                 BKE_report(reports, RPT_ERROR,
251                                            "Sequences.new_effect: Effect takes 2 input sequences");
252                                 return NULL;
253                         }
254                         break;
255                 case 3:
256                         if (seq1 == NULL || seq2 == NULL || seq3 == NULL) {
257                                 BKE_report(reports, RPT_ERROR,
258                                            "Sequences.new_effect: Effect takes 3 input sequences");
259                                 return NULL;
260                         }
261                         break;
262                 default:
263                         BKE_report(reports, RPT_ERROR,
264                                    "Sequences.new_effect: get_sequence_effect_num_inputs() > 3 (should never happen)");
265                         return NULL;
266         }
267
268         seq = alloc_generic_sequence(ed, name, start_frame, channel, type, NULL);
269
270         sh = get_sequence_effect(seq);
271
272         seq->seq1 = seq1;
273         seq->seq2 = seq2;
274         seq->seq3 = seq3;
275
276         sh.init(seq);
277
278         if (!seq1) { /* effect has no deps */
279                 seq->len = 1;
280                 seq_tx_set_final_right(seq, end_frame);
281         }
282
283         seq->flag |= SEQ_USE_EFFECT_DEFAULT_FADE;
284
285         calc_sequence(scene, seq);
286
287         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
288
289         return seq;
290 }
291
292 static void rna_Sequences_remove(ID *id, Editing *ed, Sequence *seq)
293 {
294         Scene *scene = (Scene *)id;
295
296         BLI_remlink(&ed->seqbase, seq);
297         seq_free_sequence(scene, seq);
298
299         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
300 }
301
302 static StripElem *rna_SequenceElements_push(ID *id, Sequence *seq, const char *filename)
303 {
304         Scene *scene = (Scene *)id;
305         StripElem *se;
306
307         seq->strip->stripdata = se = MEM_reallocN(seq->strip->stripdata, sizeof(StripElem) * (seq->len + 1));
308         se += seq->len;
309         BLI_strncpy(se->name, filename, sizeof(se->name));
310         seq->len++;
311
312         calc_sequence_disp(scene, seq);
313
314         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
315
316         return se;
317 }
318
319 static void rna_SequenceElements_pop(ID *id, Sequence *seq, ReportList *reports, int index)
320 {
321         int i;
322         Scene *scene = (Scene *)id;
323         StripElem *new_seq, *se;
324
325         if (seq->len == 1) {
326                 BKE_report(reports, RPT_ERROR, "SequenceElements.pop: can not pop the last element");
327                 return;
328         }
329
330         if (seq->len <= index) {
331                 BKE_report(reports, RPT_ERROR, "SequenceElements.pop: index out of range");
332                 return;
333         }
334
335         new_seq = MEM_callocN(sizeof(StripElem) * (seq->len - 1), "SequenceElements_pop");
336         seq->len--;
337
338         for (i = 0, se = seq->strip->stripdata; i < seq->len; i++, se++) {
339                 if (i == index)
340                         se++;
341                 BLI_strncpy(new_seq[i].name, se->name, sizeof(se->name));
342         }
343
344         MEM_freeN(seq->strip->stripdata);
345         seq->strip->stripdata = new_seq;
346
347         calc_sequence_disp(scene, seq);
348
349         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, scene);
350 }
351
352
353 #else
354
355 void RNA_api_sequence_strip(StructRNA *srna)
356 {
357         FunctionRNA *func;
358         PropertyRNA *parm;
359
360         func = RNA_def_function(srna, "getStripElem", "give_stripelem");
361         RNA_def_function_ui_description(func, "Return the strip element from a given frame or None");
362         parm = RNA_def_int(func, "frame", 0, -MAXFRAME, MAXFRAME, "Frame",
363                            "The frame to get the strip element from", -MAXFRAME, MAXFRAME);
364         RNA_def_property_flag(parm, PROP_REQUIRED);
365         RNA_def_function_return(func, RNA_def_pointer(func, "elem", "SequenceElement", "",
366                                                       "strip element of the current frame"));
367
368         func = RNA_def_function(srna, "swap", "rna_Sequence_swap_internal");
369         RNA_def_function_flag(func, FUNC_USE_REPORTS);
370         parm = RNA_def_pointer(func, "other", "Sequence", "Other", "");
371         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
372 }
373
374 void RNA_api_sequence_elements(BlenderRNA *brna, PropertyRNA *cprop)
375 {
376         StructRNA *srna;
377         PropertyRNA *parm;
378         FunctionRNA *func;
379
380         RNA_def_property_srna(cprop, "SequenceElements");
381         srna = RNA_def_struct(brna, "SequenceElements", NULL);
382         RNA_def_struct_sdna(srna, "Sequence");
383         RNA_def_struct_ui_text(srna, "SequenceElements", "Collection of SequenceElement");
384
385         func = RNA_def_function(srna, "push", "rna_SequenceElements_push");
386         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
387         RNA_def_function_ui_description(func, "Push an image from ImageSequence.directory");
388         parm = RNA_def_string(func, "filename", "File", 0, "", "Filepath to image");
389         RNA_def_property_flag(parm, PROP_REQUIRED);
390         /* return type */
391         parm = RNA_def_pointer(func, "elem", "SequenceElement", "", "New SequenceElement");
392         RNA_def_function_return(func, parm);
393
394         func = RNA_def_function(srna, "pop", "rna_SequenceElements_pop");
395         RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
396         RNA_def_function_ui_description(func, "Pop an image off the collection");
397         parm = RNA_def_int(func, "index", 0, 0, INT_MAX, "", "Index of image to remove", 0, INT_MAX);
398         RNA_def_property_flag(parm, PROP_REQUIRED);
399 }
400
401 void RNA_api_sequences(BlenderRNA *brna, PropertyRNA *cprop)
402 {
403         StructRNA *srna;
404         PropertyRNA *parm;
405         FunctionRNA *func;
406
407         static EnumPropertyItem seq_effect_items[] = {
408                 {SEQ_CROSS, "CROSS", 0, "Cross", ""},
409                 {SEQ_ADD, "ADD", 0, "Add", ""},
410                 {SEQ_SUB, "SUBTRACT", 0, "Subtract", ""},
411                 {SEQ_ALPHAOVER, "ALPHA_OVER", 0, "Alpha Over", ""},
412                 {SEQ_ALPHAUNDER, "ALPHA_UNDER", 0, "Alpha Under", ""},
413                 {SEQ_GAMCROSS, "GAMMA_CROSS", 0, "Gamma Cross", ""},
414                 {SEQ_MUL, "MULTIPLY", 0, "Multiply", ""},
415                 {SEQ_OVERDROP, "OVER_DROP", 0, "Over Drop", ""},
416                 {SEQ_WIPE, "WIPE", 0, "Wipe", ""},
417                 {SEQ_GLOW, "GLOW", 0, "Glow", ""},
418                 {SEQ_TRANSFORM, "TRANSFORM", 0, "Transform", ""},
419                 {SEQ_COLOR, "COLOR", 0, "Color", ""},
420                 {SEQ_SPEED, "SPEED", 0, "Speed", ""},
421                 {SEQ_MULTICAM, "MULTICAM", 0, "Multicam Selector", ""},
422                 {SEQ_ADJUSTMENT, "ADJUSTMENT", 0, "Adjustment Layer", ""},
423                 {0, NULL, 0, NULL, NULL}
424         };
425
426         RNA_def_property_srna(cprop, "Sequences");
427         srna = RNA_def_struct(brna, "Sequences", NULL);
428         RNA_def_struct_sdna(srna, "Editing");
429         RNA_def_struct_ui_text(srna, "Sequences", "Collection of Sequences");
430
431         func = RNA_def_function(srna, "new_clip", "rna_Sequences_new_clip");
432         RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
433         RNA_def_function_ui_description(func, "Add a new movie clip sequence");
434         parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the sequence");
435         RNA_def_property_flag(parm, PROP_REQUIRED);
436         parm = RNA_def_pointer(func, "clip", "MovieClip", "", "Movie clip to add");
437         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
438         parm = RNA_def_int(func, "channel", 0, 0, MAXSEQ - 1, "Channel",
439                            "The channel for the new sequence", 0, MAXSEQ - 1);
440         RNA_def_property_flag(parm, PROP_REQUIRED);
441         parm = RNA_def_int(func, "start_frame", 0, -MAXFRAME, MAXFRAME, "",
442                            "The start frame for the new sequence", -MAXFRAME, MAXFRAME);
443         RNA_def_property_flag(parm, PROP_REQUIRED);
444         /* return type */
445         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "New Sequence");
446         RNA_def_function_return(func, parm);
447
448         func = RNA_def_function(srna, "new_scene", "rna_Sequences_new_scene");
449         RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
450         RNA_def_function_ui_description(func, "Add a new scene sequence");
451         parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the sequence");
452         RNA_def_property_flag(parm, PROP_REQUIRED);
453         parm = RNA_def_pointer(func, "scene", "Scene", "", "Scene to add");
454         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
455         parm = RNA_def_int(func, "channel", 0, 0, MAXSEQ - 1, "Channel",
456                            "The channel for the new sequence", 0, MAXSEQ - 1);
457         RNA_def_property_flag(parm, PROP_REQUIRED);
458         parm = RNA_def_int(func, "start_frame", 0, -MAXFRAME, MAXFRAME, "",
459                            "The start frame for the new sequence", -MAXFRAME, MAXFRAME);
460         RNA_def_property_flag(parm, PROP_REQUIRED);
461         /* return type */
462         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "New Sequence");
463         RNA_def_function_return(func, parm);
464
465         func = RNA_def_function(srna, "new_image", "rna_Sequences_new_image");
466         RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
467         RNA_def_function_ui_description(func, "Add a new image sequence");
468         parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the sequence");
469         RNA_def_property_flag(parm, PROP_REQUIRED);
470         parm = RNA_def_string(func, "filepath", "File", 0, "", "Filepath to image");
471         RNA_def_property_flag(parm, PROP_REQUIRED);
472         parm = RNA_def_int(func, "channel", 0, 0, MAXSEQ - 1, "Channel",
473                            "The channel for the new sequence", 0, MAXSEQ - 1);
474         RNA_def_property_flag(parm, PROP_REQUIRED);
475         parm = RNA_def_int(func, "start_frame", 0, -MAXFRAME, MAXFRAME, "",
476                            "The start frame for the new sequence", -MAXFRAME, MAXFRAME);
477         RNA_def_property_flag(parm, PROP_REQUIRED);
478         /* return type */
479         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "New Sequence");
480         RNA_def_function_return(func, parm);
481
482         func = RNA_def_function(srna, "new_movie", "rna_Sequences_new_movie");
483         RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
484         RNA_def_function_ui_description(func, "Add a new movie sequence");
485         parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the sequence");
486         RNA_def_property_flag(parm, PROP_REQUIRED);
487         parm = RNA_def_string(func, "filepath", "File", 0, "", "Filepath to movie");
488         RNA_def_property_flag(parm, PROP_REQUIRED);
489         parm = RNA_def_int(func, "channel", 0, 0, MAXSEQ - 1, "Channel",
490                            "The channel for the new sequence", 0, MAXSEQ - 1);
491         RNA_def_property_flag(parm, PROP_REQUIRED);
492         parm = RNA_def_int(func, "start_frame", 0, -MAXFRAME, MAXFRAME, "",
493                            "The start frame for the new sequence", -MAXFRAME, MAXFRAME);
494         RNA_def_property_flag(parm, PROP_REQUIRED);
495         /* return type */
496         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "New Sequence");
497         RNA_def_function_return(func, parm);
498
499         func = RNA_def_function(srna, "new_sound", "rna_Sequences_new_sound");
500         RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID | FUNC_USE_MAIN);
501         RNA_def_function_ui_description(func, "Add a new movie clip sequence");
502         parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the sequence");
503         RNA_def_property_flag(parm, PROP_REQUIRED);
504         parm = RNA_def_string(func, "filepath", "File", 0, "", "Filepath to movie");
505         RNA_def_property_flag(parm, PROP_REQUIRED);
506         parm = RNA_def_int(func, "channel", 0, 0, MAXSEQ - 1, "Channel",
507                            "The channel for the new sequence", 0, MAXSEQ - 1);
508         RNA_def_property_flag(parm, PROP_REQUIRED);
509         parm = RNA_def_int(func, "start_frame", 0, -MAXFRAME, MAXFRAME, "",
510                            "The start frame for the new sequence", -MAXFRAME, MAXFRAME);
511         RNA_def_property_flag(parm, PROP_REQUIRED);
512         /* return type */
513         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "New Sequence");
514         RNA_def_function_return(func, parm);
515
516         func = RNA_def_function(srna, "new_effect", "rna_Sequences_new_effect");
517         RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
518         RNA_def_function_ui_description(func, "Add a new effect sequence");
519         parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the sequence");
520         RNA_def_property_flag(parm, PROP_REQUIRED);
521         parm = RNA_def_enum(func, "type", seq_effect_items, 0, "Type",
522                             "type for the new sequence");
523         RNA_def_property_flag(parm, PROP_REQUIRED);
524         parm = RNA_def_int(func, "channel", 0, 0, MAXSEQ - 1, "Channel",
525                            "The channel for the new sequence", 0, MAXSEQ - 1);
526         RNA_def_property_flag(parm, PROP_REQUIRED);
527         parm = RNA_def_int(func, "start_frame", 0, -MAXFRAME, MAXFRAME, "",
528                            "The start frame for the new sequence", -MAXFRAME, MAXFRAME);
529         RNA_def_property_flag(parm, PROP_REQUIRED);
530         parm = RNA_def_int(func, "end_frame", 0, -MAXFRAME, MAXFRAME, "",
531                            "The end frame for the new sequence", -MAXFRAME, MAXFRAME);
532         parm = RNA_def_pointer(func, "seq1", "Sequence", "", "Sequence 1 for effect");
533         parm = RNA_def_pointer(func, "seq2", "Sequence", "", "Sequence 2 for effect");
534         parm = RNA_def_pointer(func, "seq3", "Sequence", "", "Sequence 3 for effect");
535         /* return type */
536         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "New Sequence");
537         RNA_def_function_return(func, parm);
538
539
540         func = RNA_def_function(srna, "remove", "rna_Sequences_remove");
541         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
542         RNA_def_function_ui_description(func, "Remove a Sequence");
543         parm = RNA_def_pointer(func, "sequence", "Sequence", "", "Sequence to remove");
544         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL);
545 }
546
547
548 #endif