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