doxygen: add newline after \file
[blender.git] / source / blender / editors / animation / keyingsets.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2009 Blender Foundation, Joshua Leung
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edanimation
22  */
23
24
25 #include <stdio.h>
26 #include <stddef.h>
27 #include <string.h>
28 #include <math.h>
29 #include <float.h>
30
31 #include "MEM_guardedalloc.h"
32
33 #include "BLI_blenlib.h"
34 #include "BLI_utildefines.h"
35
36 #include "DNA_anim_types.h"
37 #include "DNA_scene_types.h"
38 #include "DNA_object_types.h"
39
40 #include "BKE_main.h"
41 #include "BKE_animsys.h"
42 #include "BKE_context.h"
43 #include "BKE_report.h"
44
45 #include "DEG_depsgraph.h"
46
47 #include "ED_keyframing.h"
48 #include "ED_screen.h"
49
50 #include "UI_interface.h"
51 #include "UI_resources.h"
52
53 #include "WM_api.h"
54 #include "WM_types.h"
55
56 #include "RNA_access.h"
57 #include "RNA_define.h"
58 #include "RNA_enum_types.h"
59
60 #include "anim_intern.h"
61
62 /* ************************************************** */
63 /* KEYING SETS - OPERATORS (for use in UI panels) */
64 /* These operators are really duplication of existing functionality, but just for completeness,
65  * they're here too, and will give the basic data needed...
66  */
67
68 /* poll callback for adding default KeyingSet */
69 static bool keyingset_poll_default_add(bContext *C)
70 {
71         /* as long as there's an active Scene, it's fine */
72         return (CTX_data_scene(C) != NULL);
73 }
74
75 /* poll callback for editing active KeyingSet */
76 static bool keyingset_poll_active_edit(bContext *C)
77 {
78         Scene *scene = CTX_data_scene(C);
79
80         if (scene == NULL)
81                 return 0;
82
83         /* there must be an active KeyingSet (and KeyingSets) */
84         return ((scene->active_keyingset > 0) && (scene->keyingsets.first));
85 }
86
87 /* poll callback for editing active KeyingSet Path */
88 static bool keyingset_poll_activePath_edit(bContext *C)
89 {
90         Scene *scene = CTX_data_scene(C);
91         KeyingSet *ks;
92
93         if (scene == NULL)
94                 return 0;
95         if (scene->active_keyingset <= 0)
96                 return 0;
97         else
98                 ks = BLI_findlink(&scene->keyingsets, scene->active_keyingset - 1);
99
100         /* there must be an active KeyingSet and an active path */
101         return ((ks) && (ks->paths.first) && (ks->active_path > 0));
102 }
103
104
105 /* Add a Default (Empty) Keying Set ------------------------- */
106
107 static int add_default_keyingset_exec(bContext *C, wmOperator *UNUSED(op))
108 {
109         Scene *scene = CTX_data_scene(C);
110         short flag = 0, keyingflag = 0;
111
112         /* validate flags
113          * - absolute KeyingSets should be created by default
114          */
115         flag |= KEYINGSET_ABSOLUTE;
116
117         /* 2nd arg is 0 to indicate that we don't want to include autokeying mode related settings */
118         keyingflag = ANIM_get_keyframing_flags(scene, 0);
119
120         /* call the API func, and set the active keyingset index */
121         BKE_keyingset_add(&scene->keyingsets, NULL, NULL, flag, keyingflag);
122
123         scene->active_keyingset = BLI_listbase_count(&scene->keyingsets);
124
125         /* send notifiers */
126         WM_event_add_notifier(C, NC_SCENE | ND_KEYINGSET, NULL);
127
128         return OPERATOR_FINISHED;
129 }
130
131 void ANIM_OT_keying_set_add(wmOperatorType *ot)
132 {
133         /* identifiers */
134         ot->name = "Add Empty Keying Set";
135         ot->idname = "ANIM_OT_keying_set_add";
136         ot->description = "Add a new (empty) Keying Set to the active Scene";
137
138         /* callbacks */
139         ot->exec = add_default_keyingset_exec;
140         ot->poll = keyingset_poll_default_add;
141 }
142
143 /* Remove 'Active' Keying Set ------------------------- */
144
145 static int remove_active_keyingset_exec(bContext *C, wmOperator *op)
146 {
147         Scene *scene = CTX_data_scene(C);
148         KeyingSet *ks;
149
150         /* verify the Keying Set to use:
151          * - use the active one
152          * - return error if it doesn't exist
153          */
154         if (scene->active_keyingset == 0) {
155                 BKE_report(op->reports, RPT_ERROR, "No active keying set to remove");
156                 return OPERATOR_CANCELLED;
157         }
158         else if (scene->active_keyingset < 0) {
159                 BKE_report(op->reports, RPT_ERROR, "Cannot remove built in keying set");
160                 return OPERATOR_CANCELLED;
161         }
162         else
163                 ks = BLI_findlink(&scene->keyingsets, scene->active_keyingset - 1);
164
165         /* free KeyingSet's data, then remove it from the scene */
166         BKE_keyingset_free(ks);
167         BLI_freelinkN(&scene->keyingsets, ks);
168
169         /* the active one should now be the previously second-to-last one */
170         scene->active_keyingset--;
171
172         /* send notifiers */
173         WM_event_add_notifier(C, NC_SCENE | ND_KEYINGSET, NULL);
174
175         return OPERATOR_FINISHED;
176 }
177
178 void ANIM_OT_keying_set_remove(wmOperatorType *ot)
179 {
180         /* identifiers */
181         ot->name = "Remove Active Keying Set";
182         ot->idname = "ANIM_OT_keying_set_remove";
183         ot->description = "Remove the active Keying Set";
184
185         /* callbacks */
186         ot->exec = remove_active_keyingset_exec;
187         ot->poll = keyingset_poll_active_edit;
188 }
189
190 /* Add Empty Keying Set Path ------------------------- */
191
192 static int add_empty_ks_path_exec(bContext *C, wmOperator *op)
193 {
194         Scene *scene = CTX_data_scene(C);
195         KeyingSet *ks;
196         KS_Path *ksp;
197
198         /* verify the Keying Set to use:
199          * - use the active one
200          * - return error if it doesn't exist
201          */
202         if (scene->active_keyingset == 0) {
203                 BKE_report(op->reports, RPT_ERROR, "No active keying set to add empty path to");
204                 return OPERATOR_CANCELLED;
205         }
206         else
207                 ks = BLI_findlink(&scene->keyingsets, scene->active_keyingset - 1);
208
209         /* don't use the API method for this, since that checks on values... */
210         ksp = MEM_callocN(sizeof(KS_Path), "KeyingSetPath Empty");
211         BLI_addtail(&ks->paths, ksp);
212         ks->active_path = BLI_listbase_count(&ks->paths);
213
214         ksp->groupmode = KSP_GROUP_KSNAME; // XXX?
215         ksp->idtype = ID_OB;
216         ksp->flag = KSP_FLAG_WHOLE_ARRAY;
217
218         return OPERATOR_FINISHED;
219 }
220
221 void ANIM_OT_keying_set_path_add(wmOperatorType *ot)
222 {
223         /* identifiers */
224         ot->name = "Add Empty Keying Set Path";
225         ot->idname = "ANIM_OT_keying_set_path_add";
226         ot->description = "Add empty path to active Keying Set";
227
228         /* callbacks */
229         ot->exec = add_empty_ks_path_exec;
230         ot->poll = keyingset_poll_active_edit;
231 }
232
233 /* Remove Active Keying Set Path ------------------------- */
234
235 static int remove_active_ks_path_exec(bContext *C, wmOperator *op)
236 {
237         Scene *scene = CTX_data_scene(C);
238         KeyingSet *ks = BLI_findlink(&scene->keyingsets, scene->active_keyingset - 1);
239
240         /* if there is a KeyingSet, find the nominated path to remove */
241         if (ks) {
242                 KS_Path *ksp = BLI_findlink(&ks->paths, ks->active_path - 1);
243
244                 if (ksp) {
245                         /* remove the active path from the KeyingSet */
246                         BKE_keyingset_free_path(ks, ksp);
247
248                         /* the active path should now be the previously second-to-last active one */
249                         ks->active_path--;
250                 }
251                 else {
252                         BKE_report(op->reports, RPT_ERROR, "No active keying set path to remove");
253                         return OPERATOR_CANCELLED;
254                 }
255         }
256         else {
257                 BKE_report(op->reports, RPT_ERROR, "No active keying set to remove a path from");
258                 return OPERATOR_CANCELLED;
259         }
260
261         return OPERATOR_FINISHED;
262 }
263
264 void ANIM_OT_keying_set_path_remove(wmOperatorType *ot)
265 {
266         /* identifiers */
267         ot->name = "Remove Active Keying Set Path";
268         ot->idname = "ANIM_OT_keying_set_path_remove";
269         ot->description = "Remove active Path from active Keying Set";
270
271         /* callbacks */
272         ot->exec = remove_active_ks_path_exec;
273         ot->poll = keyingset_poll_activePath_edit;
274 }
275
276 /* ************************************************** */
277 /* KEYING SETS - OPERATORS (for use in UI menus) */
278
279 /* Add to KeyingSet Button Operator ------------------------ */
280
281 static int add_keyingset_button_exec(bContext *C, wmOperator *op)
282 {
283         Scene *scene = CTX_data_scene(C);
284         KeyingSet *ks = NULL;
285         PropertyRNA *prop = NULL;
286         PointerRNA ptr = {{NULL}};
287         char *path = NULL;
288         short success = 0;
289         int index = 0, pflag = 0;
290         const bool all = RNA_boolean_get(op->ptr, "all");
291
292         /* try to add to keyingset using property retrieved from UI */
293         if (!UI_context_active_but_prop_get(C, &ptr, &prop, &index)) {
294                 /* pass event on if no active button found */
295                 return (OPERATOR_CANCELLED | OPERATOR_PASS_THROUGH);
296         }
297
298         /* verify the Keying Set to use:
299          * - use the active one for now (more control over this can be added later)
300          * - add a new one if it doesn't exist
301          */
302         if (scene->active_keyingset == 0) {
303                 short flag = 0, keyingflag = 0;
304
305                 /* validate flags
306                  * - absolute KeyingSets should be created by default
307                  */
308                 flag |= KEYINGSET_ABSOLUTE;
309
310                 keyingflag |= ANIM_get_keyframing_flags(scene, 0);
311
312                 if (IS_AUTOKEY_FLAG(scene, XYZ2RGB))
313                         keyingflag |= INSERTKEY_XYZ2RGB;
314
315                 /* call the API func, and set the active keyingset index */
316                 ks = BKE_keyingset_add(&scene->keyingsets, "ButtonKeyingSet", "Button Keying Set", flag, keyingflag);
317
318                 scene->active_keyingset = BLI_listbase_count(&scene->keyingsets);
319         }
320         else if (scene->active_keyingset < 0) {
321                 BKE_report(op->reports, RPT_ERROR, "Cannot add property to built in keying set");
322                 return OPERATOR_CANCELLED;
323         }
324         else {
325                 ks = BLI_findlink(&scene->keyingsets, scene->active_keyingset - 1);
326         }
327
328         /* check if property is able to be added */
329         if (ptr.id.data && ptr.data && prop && RNA_property_animateable(&ptr, prop)) {
330                 path = RNA_path_from_ID_to_property(&ptr, prop);
331
332                 if (path) {
333                         /* set flags */
334                         if (all) {
335                                 pflag |= KSP_FLAG_WHOLE_ARRAY;
336
337                                 /* we need to set the index for this to 0, even though it may break in some cases, this is
338                                  * necessary if we want the entire array for most cases to get included without the user
339                                  * having to worry about where they clicked
340                                  */
341                                 index = 0;
342                         }
343
344                         /* add path to this setting */
345                         BKE_keyingset_add_path(ks, ptr.id.data, NULL, path, index, pflag, KSP_GROUP_KSNAME);
346                         ks->active_path = BLI_listbase_count(&ks->paths);
347                         success = 1;
348
349                         /* free the temp path created */
350                         MEM_freeN(path);
351                 }
352         }
353
354         if (success) {
355                 /* send updates */
356                 WM_event_add_notifier(C, NC_SCENE | ND_KEYINGSET, NULL);
357
358                 /* show notification/report header, so that users notice that something changed */
359                 BKE_reportf(op->reports, RPT_INFO, "Property added to Keying Set: '%s'", ks->name);
360         }
361
362         return (success) ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
363 }
364
365 void ANIM_OT_keyingset_button_add(wmOperatorType *ot)
366 {
367         /* identifiers */
368         ot->name = "Add to Keying Set";
369         ot->idname = "ANIM_OT_keyingset_button_add";
370         ot->description = "Add current UI-active property to current keying set";
371
372         /* callbacks */
373         ot->exec = add_keyingset_button_exec;
374         //op->poll = ???
375
376         /* flags */
377         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
378
379         /* properties */
380         RNA_def_boolean(ot->srna, "all", 1, "All", "Add all elements of the array to a Keying Set");
381 }
382
383 /* Remove from KeyingSet Button Operator ------------------------ */
384
385 static int remove_keyingset_button_exec(bContext *C, wmOperator *op)
386 {
387         Scene *scene = CTX_data_scene(C);
388         KeyingSet *ks = NULL;
389         PropertyRNA *prop = NULL;
390         PointerRNA ptr = {{NULL}};
391         char *path = NULL;
392         short success = 0;
393         int index = 0;
394
395         /* try to add to keyingset using property retrieved from UI */
396         if (UI_context_active_but_prop_get(C, &ptr, &prop, &index)) {
397                 /* pass event on if no active button found */
398                 return (OPERATOR_CANCELLED | OPERATOR_PASS_THROUGH);
399         }
400
401         /* verify the Keying Set to use:
402          * - use the active one for now (more control over this can be added later)
403          * - return error if it doesn't exist
404          */
405         if (scene->active_keyingset == 0) {
406                 BKE_report(op->reports, RPT_ERROR, "No active keying set to remove property from");
407                 return OPERATOR_CANCELLED;
408         }
409         else if (scene->active_keyingset < 0) {
410                 BKE_report(op->reports, RPT_ERROR, "Cannot remove property from built in keying set");
411                 return OPERATOR_CANCELLED;
412         }
413         else {
414                 ks = BLI_findlink(&scene->keyingsets, scene->active_keyingset - 1);
415         }
416
417         if (ptr.id.data && ptr.data && prop) {
418                 path = RNA_path_from_ID_to_property(&ptr, prop);
419
420                 if (path) {
421                         KS_Path *ksp;
422
423                         /* try to find a path matching this description */
424                         ksp = BKE_keyingset_find_path(ks, ptr.id.data, ks->name, path, index, KSP_GROUP_KSNAME);
425
426                         if (ksp) {
427                                 BKE_keyingset_free_path(ks, ksp);
428                                 success = 1;
429                         }
430
431                         /* free temp path used */
432                         MEM_freeN(path);
433                 }
434         }
435
436
437         if (success) {
438                 /* send updates */
439                 WM_event_add_notifier(C, NC_SCENE | ND_KEYINGSET, NULL);
440
441                 /* show warning */
442                 BKE_report(op->reports, RPT_INFO, "Property removed from Keying Set");
443         }
444
445         return (success) ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
446 }
447
448 void ANIM_OT_keyingset_button_remove(wmOperatorType *ot)
449 {
450         /* identifiers */
451         ot->name = "Remove from Keying Set";
452         ot->idname = "ANIM_OT_keyingset_button_remove";
453         ot->description = "Remove current UI-active property from current keying set";
454
455         /* callbacks */
456         ot->exec = remove_keyingset_button_exec;
457         //op->poll = ???
458
459         /* flags */
460         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
461 }
462
463 /* ******************************************* */
464
465 /* Change Active KeyingSet Operator ------------------------ */
466 /* This operator checks if a menu should be shown for choosing the KeyingSet to make the active one */
467
468 static int keyingset_active_menu_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
469 {
470         uiPopupMenu *pup;
471         uiLayout *layout;
472
473         /* call the menu, which will call this operator again, hence the canceled */
474         pup = UI_popup_menu_begin(C, op->type->name, ICON_NONE);
475         layout = UI_popup_menu_layout(pup);
476         uiItemsEnumO(layout, "ANIM_OT_keying_set_active_set", "type");
477         UI_popup_menu_end(C, pup);
478
479         return OPERATOR_INTERFACE;
480 }
481
482 static int keyingset_active_menu_exec(bContext *C, wmOperator *op)
483 {
484         Scene *scene = CTX_data_scene(C);
485         int type = RNA_enum_get(op->ptr, "type");
486
487         /* If type == 0, it will deselect any active keying set. */
488         scene->active_keyingset = type;
489
490         /* send notifiers */
491         WM_event_add_notifier(C, NC_SCENE | ND_KEYINGSET, NULL);
492
493         return OPERATOR_FINISHED;
494 }
495
496 void ANIM_OT_keying_set_active_set(wmOperatorType *ot)
497 {
498         PropertyRNA *prop;
499
500         /* identifiers */
501         ot->name = "Set Active Keying Set";
502         ot->idname = "ANIM_OT_keying_set_active_set";
503         ot->description = "Select a new keying set as the active one";
504
505         /* callbacks */
506         ot->invoke = keyingset_active_menu_invoke;
507         ot->exec = keyingset_active_menu_exec;
508         ot->poll = ED_operator_areaactive;
509
510         /* flags */
511         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
512
513         /* keyingset to use (dynamic enum) */
514         prop = RNA_def_enum(ot->srna, "type", DummyRNA_DEFAULT_items, 0, "Keying Set", "The Keying Set to use");
515         RNA_def_enum_funcs(prop, ANIM_keying_sets_enum_itemf);
516         // RNA_def_property_flag(prop, PROP_HIDDEN);
517 }
518
519 /* ******************************************* */
520 /* REGISTERED KEYING SETS */
521
522 /* Keying Set Type Info declarations */
523 static ListBase keyingset_type_infos = {NULL, NULL};
524
525 /* Built-In Keying Sets (referencing type infos)*/
526 ListBase builtin_keyingsets = {NULL, NULL};
527
528 /* --------------- */
529
530 /* Find KeyingSet type info given a name */
531 KeyingSetInfo *ANIM_keyingset_info_find_name(const char name[])
532 {
533         /* sanity checks */
534         if ((name == NULL) || (name[0] == 0))
535                 return NULL;
536
537         /* search by comparing names */
538         return BLI_findstring(&keyingset_type_infos, name, offsetof(KeyingSetInfo, idname));
539 }
540
541 /* Find builtin KeyingSet by name */
542 KeyingSet *ANIM_builtin_keyingset_get_named(KeyingSet *prevKS, const char name[])
543 {
544         KeyingSet *ks, *first = NULL;
545
546         /* sanity checks  any name to check? */
547         if (name[0] == 0)
548                 return NULL;
549
550         /* get first KeyingSet to use */
551         if (prevKS && prevKS->next)
552                 first = prevKS->next;
553         else
554                 first = builtin_keyingsets.first;
555
556         /* loop over KeyingSets checking names */
557         for (ks = first; ks; ks = ks->next) {
558                 if (STREQ(name, ks->idname))
559                         return ks;
560         }
561
562         /* complain about missing keying sets on debug builds */
563 #ifndef NDEBUG
564         printf("%s: '%s' not found\n", __func__, name);
565 #endif
566
567         /* no matches found */
568         return NULL;
569 }
570
571 /* --------------- */
572
573 /* Add the given KeyingSetInfo to the list of type infos, and create an appropriate builtin set too */
574 void ANIM_keyingset_info_register(KeyingSetInfo *ksi)
575 {
576         KeyingSet *ks;
577
578         /* create a new KeyingSet
579          * - inherit name and keyframing settings from the typeinfo
580          */
581         ks = BKE_keyingset_add(&builtin_keyingsets, ksi->idname, ksi->name, 1, ksi->keyingflag);
582
583         /* link this KeyingSet with its typeinfo */
584         memcpy(&ks->typeinfo, ksi->idname, sizeof(ks->typeinfo));
585
586         /* Copy description... */
587         BLI_strncpy(ks->description, ksi->description, sizeof(ks->description));
588
589         /* add type-info to the list */
590         BLI_addtail(&keyingset_type_infos, ksi);
591 }
592
593 /* Remove the given KeyingSetInfo from the list of type infos, and also remove the builtin set if appropriate */
594 void ANIM_keyingset_info_unregister(Main *bmain, KeyingSetInfo *ksi)
595 {
596         KeyingSet *ks, *ksn;
597
598         /* find relevant builtin KeyingSets which use this, and remove them */
599         /* TODO: this isn't done now, since unregister is really only used atm when we
600          * reload the scripts, which kindof defeats the purpose of "builtin"? */
601         for (ks = builtin_keyingsets.first; ks; ks = ksn) {
602                 ksn = ks->next;
603
604                 /* remove if matching typeinfo name */
605                 if (STREQ(ks->typeinfo, ksi->idname)) {
606                         Scene *scene;
607                         BKE_keyingset_free(ks);
608                         BLI_remlink(&builtin_keyingsets, ks);
609
610                         for (scene = bmain->scene.first; scene; scene = scene->id.next)
611                                 BLI_remlink_safe(&scene->keyingsets, ks);
612
613                         MEM_freeN(ks);
614                 }
615         }
616
617         /* free the type info */
618         BLI_freelinkN(&keyingset_type_infos, ksi);
619 }
620
621 /* --------------- */
622
623 void ANIM_keyingset_infos_exit(void)
624 {
625         KeyingSetInfo *ksi, *next;
626
627         /* free type infos */
628         for (ksi = keyingset_type_infos.first; ksi; ksi = next) {
629                 next = ksi->next;
630
631                 /* free extra RNA data, and remove from list */
632                 if (ksi->ext.free)
633                         ksi->ext.free(ksi->ext.data);
634                 BLI_freelinkN(&keyingset_type_infos, ksi);
635         }
636
637         /* free builtin sets */
638         BKE_keyingsets_free(&builtin_keyingsets);
639 }
640
641 /* Check if the ID appears in the paths specified by the KeyingSet */
642 bool ANIM_keyingset_find_id(KeyingSet *ks, ID *id)
643 {
644         /* sanity checks */
645         if (ELEM(NULL, ks, id))
646                 return false;
647
648         return BLI_findptr(&ks->paths, id, offsetof(KS_Path, id)) != NULL;
649 }
650
651 /* ******************************************* */
652 /* KEYING SETS API (for UI) */
653
654 /* Getters for Active/Indices ----------------------------- */
655
656 /* Get the active Keying Set for the Scene provided */
657 KeyingSet *ANIM_scene_get_active_keyingset(Scene *scene)
658 {
659         /* if no scene, we've got no hope of finding the Keying Set */
660         if (scene == NULL)
661                 return NULL;
662
663         /* currently, there are several possibilities here:
664          * -   0: no active keying set
665          * - > 0: one of the user-defined Keying Sets, but indices start from 0 (hence the -1)
666          * - < 0: a builtin keying set
667          */
668         if (scene->active_keyingset > 0)
669                 return BLI_findlink(&scene->keyingsets, scene->active_keyingset - 1);
670         else
671                 return BLI_findlink(&builtin_keyingsets, (-scene->active_keyingset) - 1);
672 }
673
674 /* Get the index of the Keying Set provided, for the given Scene */
675 int ANIM_scene_get_keyingset_index(Scene *scene, KeyingSet *ks)
676 {
677         int index;
678
679         /* if no KeyingSet provided, have none */
680         if (ks == NULL)
681                 return 0;
682
683         /* check if the KeyingSet exists in scene list */
684         if (scene) {
685                 /* get index and if valid, return
686                  * - (absolute) Scene KeyingSets are from (>= 1)
687                  */
688                 index = BLI_findindex(&scene->keyingsets, ks);
689                 if (index != -1)
690                         return (index + 1);
691         }
692
693         /* still here, so try builtins list too
694          * - builtins are from (<= -1)
695          * - none/invalid is (= 0)
696          */
697         index = BLI_findindex(&builtin_keyingsets, ks);
698         if (index != -1)
699                 return -(index + 1);
700         else
701                 return 0;
702 }
703
704 /* Get Keying Set to use for Auto-Keyframing some transforms */
705 KeyingSet *ANIM_get_keyingset_for_autokeying(Scene *scene, const char *transformKSName)
706 {
707         /* get KeyingSet to use
708          * - use the active KeyingSet if defined (and user wants to use it for all autokeying),
709          *   or otherwise key transforms only
710          */
711         if (IS_AUTOKEY_FLAG(scene, ONLYKEYINGSET) && (scene->active_keyingset))
712                 return ANIM_scene_get_active_keyingset(scene);
713         else if (IS_AUTOKEY_FLAG(scene, INSERTAVAIL))
714                 return ANIM_builtin_keyingset_get_named(NULL, ANIM_KS_AVAILABLE_ID);
715         else
716                 return ANIM_builtin_keyingset_get_named(NULL, transformKSName);
717 }
718
719 /* Menu of All Keying Sets ----------------------------- */
720
721 /* Dynamically populate an enum of Keying Sets */
722 const EnumPropertyItem *ANIM_keying_sets_enum_itemf(bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
723 {
724         Scene *scene = CTX_data_scene(C);
725         KeyingSet *ks;
726         EnumPropertyItem *item = NULL, item_tmp = {0};
727         int totitem = 0;
728         int i = 0;
729
730         if (C == NULL) {
731                 return DummyRNA_DEFAULT_items;
732         }
733
734         /* active Keying Set
735          * - only include entry if it exists
736          */
737         if (scene->active_keyingset) {
738                 /* active Keying Set */
739                 item_tmp.identifier = "__ACTIVE__";
740                 item_tmp.name = "Active Keying Set";
741                 item_tmp.value = i;
742                 RNA_enum_item_add(&item, &totitem, &item_tmp);
743
744                 /* separator */
745                 RNA_enum_item_add_separator(&item, &totitem);
746         }
747
748         i++;
749
750         /* user-defined Keying Sets
751          * - these are listed in the order in which they were defined for the active scene
752          */
753         if (scene->keyingsets.first) {
754                 for (ks = scene->keyingsets.first; ks; ks = ks->next, i++) {
755                         if (ANIM_keyingset_context_ok_poll(C, ks)) {
756                                 item_tmp.identifier = ks->idname;
757                                 item_tmp.name = ks->name;
758                                 item_tmp.description = ks->description;
759                                 item_tmp.value = i;
760                                 RNA_enum_item_add(&item, &totitem, &item_tmp);
761                         }
762                 }
763
764                 /* separator */
765                 RNA_enum_item_add_separator(&item, &totitem);
766         }
767
768         /* builtin Keying Sets */
769         i = -1;
770         for (ks = builtin_keyingsets.first; ks; ks = ks->next, i--) {
771                 /* only show KeyingSet if context is suitable */
772                 if (ANIM_keyingset_context_ok_poll(C, ks)) {
773                         item_tmp.identifier = ks->idname;
774                         item_tmp.name = ks->name;
775                         item_tmp.description = ks->description;
776                         item_tmp.value = i;
777                         RNA_enum_item_add(&item, &totitem, &item_tmp);
778                 }
779         }
780
781         RNA_enum_item_end(&item, &totitem);
782         *r_free = true;
783
784         return item;
785 }
786
787 /* ******************************************* */
788 /* KEYFRAME MODIFICATION */
789
790 /* Polling API ----------------------------------------------- */
791
792 /* Check if KeyingSet can be used in the current context */
793 bool ANIM_keyingset_context_ok_poll(bContext *C, KeyingSet *ks)
794 {
795         if ((ks->flag & KEYINGSET_ABSOLUTE) == 0) {
796                 KeyingSetInfo *ksi = ANIM_keyingset_info_find_name(ks->typeinfo);
797
798                 /* get the associated 'type info' for this KeyingSet */
799                 if (ksi == NULL)
800                         return 0;
801                 /* TODO: check for missing callbacks! */
802
803                 /* check if it can be used in the current context */
804                 return (ksi->poll(ksi, C));
805         }
806
807         return true;
808 }
809
810 /* Special 'Overrides' Iterator for Relative KeyingSets ------ */
811
812 /* 'Data Sources' for relative Keying Set 'overrides'
813  * - this is basically a wrapper for PointerRNA's in a linked list
814  * - do not allow this to be accessed from outside for now
815  */
816 typedef struct tRKS_DSource {
817         struct tRKS_DSource *next, *prev;
818         PointerRNA ptr;     /* the whole point of this exercise! */
819 } tRKS_DSource;
820
821
822 /* Iterator used for overriding the behavior of iterators defined for
823  * relative Keying Sets, with the main usage of this being operators
824  * requiring Auto Keyframing. Internal Use Only!
825  */
826 static void RKS_ITER_overrides_list(KeyingSetInfo *ksi, bContext *C, KeyingSet *ks, ListBase *dsources)
827 {
828         tRKS_DSource *ds;
829
830         for (ds = dsources->first; ds; ds = ds->next) {
831                 /* run generate callback on this data */
832                 ksi->generate(ksi, C, ks, &ds->ptr);
833         }
834 }
835
836 /* Add new data source for relative Keying Sets */
837 void ANIM_relative_keyingset_add_source(ListBase *dsources, ID *id, StructRNA *srna, void *data)
838 {
839         tRKS_DSource *ds;
840
841         /* sanity checks
842          * - we must have somewhere to output the data
843          * - we must have both srna+data (and with id too optionally), or id by itself only
844          */
845         if (dsources == NULL)
846                 return;
847         if (ELEM(NULL, srna, data) && (id == NULL))
848                 return;
849
850         /* allocate new elem, and add to the list */
851         ds = MEM_callocN(sizeof(tRKS_DSource), "tRKS_DSource");
852         BLI_addtail(dsources, ds);
853
854         /* depending on what data we have, create using ID or full pointer call */
855         if (srna && data)
856                 RNA_pointer_create(id, srna, data, &ds->ptr);
857         else
858                 RNA_id_pointer_create(id, &ds->ptr);
859 }
860
861 /* KeyingSet Operations (Insert/Delete Keyframes) ------------ */
862
863 /* Given a KeyingSet and context info, validate Keying Set's paths.
864  * This is only really necessary with relative/built-in KeyingSets
865  * where their list of paths is dynamically generated based on the
866  * current context info.
867  *
868  * Returns 0 if succeeded, otherwise an error code: eModifyKey_Returns
869  */
870 short ANIM_validate_keyingset(bContext *C, ListBase *dsources, KeyingSet *ks)
871 {
872         /* sanity check */
873         if (ks == NULL)
874                 return 0;
875
876         /* if relative Keying Sets, poll and build up the paths */
877         if ((ks->flag & KEYINGSET_ABSOLUTE) == 0) {
878                 KeyingSetInfo *ksi = ANIM_keyingset_info_find_name(ks->typeinfo);
879
880                 /* clear all existing paths
881                  * NOTE: BKE_keyingset_free() frees all of the paths for the KeyingSet, but not the set itself
882                  */
883                 BKE_keyingset_free(ks);
884
885                 /* get the associated 'type info' for this KeyingSet */
886                 if (ksi == NULL)
887                         return MODIFYKEY_MISSING_TYPEINFO;
888                 /* TODO: check for missing callbacks! */
889
890                 /* check if it can be used in the current context */
891                 if (ksi->poll(ksi, C)) {
892                         /* if a list of data sources are provided, run a special iterator over them,
893                          * otherwise, just continue per normal
894                          */
895                         if (dsources)
896                                 RKS_ITER_overrides_list(ksi, C, ks, dsources);
897                         else
898                                 ksi->iter(ksi, C, ks);
899
900                         /* if we don't have any paths now, then this still qualifies as invalid context */
901                         // FIXME: we need some error conditions (to be retrieved from the iterator why this failed!)
902                         if (BLI_listbase_is_empty(&ks->paths))
903                                 return MODIFYKEY_INVALID_CONTEXT;
904                 }
905                 else {
906                         /* poll callback tells us that KeyingSet is useless in current context */
907                         // FIXME: the poll callback needs to give us more info why
908                         return MODIFYKEY_INVALID_CONTEXT;
909                 }
910         }
911
912         /* succeeded; return 0 to tag error free */
913         return 0;
914 }
915
916 /* Determine which keying flags apply based on the override flags */
917 static short keyingset_apply_keying_flags(const short base_flags, const short overrides, const short own_flags)
918 {
919         /* Pass through all flags by default (i.e. even not explicitly listed ones). */
920         short result = base_flags;
921
922         /* The logic for whether a keying flag applies is as follows:
923          * - If the flag in question is set in "overrides", that means that the
924          *   status of that flag in "own_flags" is used
925          * - If however the flag isn't set, then its value in "base_flags" is used
926          *   instead (i.e. no override)
927          */
928 #define APPLY_KEYINGFLAG_OVERRIDE(kflag) \
929         if (overrides & kflag) {             \
930                 result &= ~kflag;                \
931                 result |= (own_flags & kflag);   \
932         }
933
934         /* Apply the flags one by one...
935          * (See rna_def_common_keying_flags() for the supported flags)
936          */
937         APPLY_KEYINGFLAG_OVERRIDE(INSERTKEY_NEEDED)
938         APPLY_KEYINGFLAG_OVERRIDE(INSERTKEY_MATRIX)
939         APPLY_KEYINGFLAG_OVERRIDE(INSERTKEY_XYZ2RGB)
940
941 #undef APPLY_KEYINGFLAG_OVERRIDE
942
943         return result;
944 }
945
946 /* Given a KeyingSet and context info (if required), modify keyframes for the channels specified
947  * by the KeyingSet. This takes into account many of the different combinations of using KeyingSets.
948  * Returns the number of channels that keyframes were added to
949  */
950 int ANIM_apply_keyingset(bContext *C, ListBase *dsources, bAction *act, KeyingSet *ks, short mode, float cfra)
951 {
952         Depsgraph *depsgraph = CTX_data_depsgraph(C);
953         Main *bmain = CTX_data_main(C);
954         Scene *scene = CTX_data_scene(C);
955         ReportList *reports = CTX_wm_reports(C);
956         KS_Path *ksp;
957         ListBase nla_cache = {NULL, NULL};
958         const short base_kflags = ANIM_get_keyframing_flags(scene, 1);
959         const char *groupname = NULL;
960         short kflag = 0, success = 0;
961         char keytype = scene->toolsettings->keyframe_type;
962
963         /* sanity checks */
964         if (ks == NULL)
965                 return 0;
966
967         /* get flags to use */
968         if (mode == MODIFYKEY_MODE_INSERT) {
969                 /* use context settings as base */
970                 kflag = keyingset_apply_keying_flags(base_kflags, ks->keyingoverride, ks->keyingflag);
971         }
972         else if (mode == MODIFYKEY_MODE_DELETE)
973                 kflag = 0;
974
975         /* if relative Keying Sets, poll and build up the paths */
976         success = ANIM_validate_keyingset(C, dsources, ks);
977
978         if (success != 0) {
979                 /* return error code if failed */
980                 return success;
981         }
982
983         /* apply the paths as specified in the KeyingSet now */
984         for (ksp = ks->paths.first; ksp; ksp = ksp->next) {
985                 int arraylen, i;
986                 short kflag2;
987
988                 /* skip path if no ID pointer is specified */
989                 if (ksp->id == NULL) {
990                         BKE_reportf(reports, RPT_WARNING,
991                                     "Skipping path in keying set, as it has no ID (KS = '%s', path = '%s[%d]')",
992                                     ks->name, ksp->rna_path, ksp->array_index);
993                         continue;
994                 }
995
996                 /* since keying settings can be defined on the paths too, apply the settings for this path first */
997                 kflag2 = keyingset_apply_keying_flags(kflag, ksp->keyingoverride, ksp->keyingflag);
998
999                 /* get pointer to name of group to add channels to */
1000                 if (ksp->groupmode == KSP_GROUP_NONE)
1001                         groupname = NULL;
1002                 else if (ksp->groupmode == KSP_GROUP_KSNAME)
1003                         groupname = ks->name;
1004                 else
1005                         groupname = ksp->group;
1006
1007                 /* init arraylen and i - arraylen should be greater than i so that
1008                  * normal non-array entries get keyframed correctly
1009                  */
1010                 i = ksp->array_index;
1011                 arraylen = i;
1012
1013                 /* get length of array if whole array option is enabled */
1014                 if (ksp->flag & KSP_FLAG_WHOLE_ARRAY) {
1015                         PointerRNA id_ptr, ptr;
1016                         PropertyRNA *prop;
1017
1018                         RNA_id_pointer_create(ksp->id, &id_ptr);
1019                         if (RNA_path_resolve_property(&id_ptr, ksp->rna_path, &ptr, &prop)) {
1020                                 arraylen = RNA_property_array_length(&ptr, prop);
1021                                 /* start from start of array, instead of the previously specified index - T48020 */
1022                                 i = 0;
1023                         }
1024                 }
1025
1026                 /* we should do at least one step */
1027                 if (arraylen == i)
1028                         arraylen++;
1029
1030                 /* for each possible index, perform operation
1031                  * - assume that arraylen is greater than index
1032                  */
1033                 for (; i < arraylen; i++) {
1034                         /* action to take depends on mode */
1035                         if (mode == MODIFYKEY_MODE_INSERT)
1036                                 success += insert_keyframe(bmain, depsgraph, reports, ksp->id, act, groupname, ksp->rna_path, i, cfra, keytype, &nla_cache, kflag2);
1037                         else if (mode == MODIFYKEY_MODE_DELETE)
1038                                 success += delete_keyframe(bmain, reports, ksp->id, act, groupname, ksp->rna_path, i, cfra, kflag2);
1039                 }
1040
1041                 /* set recalc-flags */
1042                 switch (GS(ksp->id->name)) {
1043                         case ID_OB: /* Object (or Object-Related) Keyframes */
1044                         {
1045                                 Object *ob = (Object *)ksp->id;
1046
1047                                 // XXX: only object transforms?
1048                                 DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
1049                                 break;
1050                         }
1051                         default:
1052                                 DEG_id_tag_update(ksp->id, ID_RECALC_COPY_ON_WRITE);
1053                                 break;
1054                 }
1055
1056                 /* send notifiers for updates (this doesn't require context to work!) */
1057                 WM_main_add_notifier(NC_ANIMATION | ND_KEYFRAME | NA_ADDED, NULL);
1058         }
1059
1060         BKE_animsys_free_nla_keyframing_context_cache(&nla_cache);
1061
1062         /* return the number of channels successfully affected */
1063         return success;
1064 }
1065
1066 /* ************************************************** */