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