Merge branch 'master' into blender2.8
[blender.git] / source / blender / editors / space_sequencer / sequencer_add.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  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * Contributor(s): Blender Foundation, 2003-2009, Campbell Barton
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /** \file blender/editors/space_sequencer/sequencer_add.c
27  *  \ingroup spseq
28  */
29
30 #include <stdlib.h>
31 #include <math.h>
32 #include <string.h>
33 #include <ctype.h>
34
35 #include "MEM_guardedalloc.h"
36
37 #include "BLI_blenlib.h"
38 #include "BLI_math.h"
39 #include "BLI_utildefines.h"
40
41 #include "BLT_translation.h"
42
43 #include "DNA_scene_types.h"
44 #include "DNA_mask_types.h"
45
46
47 #include "BKE_context.h"
48 #include "BKE_global.h"
49 #include "BKE_library.h"
50 #include "BKE_main.h"
51 #include "BKE_sequencer.h"
52 #include "BKE_movieclip.h"
53 #include "BKE_mask.h"
54 #include "BKE_report.h"
55
56 #include "WM_api.h"
57 #include "WM_types.h"
58
59 #include "RNA_define.h"
60 #include "RNA_enum_types.h"
61
62 /* for menu/popup icons etc etc*/
63
64 #include "ED_screen.h"
65 #include "ED_sequencer.h"
66
67 #include "UI_interface.h"
68
69 #include "BKE_sound.h"
70
71 #ifdef WITH_AUDASPACE
72 #  include <AUD_Sequence.h>
73 #endif
74
75 /* own include */
76 #include "sequencer_intern.h"
77
78 typedef struct SequencerAddData {
79         ImageFormatData im_format;
80 } SequencerAddData;
81
82 /* Generic functions, reused by add strip operators */
83
84 /* avoid passing multiple args and be more verbose */
85 #define SEQPROP_STARTFRAME  (1 << 0)
86 #define SEQPROP_ENDFRAME    (1 << 1)
87 #define SEQPROP_NOPATHS     (1 << 2)
88 #define SEQPROP_NOCHAN      (1 << 3)
89
90 #define SELECT 1
91
92 static void sequencer_generic_props__internal(wmOperatorType *ot, int flag)
93 {
94         PropertyRNA *prop;
95
96         if (flag & SEQPROP_STARTFRAME)
97                 RNA_def_int(ot->srna, "frame_start", 0, INT_MIN, INT_MAX, "Start Frame", "Start frame of the sequence strip", INT_MIN, INT_MAX);
98         
99         if (flag & SEQPROP_ENDFRAME)
100                 RNA_def_int(ot->srna, "frame_end", 0, INT_MIN, INT_MAX, "End Frame", "End frame for the color strip", INT_MIN, INT_MAX);  /* not usual since most strips have a fixed length */
101         
102         RNA_def_int(ot->srna, "channel", 1, 1, MAXSEQ, "Channel", "Channel to place this strip into", 1, MAXSEQ);
103         
104         RNA_def_boolean(ot->srna, "replace_sel", 1, "Replace Selection", "Replace the current selection");
105
106         /* only for python scripts which import strips and place them after */
107         prop = RNA_def_boolean(ot->srna, "overlap", 0, "Allow Overlap", "Don't correct overlap on new sequence strips");
108         RNA_def_property_flag(prop, PROP_HIDDEN);
109 }
110
111 static void sequencer_generic_invoke_path__internal(bContext *C, wmOperator *op, const char *identifier)
112 {
113         if (RNA_struct_find_property(op->ptr, identifier)) {
114                 Scene *scene = CTX_data_scene(C);
115                 Sequence *last_seq = BKE_sequencer_active_get(scene);
116                 if (last_seq && last_seq->strip && SEQ_HAS_PATH(last_seq)) {
117                         Main *bmain = CTX_data_main(C);
118                         char path[FILE_MAX];
119                         BLI_strncpy(path, last_seq->strip->dir, sizeof(path));
120                         BLI_path_abs(path, bmain->name);
121                         RNA_string_set(op->ptr, identifier, path);
122                 }
123         }
124 }
125
126 static int sequencer_generic_invoke_xy_guess_channel(bContext *C, int type)
127 {
128         Sequence *tgt = NULL;
129         Sequence *seq;
130         Scene *scene = CTX_data_scene(C);
131         Editing *ed = BKE_sequencer_editing_get(scene, true);
132         int cfra = (int) CFRA;
133         int proximity = INT_MAX;
134
135         if (!ed || !ed->seqbasep) {
136                 return 1;
137         }
138
139         for (seq = ed->seqbasep->first; seq; seq = seq->next) {
140                 if ((type == -1 || seq->type == type) &&
141                     (seq->enddisp < cfra) &&
142                     (cfra - seq->enddisp < proximity))
143                 {
144                         tgt = seq;
145                         proximity = cfra - seq->enddisp;
146                 }
147         }
148         
149         if (tgt) {
150                 return tgt->machine;
151         }
152         return 1;
153 }
154
155 static void sequencer_generic_invoke_xy__internal(bContext *C, wmOperator *op, int flag, int type)
156 {
157         Scene *scene = CTX_data_scene(C);
158         
159         int cfra = (int) CFRA;
160         
161         /* effect strips don't need a channel initialized from the mouse */
162         if (!(flag & SEQPROP_NOCHAN)) {
163                 RNA_int_set(op->ptr, "channel", sequencer_generic_invoke_xy_guess_channel(C, type));
164         }
165
166         RNA_int_set(op->ptr, "frame_start", cfra);
167         
168         if ((flag & SEQPROP_ENDFRAME) && RNA_struct_property_is_set(op->ptr, "frame_end") == 0)
169                 RNA_int_set(op->ptr, "frame_end", cfra + 25);  // XXX arbitary but ok for now.
170
171         if (!(flag & SEQPROP_NOPATHS)) {
172                 sequencer_generic_invoke_path__internal(C, op, "filepath");
173                 sequencer_generic_invoke_path__internal(C, op, "directory");
174         }
175 }
176
177 static void seq_load_operator_info(SeqLoadInfo *seq_load, bContext *C, wmOperator *op)
178 {
179         Main *bmain = CTX_data_main(C);
180
181         PropertyRNA *prop;
182         const bool relative = (prop = RNA_struct_find_property(op->ptr, "relative_path")) && RNA_property_boolean_get(op->ptr, prop);
183         int is_file = -1;
184         memset(seq_load, 0, sizeof(SeqLoadInfo));
185
186         seq_load->start_frame =  RNA_int_get(op->ptr, "frame_start");
187         seq_load->end_frame =    seq_load->start_frame; /* un-set */
188
189         seq_load->channel =      RNA_int_get(op->ptr, "channel");
190         seq_load->len =          1; // images only, if endframe isn't set!
191
192         if ((prop = RNA_struct_find_property(op->ptr, "filepath"))) {
193                 RNA_property_string_get(op->ptr, prop, seq_load->path); /* full path, file is set by the caller */
194                 is_file = 1;
195         }
196         else if ((prop = RNA_struct_find_property(op->ptr, "directory"))) {
197                 RNA_property_string_get(op->ptr, prop, seq_load->path); /* full path, file is set by the caller */
198                 is_file = 0;
199         }
200
201         if ((is_file != -1) && relative)
202                 BLI_path_rel(seq_load->path, bmain->name);
203
204         
205         if ((prop = RNA_struct_find_property(op->ptr, "frame_end"))) {
206                 seq_load->end_frame = RNA_property_int_get(op->ptr, prop);
207         }
208
209         if ((prop = RNA_struct_find_property(op->ptr, "replace_sel")) && RNA_property_boolean_get(op->ptr, prop))
210                 seq_load->flag |= SEQ_LOAD_REPLACE_SEL;
211
212         if ((prop = RNA_struct_find_property(op->ptr, "cache")) && RNA_property_boolean_get(op->ptr, prop))
213                 seq_load->flag |= SEQ_LOAD_SOUND_CACHE;
214
215         if ((prop = RNA_struct_find_property(op->ptr, "mono")) && RNA_property_boolean_get(op->ptr, prop))
216                 seq_load->flag |= SEQ_LOAD_SOUND_MONO;
217
218         if ((prop = RNA_struct_find_property(op->ptr, "sound")) && RNA_property_boolean_get(op->ptr, prop))
219                 seq_load->flag |= SEQ_LOAD_MOVIE_SOUND;
220         
221         if ((prop = RNA_struct_find_property(op->ptr, "use_framerate")) && RNA_property_boolean_get(op->ptr, prop))
222                 seq_load->flag |= SEQ_LOAD_SYNC_FPS;
223
224         /* always use this for ops */
225         seq_load->flag |= SEQ_LOAD_FRAME_ADVANCE;
226
227
228         if (is_file == 1) {
229                 BLI_strncpy(seq_load->name, BLI_path_basename(seq_load->path), sizeof(seq_load->name));
230         }
231         else if ((prop = RNA_struct_find_property(op->ptr, "files"))) {
232                 /* used for image strip */
233                 /* best guess, first images name */
234                 RNA_PROP_BEGIN (op->ptr, itemptr, prop)
235                 {
236                         char *name = RNA_string_get_alloc(&itemptr, "name", NULL, 0);
237                         BLI_strncpy(seq_load->name, name, sizeof(seq_load->name));
238                         MEM_freeN(name);
239                         break;
240                 }
241                 RNA_PROP_END;
242         }
243
244         if ((prop = RNA_struct_find_property(op->ptr, "use_multiview")) && RNA_property_boolean_get(op->ptr, prop)) {
245                 if (op->customdata) {
246                         SequencerAddData *sad = op->customdata;
247                         ImageFormatData *imf = &sad->im_format;
248
249                         seq_load->views_format = imf->views_format;
250                         seq_load->flag |= SEQ_USE_VIEWS;
251
252                         /* operator custom data is always released after the SeqLoadInfo, no need to handle the memory here */
253                         seq_load->stereo3d_format = &imf->stereo3d_format;
254                 }
255         }
256 }
257
258 /**
259  * Apply generic operator options.
260  */
261 static void sequencer_add_apply_overlap(bContext *C, wmOperator *op, Sequence *seq)
262 {
263         Scene *scene = CTX_data_scene(C);
264         Editing *ed = BKE_sequencer_editing_get(scene, false);
265
266         if (RNA_boolean_get(op->ptr, "overlap") == false) {
267                 if (BKE_sequence_test_overlap(ed->seqbasep, seq)) {
268                         BKE_sequence_base_shuffle(ed->seqbasep, seq, scene);
269                 }
270         }
271 }
272
273 static void sequencer_add_apply_replace_sel(bContext *C, wmOperator *op, Sequence *seq)
274 {
275         Scene *scene = CTX_data_scene(C);
276
277         if (RNA_boolean_get(op->ptr, "replace_sel")) {
278                 ED_sequencer_deselect_all(scene);
279                 BKE_sequencer_active_set(scene, seq);
280                 seq->flag |= SELECT;
281         }
282 }
283
284 /* add scene operator */
285 static int sequencer_add_scene_strip_exec(bContext *C, wmOperator *op)
286 {
287         Scene *scene = CTX_data_scene(C);
288         Editing *ed = BKE_sequencer_editing_get(scene, true);
289         
290         Scene *sce_seq;
291
292         Sequence *seq;  /* generic strip vars */
293         Strip *strip;
294         
295         int start_frame, channel; /* operator props */
296         
297         start_frame = RNA_int_get(op->ptr, "frame_start");
298         channel = RNA_int_get(op->ptr, "channel");
299         
300         sce_seq = BLI_findlink(&CTX_data_main(C)->scene, RNA_enum_get(op->ptr, "scene"));
301         
302         if (sce_seq == NULL) {
303                 BKE_report(op->reports, RPT_ERROR, "Scene not found");
304                 return OPERATOR_CANCELLED;
305         }
306         
307         seq = BKE_sequence_alloc(ed->seqbasep, start_frame, channel);
308         seq->type = SEQ_TYPE_SCENE;
309         seq->blend_mode = SEQ_TYPE_CROSS; /* so alpha adjustment fade to the strip below */
310
311         seq->scene = sce_seq;
312         
313         /* basic defaults */
314         seq->strip = strip = MEM_callocN(sizeof(Strip), "strip");
315         seq->len = sce_seq->r.efra - sce_seq->r.sfra + 1;
316         strip->us = 1;
317         
318         BLI_strncpy(seq->name + 2, sce_seq->id.name + 2, sizeof(seq->name) - 2);
319         BKE_sequence_base_unique_name_recursive(&ed->seqbase, seq);
320
321         seq->scene_sound = BKE_sound_scene_add_scene_sound(scene, seq, start_frame, start_frame + seq->len, 0);
322
323         BKE_sequence_calc_disp(scene, seq);
324         BKE_sequencer_sort(scene);
325         
326         sequencer_add_apply_replace_sel(C, op, seq);
327         sequencer_add_apply_overlap(C, op, seq);
328
329         WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
330         
331         return OPERATOR_FINISHED;
332 }
333
334
335 static int sequencer_add_scene_strip_invoke(bContext *C, wmOperator *op, const wmEvent *event)
336 {
337         if (!RNA_struct_property_is_set(op->ptr, "scene"))
338                 return WM_enum_search_invoke(C, op, event);
339
340         sequencer_generic_invoke_xy__internal(C, op, 0, SEQ_TYPE_SCENE);
341         return sequencer_add_scene_strip_exec(C, op);
342         // needs a menu
343         // return WM_menu_invoke(C, op, event);
344 }
345
346
347 void SEQUENCER_OT_scene_strip_add(struct wmOperatorType *ot)
348 {
349         PropertyRNA *prop;
350         
351         /* identifiers */
352         ot->name = "Add Scene Strip";
353         ot->idname = "SEQUENCER_OT_scene_strip_add";
354         ot->description = "Add a strip to the sequencer using a blender scene as a source";
355
356         /* api callbacks */
357         ot->invoke = sequencer_add_scene_strip_invoke;
358         ot->exec = sequencer_add_scene_strip_exec;
359
360         ot->poll = ED_operator_sequencer_active_editable;
361         
362         /* flags */
363         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
364         
365         sequencer_generic_props__internal(ot, SEQPROP_STARTFRAME);
366         prop = RNA_def_enum(ot->srna, "scene", DummyRNA_NULL_items, 0, "Scene", "");
367         RNA_def_enum_funcs(prop, RNA_scene_without_active_itemf);
368         RNA_def_property_flag(prop, PROP_ENUM_NO_TRANSLATE);
369         ot->prop = prop;
370 }
371
372 /* add movieclip operator */
373 static int sequencer_add_movieclip_strip_exec(bContext *C, wmOperator *op)
374 {
375         Scene *scene = CTX_data_scene(C);
376         Editing *ed = BKE_sequencer_editing_get(scene, true);
377         
378         MovieClip *clip;
379
380         Sequence *seq;  /* generic strip vars */
381         Strip *strip;
382         
383         int start_frame, channel; /* operator props */
384         
385         start_frame = RNA_int_get(op->ptr, "frame_start");
386         channel = RNA_int_get(op->ptr, "channel");
387         
388         clip = BLI_findlink(&CTX_data_main(C)->movieclip, RNA_enum_get(op->ptr, "clip"));
389         
390         if (clip == NULL) {
391                 BKE_report(op->reports, RPT_ERROR, "Movie clip not found");
392                 return OPERATOR_CANCELLED;
393         }
394         
395         seq = BKE_sequence_alloc(ed->seqbasep, start_frame, channel);
396         seq->type = SEQ_TYPE_MOVIECLIP;
397         seq->blend_mode = SEQ_TYPE_CROSS;
398         seq->clip = clip;
399
400         id_us_ensure_real(&seq->clip->id);
401
402         /* basic defaults */
403         seq->strip = strip = MEM_callocN(sizeof(Strip), "strip");
404         seq->len =  BKE_movieclip_get_duration(clip);
405         strip->us = 1;
406         
407         BLI_strncpy(seq->name + 2, clip->id.name + 2, sizeof(seq->name) - 2);
408         BKE_sequence_base_unique_name_recursive(&ed->seqbase, seq);
409
410         BKE_sequence_calc_disp(scene, seq);
411         BKE_sequencer_sort(scene);
412         
413         sequencer_add_apply_replace_sel(C, op, seq);
414         sequencer_add_apply_overlap(C, op, seq);
415
416         WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
417         
418         return OPERATOR_FINISHED;
419 }
420
421 static int sequencer_add_movieclip_strip_invoke(bContext *C, wmOperator *op, const wmEvent *event)
422 {
423         if (!RNA_struct_property_is_set(op->ptr, "clip"))
424                 return WM_enum_search_invoke(C, op, event);
425
426         sequencer_generic_invoke_xy__internal(C, op, 0, SEQ_TYPE_MOVIECLIP);
427         return sequencer_add_movieclip_strip_exec(C, op);
428         // needs a menu
429         // return WM_menu_invoke(C, op, event);
430 }
431
432 void SEQUENCER_OT_movieclip_strip_add(struct wmOperatorType *ot)
433 {
434         PropertyRNA *prop;
435
436         /* identifiers */
437         ot->name = "Add MovieClip Strip";
438         ot->idname = "SEQUENCER_OT_movieclip_strip_add";
439         ot->description = "Add a movieclip strip to the sequencer";
440
441         /* api callbacks */
442         ot->invoke = sequencer_add_movieclip_strip_invoke;
443         ot->exec = sequencer_add_movieclip_strip_exec;
444
445         ot->poll = ED_operator_sequencer_active_editable;
446
447         /* flags */
448         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
449
450         sequencer_generic_props__internal(ot, SEQPROP_STARTFRAME);
451         prop = RNA_def_enum(ot->srna, "clip", DummyRNA_NULL_items, 0, "Clip", "");
452         RNA_def_enum_funcs(prop, RNA_movieclip_itemf);
453         RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_MOVIECLIP);
454         RNA_def_property_flag(prop, PROP_ENUM_NO_TRANSLATE);
455         ot->prop = prop;
456 }
457
458 static int sequencer_add_mask_strip_exec(bContext *C, wmOperator *op)
459 {
460         Scene *scene = CTX_data_scene(C);
461         Editing *ed = BKE_sequencer_editing_get(scene, true);
462
463         Mask *mask;
464
465         Sequence *seq;  /* generic strip vars */
466         Strip *strip;
467
468         int start_frame, channel; /* operator props */
469
470         start_frame = RNA_int_get(op->ptr, "frame_start");
471         channel = RNA_int_get(op->ptr, "channel");
472
473         mask = BLI_findlink(&CTX_data_main(C)->mask, RNA_enum_get(op->ptr, "mask"));
474
475         if (mask == NULL) {
476                 BKE_report(op->reports, RPT_ERROR, "Mask not found");
477                 return OPERATOR_CANCELLED;
478         }
479
480         seq = BKE_sequence_alloc(ed->seqbasep, start_frame, channel);
481         seq->type = SEQ_TYPE_MASK;
482         seq->blend_mode = SEQ_TYPE_CROSS;
483         seq->mask = mask;
484
485         id_us_ensure_real(&seq->mask->id);
486
487         /* basic defaults */
488         seq->strip = strip = MEM_callocN(sizeof(Strip), "strip");
489         seq->len = BKE_mask_get_duration(mask);
490         strip->us = 1;
491
492         BLI_strncpy(seq->name + 2, mask->id.name + 2, sizeof(seq->name) - 2);
493         BKE_sequence_base_unique_name_recursive(&ed->seqbase, seq);
494
495         BKE_sequence_calc_disp(scene, seq);
496         BKE_sequencer_sort(scene);
497
498         sequencer_add_apply_replace_sel(C, op, seq);
499         sequencer_add_apply_overlap(C, op, seq);
500
501         WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
502
503         return OPERATOR_FINISHED;
504 }
505
506 static int sequencer_add_mask_strip_invoke(bContext *C, wmOperator *op, const wmEvent *event)
507 {
508         if (!RNA_struct_property_is_set(op->ptr, "mask"))
509                 return WM_enum_search_invoke(C, op, event);
510
511         sequencer_generic_invoke_xy__internal(C, op, 0, SEQ_TYPE_MASK);
512         return sequencer_add_mask_strip_exec(C, op);
513         // needs a menu
514         // return WM_menu_invoke(C, op, event);
515 }
516
517
518 void SEQUENCER_OT_mask_strip_add(struct wmOperatorType *ot)
519 {
520         PropertyRNA *prop;
521
522         /* identifiers */
523         ot->name = "Add Mask Strip";
524         ot->idname = "SEQUENCER_OT_mask_strip_add";
525         ot->description = "Add a mask strip to the sequencer";
526
527         /* api callbacks */
528         ot->invoke = sequencer_add_mask_strip_invoke;
529         ot->exec = sequencer_add_mask_strip_exec;
530
531         ot->poll = ED_operator_sequencer_active_editable;
532
533         /* flags */
534         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
535
536         sequencer_generic_props__internal(ot, SEQPROP_STARTFRAME);
537         prop = RNA_def_enum(ot->srna, "mask", DummyRNA_NULL_items, 0, "Mask", "");
538         RNA_def_enum_funcs(prop, RNA_mask_itemf);
539         RNA_def_property_flag(prop, PROP_ENUM_NO_TRANSLATE);
540         ot->prop = prop;
541 }
542
543
544 static int sequencer_add_generic_strip_exec(bContext *C, wmOperator *op, SeqLoadFunc seq_load_func)
545 {
546         Scene *scene = CTX_data_scene(C); /* only for sound */
547         Editing *ed = BKE_sequencer_editing_get(scene, true);
548         SeqLoadInfo seq_load;
549         int tot_files;
550
551         seq_load_operator_info(&seq_load, C, op);
552
553         if (seq_load.flag & SEQ_LOAD_REPLACE_SEL)
554                 ED_sequencer_deselect_all(scene);
555
556         if (RNA_struct_property_is_set(op->ptr, "files"))
557                 tot_files = RNA_property_collection_length(op->ptr, RNA_struct_find_property(op->ptr, "files"));
558         else
559                 tot_files = 0;
560
561         if (tot_files) {
562                 /* multiple files */
563                 char dir_only[FILE_MAX];
564                 char file_only[FILE_MAX];
565
566                 BLI_split_dir_part(seq_load.path, dir_only, sizeof(dir_only));
567
568                 RNA_BEGIN (op->ptr, itemptr, "files")
569                 {
570                         Sequence *seq;
571
572                         RNA_string_get(&itemptr, "name", file_only);
573                         BLI_join_dirfile(seq_load.path, sizeof(seq_load.path), dir_only, file_only);
574
575                         /* Set seq_load.name, else all video/audio files get the same name! ugly! */
576                         BLI_strncpy(seq_load.name, file_only, sizeof(seq_load.name));
577
578                         seq = seq_load_func(C, ed->seqbasep, &seq_load);
579                         if (seq) {
580                                 sequencer_add_apply_overlap(C, op, seq);
581                                 if (seq_load.seq_sound) {
582                                         sequencer_add_apply_overlap(C, op, seq_load.seq_sound);
583                                 }
584                         }
585                 }
586                 RNA_END;
587         }
588         else {
589                 Sequence *seq;
590
591                 /* single file */
592                 seq = seq_load_func(C, ed->seqbasep, &seq_load);
593                 if (seq) {
594                         sequencer_add_apply_overlap(C, op, seq);
595                         if (seq_load.seq_sound) {
596                                 sequencer_add_apply_overlap(C, op, seq_load.seq_sound);
597                         }
598                 }
599         }
600
601         if (seq_load.tot_success == 0) {
602                 BKE_reportf(op->reports, RPT_ERROR, "File '%s' could not be loaded", seq_load.path);
603                 return OPERATOR_CANCELLED;
604         }
605
606         if (op->customdata)
607                 MEM_freeN(op->customdata);
608
609         BKE_sequencer_sort(scene);
610         BKE_sequencer_update_muting(ed);
611
612         WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
613
614         return OPERATOR_FINISHED;
615 }
616
617 /* add sequencer operators */
618 static void sequencer_add_init(bContext *UNUSED(C), wmOperator *op)
619 {
620         op->customdata = MEM_callocN(sizeof(SequencerAddData), __func__);
621 }
622
623 static void sequencer_add_cancel(bContext *UNUSED(C), wmOperator *op)
624 {
625         if (op->customdata)
626                 MEM_freeN(op->customdata);
627         op->customdata = NULL;
628 }
629
630 static bool sequencer_add_draw_check_prop(PointerRNA *UNUSED(ptr), PropertyRNA *prop)
631 {
632         const char *prop_id = RNA_property_identifier(prop);
633
634         return !(STREQ(prop_id, "filepath") ||
635                  STREQ(prop_id, "directory") ||
636                  STREQ(prop_id, "filename")
637                  );
638 }
639
640 /* add movie operator */
641 static int sequencer_add_movie_strip_exec(bContext *C, wmOperator *op)
642 {
643         return sequencer_add_generic_strip_exec(C, op, BKE_sequencer_add_movie_strip);
644 }
645
646 static int sequencer_add_movie_strip_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
647 {
648         PropertyRNA *prop;
649         Scene *scene = CTX_data_scene(C);
650         Editing *ed = BKE_sequencer_editing_get(scene, false);
651
652         /* only enable "use_framerate" if there aren't any existing strips
653          *  -  When there are no strips yet, there is no harm in enabling this,
654          *     and it makes the single-strip case really nice for casual users
655          *  -  When there are strips, it's best we don't touch the framerate,
656          *     as all hell may break loose (e.g. audio strips start overlapping
657          *     and can't be restored)
658          *  -  These initial guesses can still be manually overridden by users
659          *     from the modal options panel
660          */
661         if (ed && ed->seqbasep && ed->seqbasep->first) {
662                 RNA_boolean_set(op->ptr, "use_framerate", false);
663         }
664
665         /* This is for drag and drop */
666         if ((RNA_struct_property_is_set(op->ptr, "files") && RNA_collection_length(op->ptr, "files")) ||
667             RNA_struct_property_is_set(op->ptr, "filepath"))
668         {
669                 sequencer_generic_invoke_xy__internal(C, op, SEQPROP_NOPATHS, SEQ_TYPE_MOVIE);
670                 return sequencer_add_movie_strip_exec(C, op);
671         }
672         
673         sequencer_generic_invoke_xy__internal(C, op, 0, SEQ_TYPE_MOVIE);
674
675         sequencer_add_init(C, op);
676
677         /* show multiview save options only if scene has multiviews */
678         prop = RNA_struct_find_property(op->ptr, "show_multiview");
679         RNA_property_boolean_set(op->ptr, prop, (scene->r.scemode & R_MULTIVIEW) != 0);
680
681         WM_event_add_fileselect(C, op);
682         return OPERATOR_RUNNING_MODAL;
683
684         //return sequencer_add_movie_strip_exec(C, op);
685 }
686
687 static void sequencer_add_draw(bContext *UNUSED(C), wmOperator *op)
688 {
689         uiLayout *layout = op->layout;
690         SequencerAddData *sad = op->customdata;
691         ImageFormatData *imf = &sad->im_format;
692         PointerRNA imf_ptr, ptr;
693
694         /* main draw call */
695         RNA_pointer_create(NULL, op->type->srna, op->properties, &ptr);
696         uiDefAutoButsRNA(layout, &ptr, sequencer_add_draw_check_prop, UI_BUT_LABEL_ALIGN_NONE, false);
697
698         /* image template */
699         RNA_pointer_create(NULL, &RNA_ImageFormatSettings, imf, &imf_ptr);
700
701         /* multiview template */
702         if (RNA_boolean_get(op->ptr, "show_multiview"))
703                 uiTemplateImageFormatViews(layout, &imf_ptr, op->ptr);
704 }
705
706 void SEQUENCER_OT_movie_strip_add(struct wmOperatorType *ot)
707 {
708         
709         /* identifiers */
710         ot->name = "Add Movie Strip";
711         ot->idname = "SEQUENCER_OT_movie_strip_add";
712         ot->description = "Add a movie strip to the sequencer";
713
714         /* api callbacks */
715         ot->invoke = sequencer_add_movie_strip_invoke;
716         ot->exec = sequencer_add_movie_strip_exec;
717         ot->cancel = sequencer_add_cancel;
718         ot->ui = sequencer_add_draw;
719
720         ot->poll = ED_operator_sequencer_active_editable;
721
722         /* flags */
723         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
724         
725         WM_operator_properties_filesel(
726                 ot, FILE_TYPE_FOLDER | FILE_TYPE_MOVIE, FILE_SPECIAL, FILE_OPENFILE,
727                 WM_FILESEL_FILEPATH | WM_FILESEL_RELPATH | WM_FILESEL_FILES, FILE_DEFAULTDISPLAY, FILE_SORT_ALPHA);
728         sequencer_generic_props__internal(ot, SEQPROP_STARTFRAME);
729         RNA_def_boolean(ot->srna, "sound", true, "Sound", "Load sound with the movie");
730         RNA_def_boolean(ot->srna, "use_framerate", true, "Use Movie Framerate", "Use framerate from the movie to keep sound and video in sync");
731 }
732
733 /* add sound operator */
734
735 static int sequencer_add_sound_strip_exec(bContext *C, wmOperator *op)
736 {
737         return sequencer_add_generic_strip_exec(C, op, BKE_sequencer_add_sound_strip);
738 }
739
740 static int sequencer_add_sound_strip_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
741 {
742         /* This is for drag and drop */
743         if ((RNA_struct_property_is_set(op->ptr, "files") && RNA_collection_length(op->ptr, "files")) ||
744             RNA_struct_property_is_set(op->ptr, "filepath"))
745         {
746                 sequencer_generic_invoke_xy__internal(C, op, SEQPROP_NOPATHS, SEQ_TYPE_SOUND_RAM);
747                 return sequencer_add_sound_strip_exec(C, op);
748         }
749         
750         sequencer_generic_invoke_xy__internal(C, op, 0, SEQ_TYPE_SOUND_RAM);
751
752         WM_event_add_fileselect(C, op);
753         return OPERATOR_RUNNING_MODAL;
754
755         //return sequencer_add_sound_strip_exec(C, op);
756 }
757
758
759 void SEQUENCER_OT_sound_strip_add(struct wmOperatorType *ot)
760 {
761         
762         /* identifiers */
763         ot->name = "Add Sound Strip";
764         ot->idname = "SEQUENCER_OT_sound_strip_add";
765         ot->description = "Add a sound strip to the sequencer";
766
767         /* api callbacks */
768         ot->invoke = sequencer_add_sound_strip_invoke;
769         ot->exec = sequencer_add_sound_strip_exec;
770
771         ot->poll = ED_operator_sequencer_active_editable;
772         
773         /* flags */
774         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
775         
776         WM_operator_properties_filesel(
777                 ot, FILE_TYPE_FOLDER | FILE_TYPE_SOUND, FILE_SPECIAL, FILE_OPENFILE,
778                 WM_FILESEL_FILEPATH | WM_FILESEL_RELPATH | WM_FILESEL_FILES, FILE_DEFAULTDISPLAY, FILE_SORT_ALPHA);
779         sequencer_generic_props__internal(ot, SEQPROP_STARTFRAME);
780         RNA_def_boolean(ot->srna, "cache", false, "Cache", "Cache the sound in memory");
781         RNA_def_boolean(ot->srna, "mono", false, "Mono", "Merge all the sound's channels into one");
782 }
783
784 int sequencer_image_seq_get_minmax_frame(wmOperator *op, int sfra, int *r_minframe, int *r_numdigits)
785 {
786         int minframe = INT32_MAX, maxframe = INT32_MIN;
787         int numdigits = 0;
788
789         RNA_BEGIN (op->ptr, itemptr, "files")
790         {
791                 char *filename;
792                 int frame;
793                 /* just get the first filename */
794                 filename = RNA_string_get_alloc(&itemptr, "name", NULL, 0);
795
796                 if (filename) {
797                         if (BLI_path_frame_get(filename, &frame, &numdigits)) {
798                                 minframe = min_ii(minframe, frame);
799                                 maxframe = max_ii(maxframe, frame);
800                         }
801
802                         MEM_freeN(filename);
803                 }
804         }
805         RNA_END;
806
807         if (minframe == INT32_MAX) {
808                 minframe = sfra;
809                 maxframe = minframe + 1;
810         }
811
812         *r_minframe = minframe;
813         *r_numdigits = numdigits;
814
815         return maxframe - minframe + 1;
816 }
817
818 void sequencer_image_seq_reserve_frames(wmOperator *op, StripElem *se, int len, int minframe, int numdigits)
819 {
820         int i;
821         char *filename = NULL;
822         RNA_BEGIN (op->ptr, itemptr, "files")
823         {
824                 /* just get the first filename */
825                 filename = RNA_string_get_alloc(&itemptr, "name", NULL, 0);
826                 break;
827         }
828         RNA_END;
829
830         if (filename) {
831                 char ext[PATH_MAX];
832                 char filename_stripped[PATH_MAX];
833                 /* strip the frame from filename and substitute with # */
834                 BLI_path_frame_strip(filename, true, ext);
835
836                 for (i = 0; i < len; i++, se++) {
837                         BLI_strncpy(filename_stripped, filename, sizeof(filename_stripped));
838                         BLI_path_frame(filename_stripped, minframe + i, numdigits);
839                         BLI_snprintf(se->name, sizeof(se->name), "%s%s", filename_stripped, ext);
840                 }
841
842                 MEM_freeN(filename);
843         }
844 }
845
846
847 /* add image operator */
848 static int sequencer_add_image_strip_exec(bContext *C, wmOperator *op)
849 {
850         int minframe, numdigits;
851         /* cant use the generic function for this */
852         Scene *scene = CTX_data_scene(C); /* only for sound */
853         Editing *ed = BKE_sequencer_editing_get(scene, true);
854         SeqLoadInfo seq_load;
855         Sequence *seq;
856
857         Strip *strip;
858         StripElem *se;
859         const bool use_placeholders = RNA_boolean_get(op->ptr, "use_placeholders");
860
861         seq_load_operator_info(&seq_load, C, op);
862
863         /* images are unique in how they handle this - 1 per strip elem */
864         if (use_placeholders) {
865                 seq_load.len = sequencer_image_seq_get_minmax_frame(op, seq_load.start_frame, &minframe, &numdigits);
866         }
867         else {
868                 seq_load.len = RNA_property_collection_length(op->ptr, RNA_struct_find_property(op->ptr, "files"));
869         }
870
871         if (seq_load.len == 0)
872                 return OPERATOR_CANCELLED;
873
874         if (seq_load.flag & SEQ_LOAD_REPLACE_SEL)
875                 ED_sequencer_deselect_all(scene);
876
877         /* main adding function */
878         seq = BKE_sequencer_add_image_strip(C, ed->seqbasep, &seq_load);
879         strip = seq->strip;
880         se = strip->stripdata;
881
882         if (use_placeholders) {
883                 sequencer_image_seq_reserve_frames(op, se, seq_load.len, minframe, numdigits);
884         }
885         else {
886                 RNA_BEGIN (op->ptr, itemptr, "files")
887                 {
888                         char *filename = RNA_string_get_alloc(&itemptr, "name", NULL, 0);
889                         BLI_strncpy(se->name, filename, sizeof(se->name));
890                         MEM_freeN(filename);
891                         se++;
892                 }
893                 RNA_END;
894         }
895
896         if (seq_load.len == 1) {
897                 if (seq_load.start_frame < seq_load.end_frame) {
898                         seq->endstill = seq_load.end_frame - seq_load.start_frame;
899                 }
900         }
901
902         BKE_sequence_init_colorspace(seq);
903
904         BKE_sequence_calc_disp(scene, seq);
905
906         BKE_sequencer_sort(scene);
907
908         /* last active name */
909         BLI_strncpy(ed->act_imagedir, strip->dir, sizeof(ed->act_imagedir));
910
911         sequencer_add_apply_overlap(C, op, seq);
912
913         if (op->customdata)
914                 MEM_freeN(op->customdata);
915
916         WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
917
918         return OPERATOR_FINISHED;
919 }
920
921 static int sequencer_add_image_strip_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
922 {
923         PropertyRNA *prop;
924         Scene *scene = CTX_data_scene(C);
925
926         /* drag drop has set the names */
927         if (RNA_struct_property_is_set(op->ptr, "files") && RNA_collection_length(op->ptr, "files")) {
928                 sequencer_generic_invoke_xy__internal(C, op, SEQPROP_ENDFRAME | SEQPROP_NOPATHS, SEQ_TYPE_IMAGE);
929                 return sequencer_add_image_strip_exec(C, op);
930         }
931         
932         sequencer_generic_invoke_xy__internal(C, op, SEQPROP_ENDFRAME, SEQ_TYPE_IMAGE);
933
934         sequencer_add_init(C, op);
935
936         /* show multiview save options only if scene has multiviews */
937         prop = RNA_struct_find_property(op->ptr, "show_multiview");
938         RNA_property_boolean_set(op->ptr, prop, (scene->r.scemode & R_MULTIVIEW) != 0);
939
940         WM_event_add_fileselect(C, op);
941         return OPERATOR_RUNNING_MODAL;
942 }
943
944
945 void SEQUENCER_OT_image_strip_add(struct wmOperatorType *ot)
946 {
947         
948         /* identifiers */
949         ot->name = "Add Image Strip";
950         ot->idname = "SEQUENCER_OT_image_strip_add";
951         ot->description = "Add an image or image sequence to the sequencer";
952
953         /* api callbacks */
954         ot->invoke = sequencer_add_image_strip_invoke;
955         ot->exec = sequencer_add_image_strip_exec;
956         ot->cancel = sequencer_add_cancel;
957         ot->ui = sequencer_add_draw;
958
959         ot->poll = ED_operator_sequencer_active_editable;
960         
961         /* flags */
962         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
963         
964         WM_operator_properties_filesel(
965                 ot, FILE_TYPE_FOLDER | FILE_TYPE_IMAGE, FILE_SPECIAL, FILE_OPENFILE,
966                 WM_FILESEL_DIRECTORY | WM_FILESEL_RELPATH | WM_FILESEL_FILES, FILE_DEFAULTDISPLAY, FILE_SORT_ALPHA);
967         sequencer_generic_props__internal(ot, SEQPROP_STARTFRAME | SEQPROP_ENDFRAME);
968
969         RNA_def_boolean(ot->srna, "use_placeholders", false, "Use Placeholders", "Use placeholders for missing frames of the strip");
970 }
971
972
973 /* add_effect_strip operator */
974 static int sequencer_add_effect_strip_exec(bContext *C, wmOperator *op)
975 {
976         Scene *scene = CTX_data_scene(C);
977         Editing *ed = BKE_sequencer_editing_get(scene, true);
978
979         Sequence *seq;  /* generic strip vars */
980         Strip *strip;
981         struct SeqEffectHandle sh;
982
983         int start_frame, end_frame, channel, type; /* operator props */
984         
985         Sequence *seq1, *seq2, *seq3;
986         const char *error_msg;
987
988         start_frame = RNA_int_get(op->ptr, "frame_start");
989         end_frame = RNA_int_get(op->ptr, "frame_end");
990         channel = RNA_int_get(op->ptr, "channel");
991
992         type = RNA_enum_get(op->ptr, "type");
993         
994         // XXX move to invoke
995         if (!seq_effect_find_selected(scene, NULL, type, &seq1, &seq2, &seq3, &error_msg)) {
996                 BKE_report(op->reports, RPT_ERROR, error_msg);
997                 return OPERATOR_CANCELLED;
998         }
999
1000         /* If seq1 is NULL and no error was raised it means the seq is standalone
1001          * (like color strips) and we need to check its start and end frames are valid */
1002         if (seq1 == NULL && end_frame <= start_frame) {
1003                 BKE_report(op->reports, RPT_ERROR, "Start and end frame are not set");
1004                 return OPERATOR_CANCELLED;
1005         }
1006
1007         seq = BKE_sequence_alloc(ed->seqbasep, start_frame, channel);
1008         seq->type = type;
1009
1010         BLI_strncpy(seq->name + 2, BKE_sequence_give_name(seq), sizeof(seq->name) - 2);
1011         BKE_sequence_base_unique_name_recursive(&ed->seqbase, seq);
1012
1013         sh = BKE_sequence_get_effect(seq);
1014
1015         seq->seq1 = seq1;
1016         seq->seq2 = seq2;
1017         seq->seq3 = seq3;
1018
1019         sh.init(seq);
1020
1021         if (!seq1) { /* effect has no deps */
1022                 seq->len = 1;
1023                 BKE_sequence_tx_set_final_right(seq, end_frame);
1024         }
1025
1026         seq->flag |= SEQ_USE_EFFECT_DEFAULT_FADE;
1027
1028         BKE_sequence_calc(scene, seq);
1029         
1030         /* basic defaults */
1031         seq->strip = strip = MEM_callocN(sizeof(Strip), "strip");
1032         strip->us = 1;
1033
1034         if (seq->type == SEQ_TYPE_COLOR) {
1035                 SolidColorVars *colvars = (SolidColorVars *)seq->effectdata;
1036                 RNA_float_get_array(op->ptr, "color", colvars->col);
1037                 seq->blend_mode = SEQ_TYPE_CROSS; /* so alpha adjustment fade to the strip below */
1038
1039         }
1040         else if (seq->type == SEQ_TYPE_ADJUSTMENT) {
1041                 seq->blend_mode = SEQ_TYPE_CROSS;
1042         }
1043         else if (seq->type == SEQ_TYPE_TEXT) {
1044                 seq->blend_mode = SEQ_TYPE_ALPHAOVER;
1045         }
1046
1047         /* an unset channel is a special case where we automatically go above
1048          * the other strips. */
1049         if (!RNA_struct_property_is_set(op->ptr, "channel")) {
1050                 if (seq->seq1) {
1051                         int chan = max_iii(seq->seq1 ? seq->seq1->machine : 0,
1052                                            seq->seq2 ? seq->seq2->machine : 0,
1053                                            seq->seq3 ? seq->seq3->machine : 0);
1054                         if (chan < MAXSEQ)
1055                                 seq->machine = chan;
1056                 }
1057         }
1058
1059         sequencer_add_apply_replace_sel(C, op, seq);
1060         sequencer_add_apply_overlap(C, op, seq);
1061
1062         BKE_sequencer_update_changed_seq_and_deps(scene, seq, 1, 1); /* runs BKE_sequence_calc */
1063
1064
1065         /* not sure if this is needed with update_changed_seq_and_deps.
1066          * it was NOT called in blender 2.4x, but wont hurt */
1067         BKE_sequencer_sort(scene); 
1068
1069         WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
1070
1071         return OPERATOR_FINISHED;
1072 }
1073
1074
1075 /* add color */
1076 static int sequencer_add_effect_strip_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1077 {
1078         bool is_type_set = RNA_struct_property_is_set(op->ptr, "type");
1079         int type = -1;
1080         int prop_flag = SEQPROP_ENDFRAME | SEQPROP_NOPATHS;
1081
1082         if (is_type_set) {
1083                 type = RNA_enum_get(op->ptr, "type");
1084
1085                 /* when invoking an effect strip which uses inputs,
1086                  * skip initializing the channel from the mouse.
1087                  * Instead leave the property unset so exec() initializes it to be
1088                  * above the strips its applied to. */
1089                 if (BKE_sequence_effect_get_num_inputs(type) != 0) {
1090                         prop_flag |= SEQPROP_NOCHAN;
1091                 }
1092         }
1093
1094         sequencer_generic_invoke_xy__internal(C, op, prop_flag, type);
1095
1096         return sequencer_add_effect_strip_exec(C, op);
1097 }
1098
1099 void SEQUENCER_OT_effect_strip_add(struct wmOperatorType *ot)
1100 {
1101         /* identifiers */
1102         ot->name = "Add Effect Strip";
1103         ot->idname = "SEQUENCER_OT_effect_strip_add";
1104         ot->description = "Add an effect to the sequencer, most are applied on top of existing strips";
1105
1106         /* api callbacks */
1107         ot->invoke = sequencer_add_effect_strip_invoke;
1108         ot->exec = sequencer_add_effect_strip_exec;
1109
1110         ot->poll = ED_operator_sequencer_active_editable;
1111         
1112         /* flags */
1113         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1114         
1115         sequencer_generic_props__internal(ot, SEQPROP_STARTFRAME | SEQPROP_ENDFRAME);
1116         RNA_def_enum(ot->srna, "type", sequencer_prop_effect_types, SEQ_TYPE_CROSS, "Type", "Sequencer effect type");
1117         RNA_def_float_vector(ot->srna, "color", 3, NULL, 0.0f, 1.0f, "Color",
1118                              "Initialize the strip with this color (only used when type='COLOR')", 0.0f, 1.0f);
1119 }