Cleanup: use `rna_enum_` prefix for RNA enums
[blender.git] / source / blender / editors / space_sequencer / sequencer_modifier.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) 2012 Blender Foundation.
19  * All rights reserved.
20  *
21  * Contributor(s): Blender Foundation,
22  *                 Sergey Sharybin
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27
28 /** \file blender/editors/space_sequencer/sequencer_modifier.c
29  *  \ingroup spseq
30  */
31
32
33 #include "BLI_blenlib.h"
34 #include "BLI_utildefines.h"
35
36 #include "DNA_scene_types.h"
37
38 #include "BKE_context.h"
39 #include "BKE_sequencer.h"
40
41 #include "WM_api.h"
42 #include "WM_types.h"
43
44 #include "RNA_define.h"
45 #include "RNA_enum_types.h"
46
47
48 /* own include */
49 #include "sequencer_intern.h"
50
51 /*********************** Add modifier operator *************************/
52
53 static int strip_modifier_active_poll(bContext *C)
54 {
55         Scene *scene = CTX_data_scene(C);
56         Editing *ed = BKE_sequencer_editing_get(scene, false);
57
58         if (ed) {
59                 Sequence *seq = BKE_sequencer_active_get(scene);
60
61                 if (seq)
62                         return BKE_sequence_supports_modifiers(seq);
63         }
64
65         return false;
66 }
67
68 static int strip_modifier_add_exec(bContext *C, wmOperator *op)
69 {
70         Scene *scene = CTX_data_scene(C);
71         Sequence *seq = BKE_sequencer_active_get(scene);
72         int type = RNA_enum_get(op->ptr, "type");
73
74         BKE_sequence_modifier_new(seq, NULL, type);
75
76         BKE_sequence_invalidate_cache(scene, seq);
77         WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
78
79         return OPERATOR_FINISHED;
80 }
81
82 void SEQUENCER_OT_strip_modifier_add(wmOperatorType *ot)
83 {
84         PropertyRNA *prop;
85
86         /* identifiers */
87         ot->name = "Add Strip Modifier";
88         ot->idname = "SEQUENCER_OT_strip_modifier_add";
89         ot->description = "Add a modifier to the strip";
90
91         /* api callbacks */
92         ot->exec = strip_modifier_add_exec;
93         ot->poll = strip_modifier_active_poll;
94
95         /* flags */
96         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
97
98         /* properties */
99         prop = RNA_def_enum(ot->srna, "type", rna_enum_sequence_modifier_type_items, seqModifierType_ColorBalance, "Type", "");
100         ot->prop = prop;
101 }
102
103 /*********************** Remove modifier operator *************************/
104
105 static int strip_modifier_remove_exec(bContext *C, wmOperator *op)
106 {
107         Scene *scene = CTX_data_scene(C);
108         Sequence *seq = BKE_sequencer_active_get(scene);
109         char name[MAX_NAME];
110         SequenceModifierData *smd;
111
112         RNA_string_get(op->ptr, "name", name);
113
114         smd = BKE_sequence_modifier_find_by_name(seq, name);
115         if (!smd)
116                 return OPERATOR_CANCELLED;
117
118         BLI_remlink(&seq->modifiers, smd);
119         BKE_sequence_modifier_free(smd);
120
121         BKE_sequence_invalidate_cache(scene, seq);
122         WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
123
124         return OPERATOR_FINISHED;
125 }
126
127 void SEQUENCER_OT_strip_modifier_remove(wmOperatorType *ot)
128 {
129         /* identifiers */
130         ot->name = "Remove Strip Modifier";
131         ot->idname = "SEQUENCER_OT_strip_modifier_remove";
132         ot->description = "Remove a modifier from the strip";
133
134         /* api callbacks */
135         ot->exec = strip_modifier_remove_exec;
136         ot->poll = strip_modifier_active_poll;
137
138         /* flags */
139         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
140
141         /* properties */
142         RNA_def_string(ot->srna, "name", "Name", MAX_NAME, "Name", "Name of modifier to remove");
143 }
144
145 /*********************** Move operator *************************/
146
147 enum {
148         SEQ_MODIFIER_MOVE_UP = 0,
149         SEQ_MODIFIER_MOVE_DOWN
150 };
151
152 static int strip_modifier_move_exec(bContext *C, wmOperator *op)
153 {
154         Scene *scene = CTX_data_scene(C);
155         Sequence *seq = BKE_sequencer_active_get(scene);
156         char name[MAX_NAME];
157         int direction;
158         SequenceModifierData *smd;
159
160         RNA_string_get(op->ptr, "name", name);
161         direction = RNA_enum_get(op->ptr, "direction");
162
163         smd = BKE_sequence_modifier_find_by_name(seq, name);
164         if (!smd)
165                 return OPERATOR_CANCELLED;
166
167         if (direction == SEQ_MODIFIER_MOVE_UP) {
168                 if (smd->prev) {
169                         BLI_remlink(&seq->modifiers, smd);
170                         BLI_insertlinkbefore(&seq->modifiers, smd->prev, smd);
171                 }
172         }
173         else if (direction == SEQ_MODIFIER_MOVE_DOWN) {
174                 if (smd->next) {
175                         BLI_remlink(&seq->modifiers, smd);
176                         BLI_insertlinkafter(&seq->modifiers, smd->next, smd);
177                 }
178         }
179
180         BKE_sequence_invalidate_cache(scene, seq);
181         WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
182
183         return OPERATOR_FINISHED;
184 }
185
186 void SEQUENCER_OT_strip_modifier_move(wmOperatorType *ot)
187 {
188         static EnumPropertyItem direction_items[] = {
189                 {SEQ_MODIFIER_MOVE_UP, "UP", 0, "Up", "Move modifier up in the stack"},
190                 {SEQ_MODIFIER_MOVE_DOWN, "DOWN", 0, "Down", "Move modifier down in the stack"},
191                 {0, NULL, 0, NULL, NULL}
192         };
193
194         /* identifiers */
195         ot->name = "Move Strip Modifier";
196         ot->idname = "SEQUENCER_OT_strip_modifier_move";
197         ot->description = "Move modifier up and down in the stack";
198
199         /* api callbacks */
200         ot->exec = strip_modifier_move_exec;
201         ot->poll = strip_modifier_active_poll;
202
203         /* flags */
204         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
205
206         /* properties */
207         RNA_def_string(ot->srna, "name", "Name", MAX_NAME, "Name", "Name of modifier to remove");
208         RNA_def_enum(ot->srna, "direction", direction_items, SEQ_MODIFIER_MOVE_UP, "Type", "");
209 }
210
211 static int strip_modifier_copy_exec(bContext *C, wmOperator *UNUSED(op))
212 {
213         Scene *scene = CTX_data_scene(C);
214         Editing *ed = scene->ed;
215         Sequence *seq = BKE_sequencer_active_get(scene);
216         Sequence *seq_iter;
217
218         if (!seq || !seq->modifiers.first)
219                 return OPERATOR_CANCELLED;
220
221         SEQP_BEGIN(ed, seq_iter)
222         {
223                 if (seq_iter->flag & SELECT) {
224                         if (seq_iter == seq)
225                                 continue;
226
227                         if (seq_iter->modifiers.first) {
228                                 SequenceModifierData *smd_tmp, *smd = seq_iter->modifiers.first;
229
230                                 while (smd) {
231                                         smd_tmp = smd->next;
232                                         BLI_remlink(&seq_iter->modifiers, smd);
233                                         BKE_sequence_modifier_free(smd);
234                                         smd = smd_tmp;
235                                 }
236                                 BLI_listbase_clear(&seq_iter->modifiers);
237                         }
238
239                         BKE_sequence_modifier_list_copy(seq_iter, seq);
240                 }
241         }
242         SEQ_END
243
244         BKE_sequence_invalidate_cache(scene, seq);
245         WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER, scene);
246
247         return OPERATOR_FINISHED;
248 }
249
250 void SEQUENCER_OT_strip_modifier_copy(wmOperatorType *ot)
251 {
252         /* identifiers */
253         ot->name = "Copy to Selected Strips";
254         ot->idname = "SEQUENCER_OT_strip_modifier_copy";
255         ot->description = "Copy modifiers of the active strip to all selected strips";
256
257         /* api callbacks */
258         ot->exec = strip_modifier_copy_exec;
259         ot->poll = strip_modifier_active_poll;
260
261         /* flags */
262         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
263 }
264