Cleanup: remove moar G.main usages.
[blender.git] / source / blender / editors / interface / interface_anim.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):
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/editors/interface/interface_anim.c
24  *  \ingroup edinterface
25  */
26
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30
31 #include "MEM_guardedalloc.h"
32
33 #include "DNA_anim_types.h"
34 #include "DNA_scene_types.h"
35 #include "DNA_screen_types.h"
36
37 #include "BLI_string.h"
38 #include "BLI_string_utf8.h"
39 #include "BLI_utildefines.h"
40
41 #include "BKE_context.h"
42 #include "BKE_depsgraph.h"
43 #include "BKE_fcurve.h"
44 #include "BKE_global.h"
45 #include "BKE_main.h"
46 #include "BKE_nla.h"
47
48 #include "ED_keyframing.h"
49
50 #include "UI_interface.h"
51
52 #include "RNA_access.h"
53
54 #include "WM_api.h"
55 #include "WM_types.h"
56
57 #include "interface_intern.h"
58
59 static FCurve *ui_but_get_fcurve(uiBut *but, AnimData **adt, bAction **action, bool *r_driven, bool *r_special)
60 {
61         /* for entire array buttons we check the first component, it's not perfect
62          * but works well enough in typical cases */
63         int rnaindex = (but->rnaindex == -1) ? 0 : but->rnaindex;
64
65         return rna_get_fcurve_context_ui(but->block->evil_C, &but->rnapoin, but->rnaprop, rnaindex, adt, action, r_driven, r_special);
66 }
67
68 void ui_but_anim_flag(uiBut *but, float cfra)
69 {
70         AnimData *adt;
71         bAction *act;
72         FCurve *fcu;
73         bool driven;
74         bool special;
75
76         but->flag &= ~(UI_BUT_ANIMATED | UI_BUT_ANIMATED_KEY | UI_BUT_DRIVEN);
77
78         /* NOTE: "special" is reserved for special F-Curves stored on the animation data
79          *        itself (which are used to animate properties of the animation data).
80          *        We count those as "animated" too for now
81          */
82         fcu = ui_but_get_fcurve(but, &adt, &act, &driven, &special);
83
84         if (fcu) {
85                 if (!driven) {
86                         but->flag |= UI_BUT_ANIMATED;
87
88                         /* T41525 - When the active action is a NLA strip being edited,
89                          * we need to correct the frame number to "look inside" the
90                          * remapped action
91                          */
92                         if (adt)
93                                 cfra = BKE_nla_tweakedit_remap(adt, cfra, NLATIME_CONVERT_UNMAP);
94
95                         if (fcurve_frame_has_keyframe(fcu, cfra, 0))
96                                 but->flag |= UI_BUT_ANIMATED_KEY;
97                 }
98                 else {
99                         but->flag |= UI_BUT_DRIVEN;
100                 }
101         }
102 }
103
104 /**
105  * \a str can be NULL to only perform check if \a but has an expression at all.
106  * \return if button has an expression.
107  */
108 bool ui_but_anim_expression_get(uiBut *but, char *str, size_t maxlen)
109 {
110         FCurve *fcu;
111         ChannelDriver *driver;
112         bool driven, special;
113
114         fcu = ui_but_get_fcurve(but, NULL, NULL, &driven, &special);
115
116         if (fcu && driven) {
117                 driver = fcu->driver;
118
119                 if (driver && driver->type == DRIVER_TYPE_PYTHON) {
120                         if (str) {
121                                 BLI_strncpy(str, driver->expression, maxlen);
122                         }
123                         return true;
124                 }
125         }
126
127         return false;
128 }
129
130 bool ui_but_anim_expression_set(uiBut *but, const char *str)
131 {
132         FCurve *fcu;
133         ChannelDriver *driver;
134         bool driven, special;
135
136         fcu = ui_but_get_fcurve(but, NULL, NULL, &driven, &special);
137
138         if (fcu && driven) {
139                 driver = fcu->driver;
140
141                 if (driver && (driver->type == DRIVER_TYPE_PYTHON)) {
142                         BLI_strncpy_utf8(driver->expression, str, sizeof(driver->expression));
143
144                         /* tag driver as needing to be recompiled */
145                         driver->flag |= DRIVER_FLAG_RECOMPILE;
146
147                         /* clear invalid flags which may prevent this from working */
148                         driver->flag &= ~DRIVER_FLAG_INVALID;
149                         fcu->flag &= ~FCURVE_DISABLED;
150
151                         /* this notifier should update the Graph Editor and trigger depsgraph refresh? */
152                         WM_event_add_notifier(but->block->evil_C, NC_ANIMATION | ND_KEYFRAME, NULL);
153
154                         return true;
155                 }
156         }
157
158         return false;
159 }
160
161 /* create new expression for button (i.e. a "scripted driver"), if it can be created... */
162 bool ui_but_anim_expression_create(uiBut *but, const char *str)
163 {
164         bContext *C = but->block->evil_C;
165         ID *id;
166         FCurve *fcu;
167         char *path;
168         bool ok = false;
169
170         /* button must have RNA-pointer to a numeric-capable property */
171         if (ELEM(NULL, but->rnapoin.data, but->rnaprop)) {
172                 if (G.debug & G_DEBUG)
173                         printf("ERROR: create expression failed - button has no RNA info attached\n");
174                 return false;
175         }
176
177         if (RNA_property_array_check(but->rnaprop) != 0) {
178                 if (but->rnaindex == -1) {
179                         if (G.debug & G_DEBUG)
180                                 printf("ERROR: create expression failed - can't create expression for entire array\n");
181                         return false;
182                 }
183         }
184
185         /* make sure we have animdata for this */
186         /* FIXME: until materials can be handled by depsgraph, don't allow drivers to be created for them */
187         id = (ID *)but->rnapoin.id.data;
188         if ((id == NULL) || (GS(id->name) == ID_MA) || (GS(id->name) == ID_TE)) {
189                 if (G.debug & G_DEBUG)
190                         printf("ERROR: create expression failed - invalid data-block for adding drivers (%p)\n", id);
191                 return false;
192         }
193
194         /* get path */
195         path = RNA_path_from_ID_to_property(&but->rnapoin, but->rnaprop);
196         if (path == NULL) {
197                 return false;
198         }
199
200         /* create driver */
201         fcu = verify_driver_fcurve(id, path, but->rnaindex, 1);
202         if (fcu) {
203                 ChannelDriver *driver = fcu->driver;
204
205                 if (driver) {
206                         /* set type of driver */
207                         driver->type = DRIVER_TYPE_PYTHON;
208
209                         /* set the expression */
210                         /* TODO: need some way of identifying variables used */
211                         BLI_strncpy_utf8(driver->expression, str, sizeof(driver->expression));
212
213                         /* updates */
214                         driver->flag |= DRIVER_FLAG_RECOMPILE;
215                         DAG_relations_tag_update(CTX_data_main(C));
216                         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME, NULL);
217                         ok = true;
218                 }
219         }
220
221         MEM_freeN(path);
222
223         return ok;
224 }
225
226 void ui_but_anim_autokey(bContext *C, uiBut *but, Scene *scene, float cfra)
227 {
228         Main *bmain = CTX_data_main(C);
229         ID *id;
230         bAction *action;
231         FCurve *fcu;
232         bool driven;
233         bool special;
234
235         fcu = ui_but_get_fcurve(but, NULL, &action, &driven, &special);
236
237         if (fcu == NULL)
238                 return;
239
240         if (special) {
241                 /* NLA Strip property */
242                 if (IS_AUTOKEY_ON(scene)) {
243                         ReportList *reports = CTX_wm_reports(C);
244                         ToolSettings *ts = scene->toolsettings;
245
246                         insert_keyframe_direct(reports, but->rnapoin, but->rnaprop, fcu, cfra, ts->keyframe_type, 0);
247                         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
248                 }
249         }
250         else if (driven) {
251                 /* Driver - Try to insert keyframe using the driver's input as the frame,
252                  * making it easier to set up corrective drivers
253                  */
254                 if (IS_AUTOKEY_ON(scene)) {
255                         ReportList *reports = CTX_wm_reports(C);
256                         ToolSettings *ts = scene->toolsettings;
257
258                         insert_keyframe_direct(reports, but->rnapoin, but->rnaprop, fcu, cfra, ts->keyframe_type, INSERTKEY_DRIVER);
259                         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
260                 }
261         }
262         else {
263                 id = but->rnapoin.id.data;
264
265                 /* TODO: this should probably respect the keyingset only option for anim */
266                 if (autokeyframe_cfra_can_key(scene, id)) {
267                         ReportList *reports = CTX_wm_reports(C);
268                         ToolSettings *ts = scene->toolsettings;
269                         short flag = ANIM_get_keyframing_flags(scene, 1);
270
271                         fcu->flag &= ~FCURVE_SELECTED;
272
273                         /* Note: We use but->rnaindex instead of fcu->array_index,
274                          *       because a button may control all items of an array at once.
275                          *       E.g., color wheels (see T42567). */
276                         BLI_assert((fcu->array_index == but->rnaindex) || (but->rnaindex == -1));
277                         insert_keyframe(bmain, reports, id, action, ((fcu->grp) ? (fcu->grp->name) : (NULL)),
278                                         fcu->rna_path, but->rnaindex, cfra, ts->keyframe_type, flag);
279
280                         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
281                 }
282         }
283 }
284
285 void ui_but_anim_copy_driver(bContext *C)
286 {
287         /* this operator calls UI_context_active_but_prop_get */
288         WM_operator_name_call(C, "ANIM_OT_copy_driver_button", WM_OP_INVOKE_DEFAULT, NULL);
289 }
290
291 void ui_but_anim_paste_driver(bContext *C)
292 {
293         /* this operator calls UI_context_active_but_prop_get */
294         WM_operator_name_call(C, "ANIM_OT_paste_driver_button", WM_OP_INVOKE_DEFAULT, NULL);
295 }