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