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