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