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