2.5 filebrowser
[blender.git] / source / blender / editors / space_sequencer / sequencer_add.c
1 /**
2  *
3  * ***** BEGIN GPL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software Foundation,
17  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18  *
19  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
20  * All rights reserved.
21  *
22  * Contributor(s): Blender Foundation, 2003-2009, Campbell Barton
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 #include <stdlib.h>
28 #include <math.h>
29 #include <string.h>
30
31 #ifndef WIN32
32 #include <unistd.h>
33 #else
34 #include <io.h>
35 #endif
36 #include <sys/types.h>
37
38 #include "MEM_guardedalloc.h"
39
40 #include "BLI_blenlib.h"
41 #include "BLI_arithb.h"
42 #include "BLI_storage_types.h"
43
44 #include "IMB_imbuf_types.h"
45 #include "IMB_imbuf.h"
46
47 #include "DNA_ipo_types.h"
48 #include "DNA_curve_types.h"
49 #include "DNA_scene_types.h"
50 #include "DNA_screen_types.h"
51 #include "DNA_space_types.h"
52 #include "DNA_sequence_types.h"
53 #include "DNA_view2d_types.h"
54 #include "DNA_userdef_types.h"
55 #include "DNA_sound_types.h"
56
57 #include "BKE_context.h"
58 #include "BKE_global.h"
59 #include "BKE_image.h"
60 #include "BKE_library.h"
61 #include "BKE_main.h"
62 #include "BKE_plugin_types.h"
63 #include "BKE_sequence.h"
64 #include "BKE_scene.h"
65 #include "BKE_utildefines.h"
66 #include "BKE_report.h"
67
68 #include "BIF_gl.h"
69 #include "BIF_glutil.h"
70
71 #include "WM_api.h"
72 #include "WM_types.h"
73
74 #include "RNA_access.h"
75 #include "RNA_define.h"
76
77 /* for menu/popup icons etc etc*/
78 #include "UI_interface.h"
79 #include "UI_resources.h"
80
81 #include "ED_anim_api.h"
82 #include "ED_space_api.h"
83 #include "ED_types.h"
84 #include "ED_screen.h"
85 #include "ED_util.h"
86 #include "ED_fileselect.h"
87
88 #include "UI_interface.h"
89 #include "UI_resources.h"
90 #include "UI_view2d.h"
91
92 #include "BKE_sound.h"
93 #include "AUD_C-API.h"
94
95 /* own include */
96 #include "sequencer_intern.h"
97
98 /* Generic functions, reused by add strip operators */
99
100 /* avoid passing multiple args and be more verbose */
101 #define SEQPROP_STARTFRAME      1<<0
102 #define SEQPROP_ENDFRAME        1<<1
103
104 static void sequencer_generic_props__internal(wmOperatorType *ot, int flag)
105 {
106         RNA_def_string(ot->srna, "name", "", MAX_ID_NAME-2, "Name", "Name of the new sequence strip");
107
108         if(flag & SEQPROP_STARTFRAME)
109                 RNA_def_int(ot->srna, "start_frame", 0, INT_MIN, INT_MAX, "Start Frame", "Start frame of the sequence strip", INT_MIN, INT_MAX);
110         
111         if(flag & SEQPROP_ENDFRAME)
112                 RNA_def_int(ot->srna, "end_frame", 0, INT_MIN, INT_MAX, "End Frame", "End frame for the color strip", INT_MIN, INT_MAX); /* not useual since most strips have a fixed length */
113         
114         RNA_def_int(ot->srna, "channel", 1, 1, MAXSEQ, "Channel", "Channel to place this strip into", 1, MAXSEQ);
115         
116         RNA_def_boolean(ot->srna, "replace_sel", 1, "Replace Selection", "replace the current selection");
117 }
118
119 static void sequencer_generic_invoke_xy__internal(bContext *C, wmOperator *op, wmEvent *event, int flag)
120 {
121         ARegion *ar= CTX_wm_region(C);
122         View2D *v2d= UI_view2d_fromcontext(C);
123         
124         short mval[2];  
125         float mval_v2d[2];
126         
127
128         mval[0]= event->x - ar->winrct.xmin;
129         mval[1]= event->y - ar->winrct.ymin;
130         
131         UI_view2d_region_to_view(v2d, mval[0], mval[1], &mval_v2d[0], &mval_v2d[1]);
132         
133         RNA_int_set(op->ptr, "channel", (int)mval_v2d[1]+0.5f);
134         RNA_int_set(op->ptr, "start_frame", (int)mval_v2d[0]);
135         
136         if ((flag & SEQPROP_ENDFRAME) && RNA_property_is_set(op->ptr, "end_frame")==0)
137                 RNA_int_set(op->ptr, "end_frame", (int)mval_v2d[0] + 25); // XXX arbitary but ok for now.
138         
139 }
140
141 /* add scene operator */
142 static int sequencer_add_scene_strip_exec(bContext *C, wmOperator *op)
143 {
144         Scene *scene= CTX_data_scene(C);
145         Editing *ed= seq_give_editing(scene, TRUE);
146         
147         Scene *sce_seq;
148         char sce_name[MAX_ID_NAME-2];
149         
150         Sequence *seq;  /* generic strip vars */
151         Strip *strip;
152         StripElem *se;
153         
154         int start_frame, channel; /* operator props */
155         
156         start_frame= RNA_int_get(op->ptr, "start_frame");
157         channel= RNA_int_get(op->ptr, "channel");
158         
159         RNA_string_get(op->ptr, "scene", sce_name);
160
161         sce_seq= (Scene *)find_id("SC", sce_name);
162         
163         if (sce_seq==NULL) {
164                 BKE_reportf(op->reports, RPT_ERROR, "Scene \"%s\" not found", sce_name);
165                 return OPERATOR_CANCELLED;
166         }
167         
168         seq = alloc_sequence(ed->seqbasep, start_frame, channel);
169         
170         seq->type= SEQ_SCENE;
171         seq->scene= sce_seq;
172         
173         /* basic defaults */
174         seq->strip= strip= MEM_callocN(sizeof(Strip), "strip");
175         strip->len = seq->len = sce_seq->r.efra - sce_seq->r.sfra + 1;
176         strip->us= 1;
177         
178         strip->stripdata= se= MEM_callocN(seq->len*sizeof(StripElem), "stripelem");
179         
180         
181         RNA_string_get(op->ptr, "name", seq->name);
182         
183         calc_sequence_disp(seq);
184         sort_seq(scene);
185         
186         if (RNA_boolean_get(op->ptr, "replace_sel")) {
187                 deselect_all_seq(scene);
188                 set_last_seq(scene, seq);
189                 seq->flag |= SELECT;
190         }
191         
192         ED_area_tag_redraw(CTX_wm_area(C));
193         
194         return OPERATOR_FINISHED;
195 }
196
197
198 static int sequencer_add_scene_strip_invoke(bContext *C, wmOperator *op, wmEvent *event)
199 {
200         sequencer_generic_invoke_xy__internal(C, op, event, 0);
201         
202         /* scene can be left default */
203         RNA_string_set(op->ptr, "scene", "Scene"); // XXX should popup a menu but ton says 2.5 will have some better feature for this
204
205         return sequencer_add_scene_strip_exec(C, op);
206 }
207
208
209 void SEQUENCER_OT_scene_strip_add(struct wmOperatorType *ot)
210 {
211         
212         /* identifiers */
213         ot->name= "Add Scene Strip";
214         ot->idname= "SEQUENCER_OT_scene_strip_add";
215         ot->description= "Add a strip to the sequencer using a blender scene as a source";
216
217         /* api callbacks */
218         ot->invoke= sequencer_add_scene_strip_invoke;
219         ot->exec= sequencer_add_scene_strip_exec;
220
221         ot->poll= ED_operator_sequencer_active;
222         
223         /* flags */
224         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
225         
226         sequencer_generic_props__internal(ot, SEQPROP_STARTFRAME);
227         RNA_def_string(ot->srna, "scene", "", MAX_ID_NAME-2, "Scene Name", "Scene name to add as a strip");
228 }
229
230 static Sequence* sequencer_add_sound_strip(bContext *C, wmOperator *op, int start_frame, int channel, char* filename)
231 {
232         Scene *scene= CTX_data_scene(C);
233         Editing *ed= seq_give_editing(scene, TRUE);
234
235         bSound *sound;
236
237         Sequence *seq;  /* generic strip vars */
238         Strip *strip;
239         StripElem *se;
240
241         AUD_SoundInfo info;
242
243         sound = sound_new_file(CTX_data_main(C), filename);
244
245         if (sound==NULL || sound->handle == NULL) {
246                 if(op)
247                         BKE_report(op->reports, RPT_ERROR, "Unsupported audio format");
248                 return NULL;
249         }
250
251         info = AUD_getInfo(sound->handle);
252
253         if (info.specs.format == AUD_FORMAT_INVALID) {
254                 sound_delete(C, sound);
255                 if(op)
256                         BKE_report(op->reports, RPT_ERROR, "Unsupported audio format");
257                 return NULL;
258         }
259
260         seq = alloc_sequence(ed->seqbasep, start_frame, channel);
261
262         seq->type= SEQ_SOUND;
263         seq->sound= sound;
264
265         /* basic defaults */
266         seq->strip= strip= MEM_callocN(sizeof(Strip), "strip");
267         strip->len = seq->len = (int) (info.length * FPS);
268         strip->us= 1;
269
270         strip->stripdata= se= MEM_callocN(seq->len*sizeof(StripElem), "stripelem");
271
272         BLI_split_dirfile_basic(filename, strip->dir, se->name);
273
274         seq->sound_handle = sound_new_handle(scene, sound, start_frame, start_frame + strip->len, 0);
275
276         calc_sequence_disp(seq);
277         sort_seq(scene);
278
279         /* last active name */
280         strncpy(ed->act_sounddir, strip->dir, FILE_MAXDIR-1);
281
282         return seq;
283 }
284
285 /* add movie operator */
286 static int sequencer_add_movie_strip_exec(bContext *C, wmOperator *op)
287 {
288         Scene *scene= CTX_data_scene(C);
289         Editing *ed= seq_give_editing(scene, TRUE);
290
291         struct anim *an;
292         char path[FILE_MAX];
293
294         Sequence *seq, *soundseq=NULL;  /* generic strip vars */
295         Strip *strip;
296         StripElem *se;
297
298         int start_frame, channel, sound; /* operator props */
299
300         start_frame= RNA_int_get(op->ptr, "start_frame");
301         channel= RNA_int_get(op->ptr, "channel");
302         sound = RNA_boolean_get(op->ptr, "sound");
303
304         RNA_string_get(op->ptr, "path", path);
305         
306         an = openanim(path, IB_rect);
307
308         if (an==NULL) {
309                 BKE_reportf(op->reports, RPT_ERROR, "File \"%s\" could not be loaded as a movie", path);
310                 return OPERATOR_CANCELLED;
311         }
312         
313         seq = alloc_sequence(ed->seqbasep, start_frame, channel);
314         
315         seq->type= SEQ_MOVIE;
316         seq->anim= an;
317         seq->anim_preseek = IMB_anim_get_preseek(an);
318         
319         /* basic defaults */
320         seq->strip= strip= MEM_callocN(sizeof(Strip), "strip");
321         strip->len = seq->len = IMB_anim_get_duration( an ); 
322         strip->us= 1;
323         
324         strip->stripdata= se= MEM_callocN(seq->len*sizeof(StripElem), "stripelem");
325         
326         BLI_split_dirfile_basic(path, strip->dir, se->name);
327
328         RNA_string_get(op->ptr, "name", seq->name);
329         
330         calc_sequence_disp(seq);
331         sort_seq(scene);
332
333         if(sound)
334         {
335                 soundseq = sequencer_add_sound_strip(C, NULL, start_frame, channel+1, path);
336                 if(soundseq != NULL)
337                         RNA_string_get(op->ptr, "name", soundseq->name);
338         }
339
340         if (RNA_boolean_get(op->ptr, "replace_sel")) {
341                 deselect_all_seq(scene);
342                 set_last_seq(scene, seq);
343                 seq->flag |= SELECT;
344                 if(soundseq)
345                         soundseq->flag |= SELECT;
346         }
347         
348         ED_area_tag_redraw(CTX_wm_area(C));
349         
350         return OPERATOR_FINISHED;
351 }
352
353
354 static int sequencer_add_movie_strip_invoke(bContext *C, wmOperator *op, wmEvent *event)
355 {       
356         sequencer_generic_invoke_xy__internal(C, op, event, 0);
357         return WM_operator_filesel(C, op, event);
358         //return sequencer_add_movie_strip_exec(C, op);
359 }
360
361
362 void SEQUENCER_OT_movie_strip_add(struct wmOperatorType *ot)
363 {
364         
365         /* identifiers */
366         ot->name= "Add Movie Strip";
367         ot->idname= "SEQUENCER_OT_movie_strip_add";
368         ot->description= "Add a movie strip to the sequencer";
369
370         /* api callbacks */
371         ot->invoke= sequencer_add_movie_strip_invoke;
372         ot->exec= sequencer_add_movie_strip_exec;
373
374         ot->poll= ED_operator_sequencer_active;
375         
376         /* flags */
377         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
378         
379         WM_operator_properties_filesel(ot, FOLDERFILE|MOVIEFILE, FILE_SPECIAL);
380         sequencer_generic_props__internal(ot, SEQPROP_STARTFRAME);
381         RNA_def_boolean(ot->srna, "sound", TRUE, "Sound", "Load sound with the movie");
382 }
383
384 /* add sound operator */
385 static int sequencer_add_sound_strip_exec(bContext *C, wmOperator *op)
386 {
387         char path[FILE_MAX];
388         Scene *scene= CTX_data_scene(C);
389         Sequence *seq;  /* generic strip vars */
390         int start_frame, channel; /* operator props */
391         
392         start_frame= RNA_int_get(op->ptr, "start_frame");
393         channel= RNA_int_get(op->ptr, "channel");
394         
395         RNA_string_get(op->ptr, "path", path);
396
397         seq = sequencer_add_sound_strip(C, op, start_frame, channel, path);
398
399         if(seq == NULL)
400                 return OPERATOR_CANCELLED;
401
402         RNA_string_get(op->ptr, "name", seq->name);
403
404         if (RNA_boolean_get(op->ptr, "cache")) {
405                 sound_cache(seq->sound, 0);
406         }
407
408         if (RNA_boolean_get(op->ptr, "replace_sel")) {
409                 deselect_all_seq(scene);
410                 set_last_seq(scene, seq);
411                 seq->flag |= SELECT;
412         }
413
414         ED_area_tag_redraw(CTX_wm_area(C));
415         
416         return OPERATOR_FINISHED;
417 }
418
419
420 static int sequencer_add_sound_strip_invoke(bContext *C, wmOperator *op, wmEvent *event)
421 {       
422         sequencer_generic_invoke_xy__internal(C, op, event, 0);
423         return WM_operator_filesel(C, op, event);
424         //return sequencer_add_sound_strip_exec(C, op);
425 }
426
427
428 void SEQUENCER_OT_sound_strip_add(struct wmOperatorType *ot)
429 {
430         
431         /* identifiers */
432         ot->name= "Add Sound Strip";
433         ot->idname= "SEQUENCER_OT_sound_strip_add";
434         ot->description= "Add a sound strip to the sequencer";
435
436         /* api callbacks */
437         ot->invoke= sequencer_add_sound_strip_invoke;
438         ot->exec= sequencer_add_sound_strip_exec;
439
440         ot->poll= ED_operator_sequencer_active;
441         
442         /* flags */
443         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
444         
445         WM_operator_properties_filesel(ot, FOLDERFILE|SOUNDFILE, FILE_SPECIAL);
446         sequencer_generic_props__internal(ot, SEQPROP_STARTFRAME);
447         RNA_def_boolean(ot->srna, "cache", FALSE, "Cache", "Cache the sound in memory.");
448 }
449
450 /* add image operator */
451 static int sequencer_add_image_strip_exec(bContext *C, wmOperator *op)
452 {
453         Scene *scene= CTX_data_scene(C);
454         Editing *ed= seq_give_editing(scene, TRUE);
455
456         int tot_images;
457
458         char path[FILE_MAX];
459
460         Sequence *seq;  /* generic strip vars */
461         Strip *strip;
462         StripElem *se;
463         
464         int start_frame, channel; /* operator props */
465         
466         start_frame= RNA_int_get(op->ptr, "start_frame");
467         channel= RNA_int_get(op->ptr, "channel");
468         
469         RNA_string_get(op->ptr, "path", path);
470
471         seq = alloc_sequence(ed->seqbasep, start_frame, channel);       
472         seq->type= SEQ_IMAGE;
473         
474         /* basic defaults */
475         seq->strip= strip= MEM_callocN(sizeof(Strip), "strip");
476         BLI_split_dirfile_basic(path, strip->dir, NULL);
477         
478         tot_images= RNA_property_collection_length(op->ptr, RNA_struct_find_property(op->ptr, "files"));
479         
480         strip->len = seq->len = tot_images?tot_images:1;
481         strip->us= 1;
482         
483         strip->stripdata= se= MEM_callocN(seq->len*sizeof(StripElem), "stripelem");
484         
485         if(tot_images) {
486                 RNA_BEGIN(op->ptr, itemptr, "files") {
487                         RNA_string_get(&itemptr, "name", se->name);
488                         se++;
489                 }
490                 RNA_END;
491         }
492         else {
493                 BLI_split_dirfile_basic(path, NULL, se->name);
494         }
495
496         RNA_string_get(op->ptr, "name", seq->name);
497         
498         calc_sequence_disp(seq);
499         sort_seq(scene);
500         
501         /* last active name */
502         strncpy(ed->act_imagedir, strip->dir, FILE_MAXDIR-1);
503         
504         if (RNA_boolean_get(op->ptr, "replace_sel")) {
505                 deselect_all_seq(scene);
506                 set_last_seq(scene, seq);
507                 seq->flag |= SELECT;
508         }
509
510         ED_area_tag_redraw(CTX_wm_area(C));
511         
512         return OPERATOR_FINISHED;
513 }
514
515
516 static int sequencer_add_image_strip_invoke(bContext *C, wmOperator *op, wmEvent *event)
517 {
518         sequencer_generic_invoke_xy__internal(C, op, event, 0);
519         return WM_operator_filesel(C, op, event);       
520         //return sequencer_add_image_strip_exec(C, op);
521 }
522
523
524 void SEQUENCER_OT_image_strip_add(struct wmOperatorType *ot)
525 {
526         
527         /* identifiers */
528         ot->name= "Add Image Strip";
529         ot->idname= "SEQUENCER_OT_image_strip_add";
530         ot->description= "Add an image or image sequence to the sequencer";
531
532         /* api callbacks */
533         ot->invoke= sequencer_add_image_strip_invoke;
534         ot->exec= sequencer_add_image_strip_exec;
535
536         ot->poll= ED_operator_sequencer_active;
537         
538         /* flags */
539         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
540         
541         WM_operator_properties_filesel(ot, FOLDERFILE|IMAGEFILE, FILE_SPECIAL);
542         sequencer_generic_props__internal(ot, SEQPROP_STARTFRAME);
543         
544         RNA_def_collection_runtime(ot->srna, "files", &RNA_OperatorFileListElement, "Files", "");
545 }
546
547
548 /* add_effect_strip operator */
549 static int sequencer_add_effect_strip_exec(bContext *C, wmOperator *op)
550 {
551         Scene *scene= CTX_data_scene(C);
552         Editing *ed= seq_give_editing(scene, TRUE);
553
554         Sequence *seq;  /* generic strip vars */
555         Strip *strip;
556         StripElem *se;
557         struct SeqEffectHandle sh;
558
559         int start_frame, end_frame, channel, type; /* operator props */
560         
561         Sequence *seq1, *seq2, *seq3;
562         char *error_msg;
563
564         start_frame= RNA_int_get(op->ptr, "start_frame");
565         end_frame= RNA_int_get(op->ptr, "end_frame");
566         channel= RNA_int_get(op->ptr, "channel");
567
568         type= RNA_enum_get(op->ptr, "type");
569         
570         // XXX We need unique names and move to invoke
571         if(!seq_effect_find_selected(scene, NULL, type, &seq1, &seq2, &seq3, &error_msg)) {
572                 BKE_report(op->reports, RPT_ERROR, error_msg);
573                 return OPERATOR_CANCELLED;
574         }
575
576         /* If seq1 is NULL and no error was rasied it means the seq is standalone
577          * (like color strips) and we need to check its start and end frames are valid */
578         if (seq1==NULL && end_frame <= start_frame) {
579                 BKE_report(op->reports, RPT_ERROR, "Start and end frame are not set");
580                 return OPERATOR_CANCELLED;
581         }
582
583         seq = alloc_sequence(ed->seqbasep, start_frame, channel);
584         seq->type= type;
585
586         sh = get_sequence_effect(seq);
587
588         seq->seq1= seq1;
589         seq->seq2= seq2;
590         seq->seq3= seq3;
591
592         sh.init(seq);
593
594         if (!seq1) { /* effect has no deps */
595                 seq->len= 1;
596                 seq_tx_set_final_right(seq, end_frame);
597         }
598
599         calc_sequence(seq);
600         
601         /* basic defaults */
602         seq->strip= strip= MEM_callocN(sizeof(Strip), "strip");
603         strip->len = seq->len;
604         strip->us= 1;
605         if(seq->len>0)
606                 strip->stripdata= se= MEM_callocN(seq->len*sizeof(StripElem), "stripelem");
607
608         if (seq->type==SEQ_PLUGIN) {
609                 char path[FILE_MAX];
610                 RNA_string_get(op->ptr, "path", path);
611
612                 sh.init_plugin(seq, path);
613
614                 if(seq->plugin==NULL) {
615                         BLI_remlink(ed->seqbasep, seq);
616                         seq_free_sequence(scene, seq);
617                         BKE_reportf(op->reports, RPT_ERROR, "Sequencer plugin \"%s\" could not load.", path);
618                         return OPERATOR_CANCELLED;
619                 }
620         }
621         else if (seq->type==SEQ_COLOR) {
622                 SolidColorVars *colvars= (SolidColorVars *)seq->effectdata;
623                 RNA_float_get_array(op->ptr, "color", colvars->col);
624         }
625
626         if(seq_test_overlap(ed->seqbasep, seq)) shuffle_seq(ed->seqbasep, seq);
627
628         update_changed_seq_and_deps(scene, seq, 1, 1); /* runs calc_sequence */
629
630
631         /* not sure if this is needed with update_changed_seq_and_deps.
632          * it was NOT called in blender 2.4x, but wont hurt */
633         sort_seq(scene); 
634
635         if (RNA_boolean_get(op->ptr, "replace_sel")) {
636                 deselect_all_seq(scene);
637                 set_last_seq(scene, seq);
638                 seq->flag |= SELECT;
639         }
640
641         ED_area_tag_redraw(CTX_wm_area(C));
642         return OPERATOR_FINISHED;
643 }
644
645
646 /* add color */
647 static int sequencer_add_effect_strip_invoke(bContext *C, wmOperator *op, wmEvent *event)
648 {
649         sequencer_generic_invoke_xy__internal(C, op, event, SEQPROP_ENDFRAME);
650
651         if (RNA_property_is_set(op->ptr, "type") && RNA_enum_get(op->ptr, "type")==SEQ_PLUGIN) {
652                 /* only plugins need the file selector */
653                 return WM_operator_filesel(C, op, event);
654         }
655         else {
656                 return sequencer_add_effect_strip_exec(C, op);
657         }
658 }
659
660 void SEQUENCER_OT_effect_strip_add(struct wmOperatorType *ot)
661 {
662         /* identifiers */
663         ot->name= "Add Effect Strip";
664         ot->idname= "SEQUENCER_OT_effect_strip_add";
665         ot->description= "Add an effect to the sequencer, most are applied on top of existing strips";
666
667         /* api callbacks */
668         ot->invoke= sequencer_add_effect_strip_invoke;
669         ot->exec= sequencer_add_effect_strip_exec;
670
671         ot->poll= ED_operator_sequencer_active;
672         
673         /* flags */
674         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
675         
676         WM_operator_properties_filesel(ot, 0, FILE_SPECIAL);
677         sequencer_generic_props__internal(ot, SEQPROP_STARTFRAME|SEQPROP_ENDFRAME);
678         RNA_def_enum(ot->srna, "type", sequencer_prop_effect_types, SEQ_CROSS, "Type", "Sequencer effect type");
679         RNA_def_float_vector(ot->srna, "color", 3, NULL, 0.0f, 1.0f, "Color", "Initialize the strip with this color (only used when type='COLOR')", 0.0f, 1.0f);
680 }