b031a54495378c770f8842f272866364f545e9f3
[blender-staging.git] / source / blender / editors / animation / keyframing.c
1 /* Testing code for 2.5 animation system 
2  * Copyright 2009, Joshua Leung
3  */
4  
5 #include <stdio.h>
6 #include <stddef.h>
7 #include <string.h>
8 #include <math.h>
9 #include <float.h>
10
11 #include "MEM_guardedalloc.h"
12
13 #include "BLI_blenlib.h"
14 #include "BLI_arithb.h"
15 #include "BLI_dynstr.h"
16
17 #include "DNA_anim_types.h"
18 #include "DNA_action_types.h"
19 #include "DNA_armature_types.h"
20 #include "DNA_constraint_types.h"
21 #include "DNA_key_types.h"
22 #include "DNA_object_types.h"
23 #include "DNA_material_types.h"
24 #include "DNA_scene_types.h"
25 #include "DNA_userdef_types.h"
26 #include "DNA_windowmanager_types.h"
27
28 #include "BKE_animsys.h"
29 #include "BKE_action.h"
30 #include "BKE_constraint.h"
31 #include "BKE_fcurve.h"
32 #include "BKE_utildefines.h"
33 #include "BKE_context.h"
34 #include "BKE_report.h"
35 #include "BKE_key.h"
36 #include "BKE_material.h"
37
38 #include "ED_anim_api.h"
39 #include "ED_keyframing.h"
40 #include "ED_keyframes_edit.h"
41 #include "ED_screen.h"
42 #include "ED_util.h"
43
44 #include "UI_interface.h"
45
46 #include "WM_api.h"
47 #include "WM_types.h"
48
49 #include "RNA_access.h"
50 #include "RNA_define.h"
51 #include "RNA_types.h"
52
53 /* ************************************************** */
54 /* LOCAL TYPES AND DEFINES */
55
56 /* ----------- Common KeyData Sources ------------ */
57
58 /* temporary struct to gather data combos to keyframe */
59 typedef struct bCommonKeySrc {
60         struct bCommonKeySrc *next, *prev;
61                 
62                 /* general data/destination-source settings */
63         ID *id;                                 /* id-block this comes from */
64         char *rna_path;                 /* base path to use */  // xxx.... maybe we don't need this?
65         
66                 /* specific cases */
67         bPoseChannel *pchan;    /* only needed when doing recalcs... */
68 } bCommonKeySrc;
69
70 /* ******************************************* */
71 /* Animation Data Validation */
72
73 /* Get (or add relevant data to be able to do so) F-Curve from the Active Action, 
74  * for the given Animation Data block. This assumes that all the destinations are valid.
75  */
76 FCurve *verify_fcurve (ID *id, const char group[], const char rna_path[], const int array_index, short add)
77 {
78         AnimData *adt;
79         bAction *act;
80         bActionGroup *grp;
81         FCurve *fcu;
82         
83         /* sanity checks */
84         if ELEM(NULL, id, rna_path)
85                 return NULL;
86         
87         /* init animdata if none available yet */
88         adt= BKE_animdata_from_id(id);
89         if ((adt == NULL) && (add))
90                 adt= BKE_id_add_animdata(id);
91         if (adt == NULL) { 
92                 /* if still none (as not allowed to add, or ID doesn't have animdata for some reason) */
93                 return NULL;
94         }
95                 
96         /* init action if none available yet */
97         // TODO: need some wizardry to handle NLA stuff correct
98         if ((adt->action == NULL) && (add))
99                 adt->action= add_empty_action("Action");
100         act= adt->action;
101                 
102         /* try to find f-curve matching for this setting 
103          *      - add if not found and allowed to add one
104          *              TODO: add auto-grouping support? how this works will need to be resolved
105          */
106         if (act)
107                 fcu= list_find_fcurve(&act->curves, rna_path, array_index);
108         else
109                 fcu= NULL;
110         
111         if ((fcu == NULL) && (add)) {
112                 /* use default settings to make a F-Curve */
113                 fcu= MEM_callocN(sizeof(FCurve), "FCurve");
114                 
115                 fcu->flag = (FCURVE_VISIBLE|FCURVE_AUTO_HANDLES|FCURVE_SELECTED);
116                 if (act->curves.first==NULL) 
117                         fcu->flag |= FCURVE_ACTIVE;     /* first one added active */
118                         
119                 /* store path - make copy, and store that */
120                 fcu->rna_path= BLI_strdupn(rna_path, strlen(rna_path));
121                 fcu->array_index= array_index;
122                 
123                 /* if a group name has been provided, try to add or find a group, then add F-Curve to it */
124                 if (group) {
125                         /* try to find group */
126                         grp= action_groups_find_named(act, group);
127                         
128                         /* no matching groups, so add one */
129                         if (grp == NULL) {
130                                 /* Add a new group, and make it active */
131                                 grp= MEM_callocN(sizeof(bActionGroup), "bActionGroup");
132                                 
133                                 grp->flag = AGRP_SELECTED;
134                                 BLI_snprintf(grp->name, 64, group);
135                                 
136                                 BLI_addtail(&act->groups, grp);
137                                 BLI_uniquename(&act->groups, grp, "Group", offsetof(bActionGroup, name), 64);
138                         }
139                         
140                         /* add F-Curve to group */
141                         action_groups_add_channel(act, grp, fcu);
142                 }
143                 else {
144                         /* just add F-Curve to end of Action's list */
145                         BLI_addtail(&act->curves, fcu);
146                 }
147         }
148         
149         /* return the F-Curve */
150         return fcu;
151 }
152
153 /* ************************************************** */
154 /* KEYFRAME INSERTION */
155
156 /* -------------- BezTriple Insertion -------------------- */
157
158 /* threshold for inserting keyframes - threshold here should be good enough for now, but should become userpref */
159 #define BEZT_INSERT_THRESH      0.00001f
160
161 /* Binary search algorithm for finding where to insert BezTriple. (for use by insert_bezt_icu)
162  * Returns the index to insert at (data already at that index will be offset if replace is 0)
163  */
164 static int binarysearch_bezt_index (BezTriple array[], float frame, int arraylen, short *replace)
165 {
166         int start=0, end=arraylen;
167         int loopbreaker= 0, maxloop= arraylen * 2;
168         
169         /* initialise replace-flag first */
170         *replace= 0;
171         
172         /* sneaky optimisations (don't go through searching process if...):
173          *      - keyframe to be added is to be added out of current bounds
174          *      - keyframe to be added would replace one of the existing ones on bounds
175          */
176         if ((arraylen <= 0) || (array == NULL)) {
177                 printf("Warning: binarysearch_bezt_index() encountered invalid array \n");
178                 return 0;
179         }
180         else {
181                 /* check whether to add before/after/on */
182                 float framenum;
183                 
184                 /* 'First' Keyframe (when only one keyframe, this case is used) */
185                 framenum= array[0].vec[1][0];
186                 if (IS_EQT(frame, framenum, BEZT_INSERT_THRESH)) {
187                         *replace = 1;
188                         return 0;
189                 }
190                 else if (frame < framenum)
191                         return 0;
192                         
193                 /* 'Last' Keyframe */
194                 framenum= array[(arraylen-1)].vec[1][0];
195                 if (IS_EQT(frame, framenum, BEZT_INSERT_THRESH)) {
196                         *replace= 1;
197                         return (arraylen - 1);
198                 }
199                 else if (frame > framenum)
200                         return arraylen;
201         }
202         
203         
204         /* most of the time, this loop is just to find where to put it
205          * 'loopbreaker' is just here to prevent infinite loops 
206          */
207         for (loopbreaker=0; (start <= end) && (loopbreaker < maxloop); loopbreaker++) {
208                 /* compute and get midpoint */
209                 int mid = start + ((end - start) / 2);  /* we calculate the midpoint this way to avoid int overflows... */
210                 float midfra= array[mid].vec[1][0];
211                 
212                 /* check if exactly equal to midpoint */
213                 if (IS_EQT(frame, midfra, BEZT_INSERT_THRESH)) {
214                         *replace = 1;
215                         return mid;
216                 }
217                 
218                 /* repeat in upper/lower half */
219                 if (frame > midfra)
220                         start= mid + 1;
221                 else if (frame < midfra)
222                         end= mid - 1;
223         }
224         
225         /* print error if loop-limit exceeded */
226         if (loopbreaker == (maxloop-1)) {
227                 printf("Error: binarysearch_bezt_index() was taking too long \n");
228                 
229                 // include debug info 
230                 printf("\tround = %d: start = %d, end = %d, arraylen = %d \n", loopbreaker, start, end, arraylen);
231         }
232         
233         /* not found, so return where to place it */
234         return start;
235 }
236
237 /* This function adds a given BezTriple to an F-Curve. It will allocate 
238  * memory for the array if needed, and will insert the BezTriple into a
239  * suitable place in chronological order.
240  * 
241  * NOTE: any recalculate of the F-Curve that needs to be done will need to 
242  *              be done by the caller.
243  */
244 int insert_bezt_fcurve (FCurve *fcu, BezTriple *bezt)
245 {
246         BezTriple *newb;
247         int i= 0;
248         
249         if (fcu->bezt) {
250                 short replace = -1;
251                 i = binarysearch_bezt_index(fcu->bezt, bezt->vec[1][0], fcu->totvert, &replace);
252                 
253                 if (replace) {                  
254                         /* sanity check: 'i' may in rare cases exceed arraylen */
255                         // FIXME: do not overwrite handletype if just replacing...?
256                         if ((i >= 0) && (i < fcu->totvert))
257                                 *(fcu->bezt + i) = *bezt;
258                 }
259                 else {
260                         /* add new */
261                         newb= MEM_callocN((fcu->totvert+1)*sizeof(BezTriple), "beztriple");
262                         
263                         /* add the beztriples that should occur before the beztriple to be pasted (originally in ei->icu) */
264                         if (i > 0)
265                                 memcpy(newb, fcu->bezt, i*sizeof(BezTriple));
266                         
267                         /* add beztriple to paste at index i */
268                         *(newb + i)= *bezt;
269                         
270                         /* add the beztriples that occur after the beztriple to be pasted (originally in icu) */
271                         if (i < fcu->totvert) 
272                                 memcpy(newb+i+1, fcu->bezt+i, (fcu->totvert-i)*sizeof(BezTriple));
273                         
274                         /* replace (+ free) old with new */
275                         MEM_freeN(fcu->bezt);
276                         fcu->bezt= newb;
277                         
278                         fcu->totvert++;
279                 }
280         }
281         else {
282                 // TODO: need to check for old sample-data now...
283                 fcu->bezt= MEM_callocN(sizeof(BezTriple), "beztriple");
284                 *(fcu->bezt)= *bezt;
285                 fcu->totvert= 1;
286         }
287         
288         
289         /* we need to return the index, so that some tools which do post-processing can 
290          * detect where we added the BezTriple in the array
291          */
292         return i;
293 }
294
295 /* This function is a wrapper for insert_bezt_icu, and should be used when
296  * adding a new keyframe to a curve, when the keyframe doesn't exist anywhere
297  * else yet. 
298  * 
299  * 'fast' - is only for the python API where importing BVH's would take an extreamly long time.
300  */
301 void insert_vert_fcurve (FCurve *fcu, float x, float y, short fast)
302 {
303         BezTriple beztr;
304         int a;
305         
306         /* set all three points, for nicer start position */
307         memset(&beztr, 0, sizeof(BezTriple));
308         beztr.vec[0][0]= x; 
309         beztr.vec[0][1]= y;
310         beztr.vec[1][0]= x;
311         beztr.vec[1][1]= y;
312         beztr.vec[2][0]= x;
313         beztr.vec[2][1]= y;
314         beztr.ipo= U.ipo_new; /* use default interpolation mode here... */
315         beztr.f1= beztr.f2= beztr.f3= SELECT;
316         beztr.h1= beztr.h2= HD_AUTO; // XXX what about when we replace an old one?
317         
318         /* add temp beztriple to keyframes */
319         a= insert_bezt_fcurve(fcu, &beztr);
320         
321         /* what if 'a' is a negative index? 
322          * for now, just exit to prevent any segfaults
323          */
324         if (a < 0) return;
325         
326         /* don't recalculate handles if fast is set
327          *      - this is a hack to make importers faster
328          *      - we may calculate twice (see editipo_changed(), due to autohandle needing two calculations)
329          */
330         if (!fast) calchandles_fcurve(fcu);
331         
332         /* set handletype and interpolation */
333         if (fcu->totvert > 2) {
334                 BezTriple *bezt= (fcu->bezt + a);
335                 char h1, h2;
336                 
337                 /* set handles (autohandles by default) */
338                 h1= h2= HD_AUTO;
339                 
340                 if (a > 0) h1= (bezt-1)->h2;
341                 if (a < fcu->totvert-1) h2= (bezt+1)->h1;
342                 
343                 bezt->h1= h1;
344                 bezt->h2= h2;
345                 
346                 /* set interpolation from previous (if available) */
347                 if (a > 0) bezt->ipo= (bezt-1)->ipo;
348                 else if (a < fcu->totvert-1) bezt->ipo= (bezt+1)->ipo;
349                         
350                 /* don't recalculate handles if fast is set
351                  *      - this is a hack to make importers faster
352                  *      - we may calculate twice (see editipo_changed(), due to autohandle needing two calculations)
353                  */
354                 if (!fast) calchandles_fcurve(fcu);
355         }
356 }
357
358 /* -------------- 'Smarter' Keyframing Functions -------------------- */
359 /* return codes for new_key_needed */
360 enum {
361         KEYNEEDED_DONTADD = 0,
362         KEYNEEDED_JUSTADD,
363         KEYNEEDED_DELPREV,
364         KEYNEEDED_DELNEXT
365 } eKeyNeededStatus;
366
367 /* This helper function determines whether a new keyframe is needed */
368 /* Cases where keyframes should not be added:
369  *      1. Keyframe to be added bewteen two keyframes with similar values
370  *      2. Keyframe to be added on frame where two keyframes are already situated
371  *      3. Keyframe lies at point that intersects the linear line between two keyframes
372  */
373 static short new_key_needed (FCurve *fcu, float cFrame, float nValue) 
374 {
375         BezTriple *bezt=NULL, *prev=NULL;
376         int totCount, i;
377         float valA = 0.0f, valB = 0.0f;
378         
379         /* safety checking */
380         if (fcu == NULL) return KEYNEEDED_JUSTADD;
381         totCount= fcu->totvert;
382         if (totCount == 0) return KEYNEEDED_JUSTADD;
383         
384         /* loop through checking if any are the same */
385         bezt= fcu->bezt;
386         for (i=0; i<totCount; i++) {
387                 float prevPosi=0.0f, prevVal=0.0f;
388                 float beztPosi=0.0f, beztVal=0.0f;
389                         
390                 /* get current time+value */    
391                 beztPosi= bezt->vec[1][0];
392                 beztVal= bezt->vec[1][1];
393                         
394                 if (prev) {
395                         /* there is a keyframe before the one currently being examined */               
396                         
397                         /* get previous time+value */
398                         prevPosi= prev->vec[1][0];
399                         prevVal= prev->vec[1][1];
400                         
401                         /* keyframe to be added at point where there are already two similar points? */
402                         if (IS_EQ(prevPosi, cFrame) && IS_EQ(beztPosi, cFrame) && IS_EQ(beztPosi, prevPosi)) {
403                                 return KEYNEEDED_DONTADD;
404                         }
405                         
406                         /* keyframe between prev+current points ? */
407                         if ((prevPosi <= cFrame) && (cFrame <= beztPosi)) {
408                                 /* is the value of keyframe to be added the same as keyframes on either side ? */
409                                 if (IS_EQ(prevVal, nValue) && IS_EQ(beztVal, nValue) && IS_EQ(prevVal, beztVal)) {
410                                         return KEYNEEDED_DONTADD;
411                                 }
412                                 else {
413                                         float realVal;
414                                         
415                                         /* get real value of curve at that point */
416                                         realVal= evaluate_fcurve(fcu, cFrame);
417                                         
418                                         /* compare whether it's the same as proposed */
419                                         if (IS_EQ(realVal, nValue)) 
420                                                 return KEYNEEDED_DONTADD;
421                                         else 
422                                                 return KEYNEEDED_JUSTADD;
423                                 }
424                         }
425                         
426                         /* new keyframe before prev beztriple? */
427                         if (cFrame < prevPosi) {
428                                 /* A new keyframe will be added. However, whether the previous beztriple
429                                  * stays around or not depends on whether the values of previous/current
430                                  * beztriples and new keyframe are the same.
431                                  */
432                                 if (IS_EQ(prevVal, nValue) && IS_EQ(beztVal, nValue) && IS_EQ(prevVal, beztVal))
433                                         return KEYNEEDED_DELNEXT;
434                                 else 
435                                         return KEYNEEDED_JUSTADD;
436                         }
437                 }
438                 else {
439                         /* just add a keyframe if there's only one keyframe 
440                          * and the new one occurs before the exisiting one does.
441                          */
442                         if ((cFrame < beztPosi) && (totCount==1))
443                                 return KEYNEEDED_JUSTADD;
444                 }
445                 
446                 /* continue. frame to do not yet passed (or other conditions not met) */
447                 if (i < (totCount-1)) {
448                         prev= bezt;
449                         bezt++;
450                 }
451                 else
452                         break;
453         }
454         
455         /* Frame in which to add a new-keyframe occurs after all other keys
456          * -> If there are at least two existing keyframes, then if the values of the
457          *       last two keyframes and the new-keyframe match, the last existing keyframe
458          *       gets deleted as it is no longer required.
459          * -> Otherwise, a keyframe is just added. 1.0 is added so that fake-2nd-to-last
460          *       keyframe is not equal to last keyframe.
461          */
462         bezt= (fcu->bezt + (fcu->totvert - 1));
463         valA= bezt->vec[1][1];
464         
465         if (prev)
466                 valB= prev->vec[1][1];
467         else 
468                 valB= bezt->vec[1][1] + 1.0f; 
469                 
470         if (IS_EQ(valA, nValue) && IS_EQ(valA, valB)) 
471                 return KEYNEEDED_DELPREV;
472         else 
473                 return KEYNEEDED_JUSTADD;
474 }
475
476 /* ------------------ RNA Data-Access Functions ------------------ */
477
478 /* Try to read value using RNA-properties obtained already */
479 static float setting_get_rna_value (PointerRNA *ptr, PropertyRNA *prop, int index)
480 {
481         float value= 0.0f;
482         
483         switch (RNA_property_type(ptr, prop)) {
484                 case PROP_BOOLEAN:
485                         if (RNA_property_array_length(ptr, prop))
486                                 value= (float)RNA_property_boolean_get_index(ptr, prop, index);
487                         else
488                                 value= (float)RNA_property_boolean_get(ptr, prop);
489                         break;
490                 case PROP_INT:
491                         if (RNA_property_array_length(ptr, prop))
492                                 value= (float)RNA_property_int_get_index(ptr, prop, index);
493                         else
494                                 value= (float)RNA_property_int_get(ptr, prop);
495                         break;
496                 case PROP_FLOAT:
497                         if (RNA_property_array_length(ptr, prop))
498                                 value= RNA_property_float_get_index(ptr, prop, index);
499                         else
500                                 value= RNA_property_float_get(ptr, prop);
501                         break;
502                 case PROP_ENUM:
503                         value= (float)RNA_property_enum_get(ptr, prop);
504                         break;
505                 default:
506                         break;
507         }
508         
509         return value;
510 }
511
512 /* ------------------ 'Visual' Keyframing Functions ------------------ */
513
514 /* internal status codes for visualkey_can_use */
515 enum {
516         VISUALKEY_NONE = 0,
517         VISUALKEY_LOC,
518         VISUALKEY_ROT,
519 };
520
521 /* This helper function determines if visual-keyframing should be used when  
522  * inserting keyframes for the given channel. As visual-keyframing only works
523  * on Object and Pose-Channel blocks, this should only get called for those 
524  * blocktypes, when using "standard" keying but 'Visual Keying' option in Auto-Keying 
525  * settings is on.
526  */
527 static short visualkey_can_use (PointerRNA *ptr, PropertyRNA *prop)
528 {
529         bConstraint *con= NULL;
530         short searchtype= VISUALKEY_NONE;
531         char *identifier= NULL;
532         
533         /* validate data */
534         // TODO: this check is probably not needed, but it won't hurt
535         if (ELEM3(NULL, ptr, ptr->data, prop))
536                 return 0;
537                 
538         /* get first constraint and determine type of keyframe constraints to check for 
539          *      - constraints can be on either Objects or PoseChannels, so we only check if the
540          *        ptr->type is RNA_Object or RNA_PoseChannel, which are the RNA wrapping-info for
541          *        those structs, allowing us to identify the owner of the data 
542          */
543         if (ptr->type == &RNA_Object) {
544                 /* Object */
545                 Object *ob= (Object *)ptr->data;
546                 
547                 con= ob->constraints.first;
548                 identifier= (char *)RNA_property_identifier(ptr, prop);
549         }
550         else if (ptr->type == &RNA_PoseChannel) {
551                 /* Pose Channel */
552                 bPoseChannel *pchan= (bPoseChannel *)ptr->data;
553                 
554                 con= pchan->constraints.first;
555                 identifier= (char *)RNA_property_identifier(ptr, prop);
556         }
557         
558         /* check if any data to search using */
559         if (ELEM(NULL, con, identifier))
560                 return 0;
561                 
562         /* location or rotation identifiers only... */
563         if (strstr(identifier, "location"))
564                 searchtype= VISUALKEY_LOC;
565         else if (strstr(identifier, "rotation"))
566                 searchtype= VISUALKEY_ROT;
567         else {
568                 printf("visualkey_can_use() failed: identifier - '%s' \n", identifier);
569                 return 0;
570         }
571         
572         
573         /* only search if a searchtype and initial constraint are available */
574         if (searchtype && con) {
575                 for (; con; con= con->next) {
576                         /* only consider constraint if it is not disabled, and has influence */
577                         if (con->flag & CONSTRAINT_DISABLE) continue;
578                         if (con->enforce == 0.0f) continue;
579                         
580                         /* some constraints may alter these transforms */
581                         switch (con->type) {
582                                 /* multi-transform constraints */
583                                 case CONSTRAINT_TYPE_CHILDOF:
584                                         return 1;
585                                 case CONSTRAINT_TYPE_TRANSFORM:
586                                         return 1;
587                                 case CONSTRAINT_TYPE_FOLLOWPATH:
588                                         return 1;
589                                 case CONSTRAINT_TYPE_KINEMATIC:
590                                         return 1;
591                                         
592                                 /* single-transform constraits  */
593                                 case CONSTRAINT_TYPE_TRACKTO:
594                                         if (searchtype==VISUALKEY_ROT) return 1;
595                                         break;
596                                 case CONSTRAINT_TYPE_ROTLIMIT:
597                                         if (searchtype==VISUALKEY_ROT) return 1;
598                                         break;
599                                 case CONSTRAINT_TYPE_LOCLIMIT:
600                                         if (searchtype==VISUALKEY_LOC) return 1;
601                                         break;
602                                 case CONSTRAINT_TYPE_ROTLIKE:
603                                         if (searchtype==VISUALKEY_ROT) return 1;
604                                         break;
605                                 case CONSTRAINT_TYPE_DISTLIMIT:
606                                         if (searchtype==VISUALKEY_LOC) return 1;
607                                         break;
608                                 case CONSTRAINT_TYPE_LOCLIKE:
609                                         if (searchtype==VISUALKEY_LOC) return 1;
610                                         break;
611                                 case CONSTRAINT_TYPE_LOCKTRACK:
612                                         if (searchtype==VISUALKEY_ROT) return 1;
613                                         break;
614                                 case CONSTRAINT_TYPE_MINMAX:
615                                         if (searchtype==VISUALKEY_LOC) return 1;
616                                         break;
617                                 
618                                 default:
619                                         break;
620                         }
621                 }
622         }
623         
624         /* when some condition is met, this function returns, so here it can be 0 */
625         return 0;
626 }
627
628 /* This helper function extracts the value to use for visual-keyframing 
629  * In the event that it is not possible to perform visual keying, try to fall-back
630  * to using the default method. Assumes that all data it has been passed is valid.
631  */
632 static float visualkey_get_value (PointerRNA *ptr, PropertyRNA *prop, int array_index)
633 {
634         char *identifier= (char *)RNA_property_identifier(ptr, prop);
635         
636         /* handle for Objects or PoseChannels only 
637          *      - constraints can be on either Objects or PoseChannels, so we only check if the
638          *        ptr->type is RNA_Object or RNA_PoseChannel, which are the RNA wrapping-info for
639          *        those structs, allowing us to identify the owner of the data 
640          *      - assume that array_index will be sane
641          */
642         if (ptr->type == &RNA_Object) {
643                 Object *ob= (Object *)ptr->data;
644                 
645                 /* parented objects are not supported, as the effects of the parent
646                  * are included in the matrix, which kindof beats the point
647                  */
648                 if (ob->parent == NULL) {
649                         /* only Location or Rotation keyframes are supported now */
650                         if (strstr(identifier, "location")) {
651                                 return ob->obmat[3][array_index];
652                         }
653                         else if (strstr(identifier, "rotation")) {
654                                 float eul[3];
655                                 
656                                 Mat4ToEul(ob->obmat, eul);
657                                 return eul[array_index];
658                         }
659                 }
660         }
661         else if (ptr->type == &RNA_PoseChannel) {
662                 Object *ob= (Object *)ptr->id.data; /* we assume that this is always set, and is an object */
663                 bPoseChannel *pchan= (bPoseChannel *)ptr->data;
664                 float tmat[4][4];
665                 
666                 /* Although it is not strictly required for this particular space conversion, 
667                  * arg1 must not be null, as there is a null check for the other conversions to
668                  * be safe. Therefore, the active object is passed here, and in many cases, this
669                  * will be what owns the pose-channel that is getting this anyway.
670                  */
671                 Mat4CpyMat4(tmat, pchan->pose_mat);
672                 constraint_mat_convertspace(ob, pchan, tmat, CONSTRAINT_SPACE_POSE, CONSTRAINT_SPACE_LOCAL);
673                 
674                 /* Loc, Rot/Quat keyframes are supported... */
675                 if (strstr(identifier, "location")) {
676                         /* only use for non-connected bones */
677                         if ((pchan->bone->parent) && !(pchan->bone->flag & BONE_CONNECTED))
678                                 return tmat[3][array_index];
679                         else if (pchan->bone->parent == NULL)
680                                 return tmat[3][array_index];
681                 }
682                 else if (strstr(identifier, "euler_rotation")) {
683                         float eul[3];
684                         
685                         /* euler-rotation test before standard rotation, as standard rotation does quats */
686                         Mat4ToEul(tmat, eul);
687                         return eul[array_index];
688                 }
689                 else if (strstr(identifier, "rotation")) {
690                         float trimat[3][3], quat[4];
691                         
692                         Mat3CpyMat4(trimat, tmat);
693                         Mat3ToQuat_is_ok(trimat, quat);
694                         
695                         return quat[array_index];
696                 }
697         }
698         
699         /* as the function hasn't returned yet, read value from system in the default way */
700         return setting_get_rna_value(ptr, prop, array_index);
701 }
702
703 /* ------------------------- Insert Key API ------------------------- */
704
705 /* Main Keyframing API call:
706  *      Use this when validation of necessary animation data isn't necessary as it
707  *      already exists. It will insert a keyframe using the current value being keyframed.
708  *      
709  *      The flag argument is used for special settings that alter the behaviour of
710  *      the keyframe insertion. These include the 'visual' keyframing modes, quick refresh,
711  *      and extra keyframe filtering.
712  */
713 short insertkey (ID *id, const char group[], const char rna_path[], int array_index, float cfra, short flag)
714 {       
715         PointerRNA id_ptr, ptr;
716         PropertyRNA *prop;
717         FCurve *fcu;
718         
719         /* validate pointer first - exit if failure*/
720         RNA_id_pointer_create(id, &id_ptr);
721         if (RNA_path_resolve(&id_ptr, rna_path, &ptr, &prop) == 0 || prop == NULL) {
722                 printf("Insert Key: Could not insert keyframe, as RNA Path is invalid for the given ID (%s)\n", rna_path);
723                 return 0;
724         }
725         
726         /* get F-Curve */
727         fcu= verify_fcurve(id, group, rna_path, array_index, 1);
728         
729         /* only continue if we have an F-Curve to add keyframe to */
730         if (fcu) {
731                 float curval= 0.0f;
732                 
733                 /* set additional flags for the F-Curve (i.e. only integer values) */
734                 if (RNA_property_type(&ptr, prop) != PROP_FLOAT)
735                         fcu->flag |= FCURVE_INT_VALUES;
736                 
737                 /* apply special time tweaking */
738                         // XXX check on this stuff...
739                 if (GS(id->name) == ID_OB) {
740                         //Object *ob= (Object *)id;
741                         
742                         /* apply NLA-scaling (if applicable) */
743                         //cfra= get_action_frame(ob, cfra);
744                         
745                         /* ancient time-offset cruft */
746                         //if ( (ob->ipoflag & OB_OFFS_OB) && (give_timeoffset(ob)) ) {
747                         //      /* actually frametofloat calc again! */
748                         //      cfra-= give_timeoffset(ob)*scene->r.framelen;
749                         //}
750                 }
751                 
752                 /* obtain value to give keyframe */
753                 if ( (flag & INSERTKEY_MATRIX) && 
754                          (visualkey_can_use(&ptr, prop)) ) 
755                 {
756                         /* visual-keying is only available for object and pchan datablocks, as 
757                          * it works by keyframing using a value extracted from the final matrix 
758                          * instead of using the kt system to extract a value.
759                          */
760                         curval= visualkey_get_value(&ptr, prop, array_index);
761                 }
762                 else {
763                         /* read value from system */
764                         curval= setting_get_rna_value(&ptr, prop, array_index);
765                 }
766                 
767                 /* only insert keyframes where they are needed */
768                 if (flag & INSERTKEY_NEEDED) {
769                         short insert_mode;
770                         
771                         /* check whether this curve really needs a new keyframe */
772                         insert_mode= new_key_needed(fcu, cfra, curval);
773                         
774                         /* insert new keyframe at current frame */
775                         if (insert_mode)
776                                 insert_vert_fcurve(fcu, cfra, curval, (flag & INSERTKEY_FAST));
777                         
778                         /* delete keyframe immediately before/after newly added */
779                         switch (insert_mode) {
780                                 case KEYNEEDED_DELPREV:
781                                         delete_fcurve_key(fcu, fcu->totvert-2, 1);
782                                         break;
783                                 case KEYNEEDED_DELNEXT:
784                                         delete_fcurve_key(fcu, 1, 1);
785                                         break;
786                         }
787                         
788                         /* only return success if keyframe added */
789                         if (insert_mode)
790                                 return 1;
791                 }
792                 else {
793                         /* just insert keyframe */
794                         insert_vert_fcurve(fcu, cfra, curval, (flag & INSERTKEY_FAST));
795                         
796                         /* return success */
797                         return 1;
798                 }
799         }
800         
801         /* return failure */
802         return 0;
803 }
804
805 /* ************************************************** */
806 /* KEYFRAME DELETION */
807
808 /* Main Keyframing API call:
809  *      Use this when validation of necessary animation data isn't necessary as it
810  *      already exists. It will delete a keyframe at the current frame.
811  *      
812  *      The flag argument is used for special settings that alter the behaviour of
813  *      the keyframe deletion. These include the quick refresh options.
814  */
815 short deletekey (ID *id, const char group[], const char rna_path[], int array_index, float cfra, short flag)
816 {
817         AnimData *adt;
818         FCurve *fcu;
819         
820         /* get F-Curve
821          * Note: here is one of the places where we don't want new Action + F-Curve added!
822          *              so 'add' var must be 0
823          */
824         /* we don't check the validity of the path here yet, but it should be ok... */
825         fcu= verify_fcurve(id, group, rna_path, array_index, 0);
826         adt= BKE_animdata_from_id(id);
827         
828         /* only continue if we have an ipo-curve to remove keyframes from */
829         if (adt && adt->action && fcu) {
830                 bAction *act= adt->action;
831                 short found = -1;
832                 int i;
833                 
834                 /* apply special time tweaking */
835                 if (GS(id->name) == ID_OB) {
836                         //Object *ob= (Object *)id;
837                         
838                         /* apply NLA-scaling (if applicable) */
839                         //      cfra= get_action_frame(ob, cfra);
840                         
841                         /* ancient time-offset cruft */
842                         //if ( (ob->ipoflag & OB_OFFS_OB) && (give_timeoffset(ob)) ) {
843                         //      /* actually frametofloat calc again! */
844                         //      cfra-= give_timeoffset(ob)*scene->r.framelen;
845                         //}
846                 }
847                 
848                 /* try to find index of beztriple to get rid of */
849                 i = binarysearch_bezt_index(fcu->bezt, cfra, fcu->totvert, &found);
850                 if (found) {                    
851                         /* delete the key at the index (will sanity check + do recalc afterwards) */
852                         delete_fcurve_key(fcu, i, 1);
853                         
854                         /* Only delete curve too if there are no points (we don't need to check for drivers, as they're kept separate) */
855                         if (fcu->totvert == 0) {
856                                 BLI_remlink(&act->curves, fcu);
857                                 free_fcurve(fcu);
858                         }
859                         
860                         /* return success */
861                         return 1;
862                 }
863         }
864         
865         /* return failure */
866         return 0;
867 }
868
869 /* ******************************************* */
870 /* KEYINGSETS */
871
872 /* Operators ------------------------------------------- */
873
874 /* These operators are only provided for scripting/macro usage, not for direct
875  * calling from the UI since they wrap some of the data-access API code for these
876  * (defined in blenkernel) which have quite a few properties.
877  */
878
879 /* ----- */
880
881 static int keyingset_add_destination_exec (bContext *C, wmOperator *op)
882 {
883         PointerRNA ptr;
884         KeyingSet *ks= NULL;
885         ID *id= NULL;
886         char rna_path[256], group_name[64]; // xxx
887         short groupmode=0, flag=0;
888         int array_index=0;
889         
890         /* get settings from operator properties */
891         ptr = RNA_pointer_get(op->ptr, "keyingset");
892         if (ptr.data) 
893                 ks= (KeyingSet *)ptr.data;
894         
895         ptr = RNA_pointer_get(op->ptr, "id");
896         if (ptr.data)
897                 id= (ID *)ptr.data;
898         
899         groupmode= RNA_enum_get(op->ptr, "grouping_method");
900         RNA_string_get(op->ptr, "group_name", group_name);              
901         
902         RNA_string_get(op->ptr, "rna_path", rna_path);
903         array_index= RNA_int_get(op->ptr, "array_index");
904         
905         if (RNA_boolean_get(op->ptr, "entire_array"))
906                 flag |= KSP_FLAG_WHOLE_ARRAY;
907         
908         /* if enough args are provided, call API method */
909         if (ks) {
910                 BKE_keyingset_add_destination(ks, id, group_name, rna_path, array_index, flag, groupmode);
911                 return OPERATOR_FINISHED;
912         }
913         else {
914                 BKE_report(op->reports, RPT_ERROR, "Keying Set could not be added.");
915                 return OPERATOR_CANCELLED;
916         }       
917 }
918
919 void ANIM_OT_keyingset_add_destination (wmOperatorType *ot)
920 {
921         // XXX: this is also defined in rna_animation.c
922         static EnumPropertyItem prop_mode_grouping_items[] = {
923                 {KSP_GROUP_NAMED, "NAMED", "Named Group", ""},
924                 {KSP_GROUP_NONE, "NONE", "None", ""},
925                 {KSP_GROUP_KSNAME, "KEYINGSET", "Keying Set Name", ""},
926                 {0, NULL, NULL, NULL}};
927         
928         /* identifiers */
929         ot->name= "Add Keying Set Destination";
930         ot->idname= "ANIM_OT_keyingset_add_destination";
931         
932         /* callbacks */
933         ot->exec= keyingset_add_destination_exec;
934         ot->poll= ED_operator_scene_editable;
935         
936         /* props */
937                 /* pointers */ // xxx - do we want to directly expose these?
938         RNA_def_pointer_runtime(ot->srna, "keyingset", &RNA_KeyingSet, "Keying Set", "Keying Set to add destination to.");
939         RNA_def_pointer_runtime(ot->srna, "id", &RNA_ID, "ID", "ID-block for the destination.");
940                 /* grouping */
941         RNA_def_enum(ot->srna, "grouping_method", prop_mode_grouping_items, KSP_GROUP_NAMED, "Grouping Method", "Method used to define which Group-name to use.");
942         RNA_def_string(ot->srna, "group_name", "", 64, "Group Name", "Name of Action Group to assign destination to (only if grouping mode is to use this name).");
943                 /* rna-path */
944         RNA_def_string(ot->srna, "rna_path", "", 256, "RNA-Path", "RNA-Path to destination property."); // xxx hopefully this is long enough
945         RNA_def_int(ot->srna, "array_index", 0, 0, INT_MAX, "Array Index", "If applicable, the index ", 0, INT_MAX);
946                 /* flags */
947         RNA_def_boolean(ot->srna, "entire_array", 1, "Entire Array", "hen an 'array/vector' type is chosen (Location, Rotation, Color, etc.), entire array is to be used.");
948         
949 }
950  
951 /* ----- */
952
953 static int keyingset_add_new_exec (bContext *C, wmOperator *op)
954 {
955         Scene *sce= CTX_data_scene(C);
956         KeyingSet *ks= NULL;
957         short flag=0, keyingflag=0;
958         char name[64];
959         
960         /* get settings from operator properties */
961         RNA_string_get(op->ptr, "name", name);
962         
963         if (RNA_boolean_get(op->ptr, "absolute"))
964                 flag |= KEYINGSET_ABSOLUTE;
965         if (RNA_boolean_get(op->ptr, "insertkey_needed"))
966                 keyingflag |= INSERTKEY_NEEDED;
967         if (RNA_boolean_get(op->ptr, "insertkey_visual"))
968                 keyingflag |= INSERTKEY_MATRIX;
969                 
970         /* call the API func, and set the active keyingset index */
971         ks= BKE_keyingset_add(&sce->keyingsets, name, flag, keyingflag);
972         
973         if (ks) {
974                 sce->active_keyingset= BLI_countlist(&sce->keyingsets);
975                 return OPERATOR_FINISHED;
976         }
977         else {
978                 BKE_report(op->reports, RPT_ERROR, "Keying Set could not be added.");
979                 return OPERATOR_CANCELLED;
980         }
981 }
982
983 void ANIM_OT_keyingset_add_new (wmOperatorType *ot)
984 {
985         /* identifiers */
986         ot->name= "Add Keying Set";
987         ot->idname= "ANIM_OT_keyingset_add_new";
988         
989         /* callbacks */
990         ot->exec= keyingset_add_new_exec;
991         ot->poll= ED_operator_scene_editable;
992         
993         /* props */
994                 /* name */
995         RNA_def_string(ot->srna, "name", "KeyingSet", 64, "Name", "Name of Keying Set");
996                 /* flags */
997         RNA_def_boolean(ot->srna, "absolute", 1, "Absolute", "Keying Set defines specifc paths/settings to be keyframed (i.e. is not reliant on context info)");
998                 /* keying flags */
999         RNA_def_boolean(ot->srna, "insertkey_needed", 0, "Insert Keyframes - Only Needed", "Only insert keyframes where they're needed in the relevant F-Curves.");
1000         RNA_def_boolean(ot->srna, "insertkey_visual", 0, "Insert Keyframes - Visual", "Insert keyframes based on 'visual transforms'.");
1001 }
1002
1003 /* UI API --------------------------------------------- */
1004
1005 /* Build menu-string of available keying-sets (allocates memory for string)
1006  * NOTE: mode must not be longer than 64 chars
1007  */
1008 char *ANIM_build_keyingsets_menu (ListBase *list, short for_edit)
1009 {
1010         DynStr *pupds= BLI_dynstr_new();
1011         KeyingSet *ks;
1012         char buf[64];
1013         char *str;
1014         int i;
1015         
1016         /* add title first */
1017         BLI_dynstr_append(pupds, "Keying Sets%t|");
1018         
1019         /* add dummy entries for none-active */
1020         if (for_edit) { 
1021                 BLI_dynstr_append(pupds, "Add New%x-1|");
1022                 BLI_dynstr_append(pupds, " %x0|");
1023         }
1024         else
1025                 BLI_dynstr_append(pupds, "<No Keying Set Active>%x0|");
1026         
1027         /* loop through keyingsets, adding them */
1028         for (ks=list->first, i=1; ks; ks=ks->next, i++) {
1029                 if (for_edit == 0)
1030                         BLI_dynstr_append(pupds, "KS: ");
1031                 
1032                 BLI_dynstr_append(pupds, ks->name);
1033                 BLI_snprintf( buf, 64, "%%x%d%s", i, ((ks->next)?"|":"") );
1034                 BLI_dynstr_append(pupds, buf);
1035         }
1036         
1037         /* convert to normal MEM_malloc'd string */
1038         str= BLI_dynstr_get_cstring(pupds);
1039         BLI_dynstr_free(pupds);
1040         
1041         return str;
1042 }
1043
1044
1045
1046 /* ******************************************* */
1047 /* KEYFRAME MODIFICATION */
1048
1049 /* mode for commonkey_modifykey */
1050 enum {
1051         COMMONKEY_MODE_INSERT = 0,
1052         COMMONKEY_MODE_DELETE,
1053 } eCommonModifyKey_Modes;
1054
1055 #if 0 // XXX old keyingsets code based on adrcodes... to be restored in due course
1056
1057 /* --------- KeyingSet Adrcode Getters ------------ */
1058
1059 /* initialise a channel-getter storage */
1060 static void ks_adrcodegetter_init (bKS_AdrcodeGetter *kag, bKeyingSet *ks, bCommonKeySrc *cks)
1061 {
1062         /* error checking */
1063         if (kag == NULL)
1064                 return;
1065         
1066         if (ELEM(NULL, ks, cks)) {
1067                 /* set invalid settings that won't cause harm */
1068                 kag->ks= NULL;
1069                 kag->cks= NULL;
1070                 kag->index= -2;
1071                 kag->tot= 0;
1072         }
1073         else {
1074                 /* store settings */
1075                 kag->ks= ks;
1076                 kag->cks= cks;
1077                 
1078                 /* - index is -1, as that allows iterators to return first element
1079                  * - tot is chan_num by default, but may get overriden if -1 is encountered (for extension-type getters)
1080                  */
1081                 kag->index= -1;
1082                 kag->tot= ks->chan_num;
1083         }
1084 }
1085
1086 /* 'default' channel-getter that will be used when iterating through keyingset's channels 
1087  *       - iteration will stop when adrcode <= 0 is encountered, so we use that as escape
1088  */
1089 static short ks_getnextadrcode_default (bKS_AdrcodeGetter *kag)
1090 {       
1091         bKeyingSet *ks= (kag)? kag->ks : NULL;
1092         
1093         /* error checking */
1094         if (ELEM(NULL, kag, ks)) return 0;
1095         if (kag->tot <= 0) return 0;
1096         
1097         kag->index++;
1098         if ((kag->index < 0) || (kag->index >= kag->tot)) return 0;
1099         
1100         /* return the adrcode stored at index then */
1101         return ks->adrcodes[kag->index];
1102 }
1103
1104 /* add map flag (for MTex channels, as certain ones need special offset) */
1105 static short ks_getnextadrcode_addmap (bKS_AdrcodeGetter *kag)
1106 {
1107         short adrcode= ks_getnextadrcode_default(kag);
1108         
1109         /* if there was an adrcode returned, assume that kag stuff is set ok */
1110         if (adrcode) {
1111                 bCommonKeySrc *cks= kag->cks;
1112                 bKeyingSet *ks= kag->ks;
1113                 
1114                 if (ELEM3(ks->blocktype, ID_MA, ID_LA, ID_WO)) {
1115                         switch (adrcode) {
1116                                 case MAP_OFS_X: case MAP_OFS_Y: case MAP_OFS_Z:
1117                                 case MAP_SIZE_X: case MAP_SIZE_Y: case MAP_SIZE_Z:
1118                                 case MAP_R: case MAP_G: case MAP_B: case MAP_DVAR:
1119                                 case MAP_COLF: case MAP_NORF: case MAP_VARF: case MAP_DISP:
1120                                         adrcode += cks->map;
1121                                         break;
1122                         }
1123                 }
1124         }
1125         
1126         /* adrcode must be returned! */
1127         return adrcode;
1128 }
1129
1130 /* extend posechannel keyingsets with rotation info (when KAG_CHAN_EXTEND is encountered) 
1131  *      - iteration will stop when adrcode <= 0 is encountered, so we use that as escape
1132  *      - when we encounter KAG_CHAN_EXTEND as adrcode, start returning our own
1133  */
1134 static short ks_getnextadrcode_pchanrot (bKS_AdrcodeGetter *kag)
1135 {       
1136         /* hardcoded adrcode channels used here only 
1137          *      - length is keyed-channels + 1 (last item must be 0 to escape)
1138          */
1139         static short quat_adrcodes[5] = {AC_QUAT_W, AC_QUAT_X, AC_QUAT_Y, AC_QUAT_Z, 0};
1140         static short eul_adrcodes[4] = {AC_EUL_X, AC_EUL_Y, AC_EUL_Z, 0};
1141                 
1142         /* useful variables */
1143         bKeyingSet *ks= (kag)? kag->ks : NULL;
1144         bCommonKeySrc *cks= (kag) ? kag->cks : NULL;
1145         short index, adrcode;
1146         
1147         /* error checking */
1148         if (ELEM3(NULL, kag, ks, cks)) return 0;
1149         if (ks->chan_num <= 0) return 0;
1150         
1151         /* get index 
1152          *      - if past the last item (kag->tot), return stuff from our static arrays
1153          *      - otherwise, just keep returning stuff from the keyingset (but check out for -1!) 
1154          */
1155         kag->index++;
1156         if (kag->index < 0)
1157                 return 0;
1158         
1159         /* normal (static stuff) */
1160         if (kag->index < kag->tot) {
1161                 /* get adrcode, and return if not KAG_CHAN_EXTEND (i.e. point for start of iteration) */
1162                 adrcode= ks->adrcodes[kag->index];
1163                 
1164                 if (adrcode != KAG_CHAN_EXTEND) 
1165                         return adrcode;
1166                 else    
1167                         kag->tot= kag->index;
1168         }
1169                 
1170         /* based on current rotation-mode
1171          *      - index can be at most 5, if we are to prevent segfaults
1172          */
1173         index= kag->index - kag->tot;
1174         if ((index < 0) || (index > 5))
1175                 return 0;
1176         
1177         if (cks->pchan && cks->pchan->rotmode)
1178                 return eul_adrcodes[index];
1179         else
1180                 return quat_adrcodes[index];
1181 }
1182
1183 /* ------------- KeyingSet Defines ------------ */
1184 /* Note: these must all be named with the defks_* prefix, otherwise the template macro will not work! */
1185
1186 /* macro for defining keyingset contexts */
1187 #define KSC_TEMPLATE(ctx_name) {&defks_##ctx_name[0], NULL, sizeof(defks_##ctx_name)/sizeof(bKeyingSet)}
1188
1189 /* --- */
1190
1191 /* check if option not available for deleting keys */
1192 static short incl_non_del_keys (bKeyingSet *ks, const char mode[])
1193 {
1194         /* as optimisation, assume that it is sufficient to check only first letter
1195          * of mode (int comparison should be faster than string!)
1196          */
1197         //if (strcmp(mode, "Delete")==0)
1198         if (mode && mode[0]=='D')
1199                 return 0;
1200         
1201         return 1;
1202 }
1203
1204 /* Object KeyingSets  ------ */
1205
1206 /* check if include shapekey entry  */
1207 static short incl_v3d_ob_shapekey (bKeyingSet *ks, const char mode[])
1208 {
1209         //Object *ob= (G.obedit)? (G.obedit) : (OBACT); // XXX
1210         Object *ob= NULL;
1211         char *newname= NULL;
1212         
1213         if(ob==NULL)
1214                 return 0;
1215         
1216         /* not available for delete mode */
1217         if (strcmp(mode, "Delete")==0)
1218                 return 0;
1219         
1220         /* check if is geom object that can get shapekeys */
1221         switch (ob->type) {
1222                 /* geometry? */
1223                 case OB_MESH:           newname= "Mesh";                break;
1224                 case OB_CURVE:          newname= "Curve";               break;
1225                 case OB_SURF:           newname= "Surface";             break;
1226                 case OB_LATTICE:        newname= "Lattice";             break;
1227                 
1228                 /* not geometry! */
1229                 default:
1230                         return 0;
1231         }
1232         
1233         /* if ks is shapekey entry (this could be callled for separator before too!) */
1234         if (ks->flag == -3)
1235                 BLI_strncpy(ks->name, newname, sizeof(ks->name));
1236         
1237         /* if it gets here, it's ok */
1238         return 1;
1239 }
1240
1241 /* array for object keyingset defines */
1242 bKeyingSet defks_v3d_object[] = 
1243 {
1244         /* include_cb, adrcode-getter, name, blocktype, flag, chan_num, adrcodes */
1245         {NULL, "Loc", ID_OB, 0, 3, {OB_LOC_X,OB_LOC_Y,OB_LOC_Z}},
1246         {NULL, "Rot", ID_OB, 0, 3, {OB_ROT_X,OB_ROT_Y,OB_ROT_Z}},
1247         {NULL, "Scale", ID_OB, 0, 3, {OB_SIZE_X,OB_SIZE_Y,OB_SIZE_Z}},
1248         
1249         {NULL, "%l", 0, -1, 0, {0}}, // separator
1250         
1251         {NULL, "LocRot", ID_OB, 0, 6, 
1252                 {OB_LOC_X,OB_LOC_Y,OB_LOC_Z,
1253                  OB_ROT_X,OB_ROT_Y,OB_ROT_Z}},
1254                  
1255         {NULL, "LocScale", ID_OB, 0, 6, 
1256                 {OB_LOC_X,OB_LOC_Y,OB_LOC_Z,
1257                  OB_SIZE_X,OB_SIZE_Y,OB_SIZE_Z}},
1258                  
1259         {NULL, "LocRotScale", ID_OB, 0, 9, 
1260                 {OB_LOC_X,OB_LOC_Y,OB_LOC_Z,
1261                  OB_ROT_X,OB_ROT_Y,OB_ROT_Z,
1262                  OB_SIZE_X,OB_SIZE_Y,OB_SIZE_Z}},
1263                  
1264         {NULL, "RotScale", ID_OB, 0, 6, 
1265                 {OB_ROT_X,OB_ROT_Y,OB_ROT_Z,
1266                  OB_SIZE_X,OB_SIZE_Y,OB_SIZE_Z}},
1267         
1268         {incl_non_del_keys, "%l", 0, -1, 0, {0}}, // separator
1269         
1270         {incl_non_del_keys, "VisualLoc", ID_OB, INSERTKEY_MATRIX, 3, {OB_LOC_X,OB_LOC_Y,OB_LOC_Z}},
1271         {incl_non_del_keys, "VisualRot", ID_OB, INSERTKEY_MATRIX, 3, {OB_ROT_X,OB_ROT_Y,OB_ROT_Z}},
1272         
1273         {incl_non_del_keys, "VisualLocRot", ID_OB, INSERTKEY_MATRIX, 6, 
1274                 {OB_LOC_X,OB_LOC_Y,OB_LOC_Z,
1275                  OB_ROT_X,OB_ROT_Y,OB_ROT_Z}},
1276         
1277         {NULL, "%l", 0, -1, 0, {0}}, // separator
1278         
1279         {NULL, "Layer", ID_OB, 0, 1, {OB_LAY}}, // icky option...
1280         {NULL, "Available", ID_OB, -2, 0, {0}},
1281         
1282         {incl_v3d_ob_shapekey, "%l%l", 0, -1, 0, {0}}, // separator (linked to shapekey entry)
1283         {incl_v3d_ob_shapekey, "<ShapeKey>", ID_OB, -3, 0, {0}}
1284 };
1285
1286 /* PoseChannel KeyingSets  ------ */
1287
1288 /* array for posechannel keyingset defines */
1289 bKeyingSet defks_v3d_pchan[] = 
1290 {
1291         /* include_cb, name, blocktype, flag, chan_num, adrcodes */
1292         {NULL, "Loc", ID_PO, 0, 3, {AC_LOC_X,AC_LOC_Y,AC_LOC_Z}},
1293         {NULL, "Rot", ID_PO, COMMONKEY_PCHANROT, 1, {KAG_CHAN_EXTEND}},
1294         {NULL, "Scale", ID_PO, 0, 3, {AC_SIZE_X,AC_SIZE_Y,AC_SIZE_Z}},
1295         
1296         {NULL, "%l", 0, -1, 0, {0}}, // separator
1297         
1298         {NULL, "LocRot", ID_PO, COMMONKEY_PCHANROT, 4, 
1299                 {AC_LOC_X,AC_LOC_Y,AC_LOC_Z,
1300                  KAG_CHAN_EXTEND}},
1301                  
1302         {NULL, "LocScale", ID_PO, 0, 6, 
1303                 {AC_LOC_X,AC_LOC_Y,AC_LOC_Z,
1304                  AC_SIZE_X,AC_SIZE_Y,AC_SIZE_Z}},
1305                  
1306         {NULL, "LocRotScale", ID_PO, COMMONKEY_PCHANROT, 7, 
1307                 {AC_LOC_X,AC_LOC_Y,AC_LOC_Z,AC_SIZE_X,AC_SIZE_Y,AC_SIZE_Z, 
1308                  KAG_CHAN_EXTEND}},
1309                  
1310         {NULL, "RotScale", ID_PO, 0, 4, 
1311                 {AC_SIZE_X,AC_SIZE_Y,AC_SIZE_Z, 
1312                  KAG_CHAN_EXTEND}},
1313         
1314         {incl_non_del_keys, "%l", 0, -1, 0, {0}}, // separator
1315         
1316         {incl_non_del_keys, "VisualLoc", ID_PO, INSERTKEY_MATRIX, 3, {AC_LOC_X,AC_LOC_Y,AC_LOC_Z}},
1317         {incl_non_del_keys, "VisualRot", ID_PO, INSERTKEY_MATRIX|COMMONKEY_PCHANROT, 1, {KAG_CHAN_EXTEND}},
1318         
1319         {incl_non_del_keys, "VisualLocRot", ID_PO, INSERTKEY_MATRIX|COMMONKEY_PCHANROT, 4, 
1320                 {AC_LOC_X,AC_LOC_Y,AC_LOC_Z, KAG_CHAN_EXTEND}},
1321         
1322         {NULL, "%l", 0, -1, 0, {0}}, // separator
1323         
1324         {NULL, "Available", ID_PO, -2, 0, {0}}
1325 };
1326
1327 /* Material KeyingSets  ------ */
1328
1329 /* array for material keyingset defines */
1330 bKeyingSet defks_buts_shading_mat[] = 
1331 {
1332         /* include_cb, name, blocktype, flag, chan_num, adrcodes */
1333         {NULL, "RGB", ID_MA, 0, 3, {MA_COL_R,MA_COL_G,MA_COL_B}},
1334         {NULL, "Alpha", ID_MA, 0, 1, {MA_ALPHA}},
1335         {NULL, "Halo Size", ID_MA, 0, 1, {MA_HASIZE}},
1336         {NULL, "Mode", ID_MA, 0, 1, {MA_MODE}}, // evil bitflags
1337         
1338         {NULL, "%l", 0, -1, 0, {0}}, // separator
1339         
1340         {NULL, "All Color", ID_MA, 0, 18, 
1341                 {MA_COL_R,MA_COL_G,MA_COL_B,
1342                  MA_ALPHA,MA_HASIZE, MA_MODE,
1343                  MA_SPEC_R,MA_SPEC_G,MA_SPEC_B,
1344                  MA_REF,MA_EMIT,MA_AMB,MA_SPEC,MA_HARD,
1345                  MA_MODE,MA_TRANSLU,MA_ADD}},
1346                  
1347         {NULL, "All Mirror", ID_MA, 0, 5, 
1348                 {MA_RAYM,MA_FRESMIR,MA_FRESMIRI,
1349                  MA_FRESTRA,MA_FRESTRAI}},
1350         
1351         {NULL, "%l", 0, -1, 0, {0}}, // separator
1352         
1353         {NULL, "Ofs", ID_MA, COMMONKEY_ADDMAP, 3, {MAP_OFS_X,MAP_OFS_Y,MAP_OFS_Z}},
1354         {NULL, "Size", ID_MA, COMMONKEY_ADDMAP, 3, {MAP_SIZE_X,MAP_SIZE_Y,MAP_SIZE_Z}},
1355         
1356         {NULL, "All Mapping", ID_MA, COMMONKEY_ADDMAP, 14, 
1357                 {MAP_OFS_X,MAP_OFS_Y,MAP_OFS_Z,
1358                  MAP_SIZE_X,MAP_SIZE_Y,MAP_SIZE_Z,
1359                  MAP_R,MAP_G,MAP_B,MAP_DVAR,
1360                  MAP_COLF,MAP_NORF,MAP_VARF,MAP_DISP}},
1361         
1362         {NULL, "%l", 0, -1, 0, {0}}, // separator
1363         
1364         {NULL, "Available", ID_MA, -2, 0, {0}}
1365 };
1366
1367 /* World KeyingSets  ------ */
1368
1369 /* array for world keyingset defines */
1370 bKeyingSet defks_buts_shading_wo[] = 
1371 {
1372         /* include_cb, name, blocktype, flag, chan_num, adrcodes */
1373         {NULL, "Zenith RGB", ID_WO, 0, 3, {WO_ZEN_R,WO_ZEN_G,WO_ZEN_B}},
1374         {NULL, "Horizon RGB", ID_WO, 0, 3, {WO_HOR_R,WO_HOR_G,WO_HOR_B}},
1375         
1376         {NULL, "%l", 0, -1, 0, {0}}, // separator
1377         
1378         {NULL, "Mist", ID_WO, 0, 4, {WO_MISI,WO_MISTDI,WO_MISTSTA,WO_MISTHI}},
1379         {NULL, "Stars", ID_WO, 0, 5, {WO_STAR_R,WO_STAR_G,WO_STAR_B,WO_STARDIST,WO_STARSIZE}},
1380         
1381         
1382         {NULL, "%l", 0, -1, 0, {0}}, // separator
1383         
1384         {NULL, "Ofs", ID_WO, COMMONKEY_ADDMAP, 3, {MAP_OFS_X,MAP_OFS_Y,MAP_OFS_Z}},
1385         {NULL, "Size", ID_WO, COMMONKEY_ADDMAP, 3, {MAP_SIZE_X,MAP_SIZE_Y,MAP_SIZE_Z}},
1386         
1387         {NULL, "All Mapping", ID_WO, COMMONKEY_ADDMAP, 14, 
1388                 {MAP_OFS_X,MAP_OFS_Y,MAP_OFS_Z,
1389                  MAP_SIZE_X,MAP_SIZE_Y,MAP_SIZE_Z,
1390                  MAP_R,MAP_G,MAP_B,MAP_DVAR,
1391                  MAP_COLF,MAP_NORF,MAP_VARF,MAP_DISP}},
1392         
1393         {NULL, "%l", 0, -1, 0, {0}}, // separator
1394         
1395         {NULL, "Available", ID_WO, -2, 0, {0}}
1396 };
1397
1398 /* Lamp KeyingSets  ------ */
1399
1400 /* array for lamp keyingset defines */
1401 bKeyingSet defks_buts_shading_la[] = 
1402 {
1403         /* include_cb, name, blocktype, flag, chan_num, adrcodes */
1404         {NULL, "RGB", ID_LA, 0, 3, {LA_COL_R,LA_COL_G,LA_COL_B}},
1405         {NULL, "Energy", ID_LA, 0, 1, {LA_ENERGY}},
1406         {NULL, "Spot Size", ID_LA, 0, 1, {LA_SPOTSI}},
1407         
1408         {NULL, "%l", 0, -1, 0, {0}}, // separator
1409         
1410         {NULL, "Ofs", ID_LA, COMMONKEY_ADDMAP, 3, {MAP_OFS_X,MAP_OFS_Y,MAP_OFS_Z}},
1411         {NULL, "Size", ID_LA, COMMONKEY_ADDMAP, 3, {MAP_SIZE_X,MAP_SIZE_Y,MAP_SIZE_Z}},
1412         
1413         {NULL, "All Mapping", ID_LA, COMMONKEY_ADDMAP, 14, 
1414                 {MAP_OFS_X,MAP_OFS_Y,MAP_OFS_Z,
1415                  MAP_SIZE_X,MAP_SIZE_Y,MAP_SIZE_Z,
1416                  MAP_R,MAP_G,MAP_B,MAP_DVAR,
1417                  MAP_COLF,MAP_NORF,MAP_VARF,MAP_DISP}},
1418         
1419         {NULL, "%l", 0, -1, 0, {0}}, // separator
1420         
1421         {NULL, "Available", ID_LA, -2, 0, {0}}
1422 };
1423
1424 /* Texture KeyingSets  ------ */
1425
1426 /* array for texture keyingset defines */
1427 bKeyingSet defks_buts_shading_tex[] = 
1428 {
1429         /* include_cb, name, blocktype, flag, chan_num, adrcodes */
1430         {NULL, "Clouds", ID_TE, 0, 5, 
1431                 {TE_NSIZE,TE_NDEPTH,TE_NTYPE,
1432                  TE_MG_TYP,TE_N_BAS1}},
1433         
1434         {NULL, "Marble", ID_TE, 0, 7, 
1435                 {TE_NSIZE,TE_NDEPTH,TE_NTYPE,
1436                  TE_TURB,TE_MG_TYP,TE_N_BAS1,TE_N_BAS2}},
1437                  
1438         {NULL, "Stucci", ID_TE, 0, 5, 
1439                 {TE_NSIZE,TE_NTYPE,TE_TURB,
1440                  TE_MG_TYP,TE_N_BAS1}},
1441                  
1442         {NULL, "Wood", ID_TE, 0, 6, 
1443                 {TE_NSIZE,TE_NTYPE,TE_TURB,
1444                  TE_MG_TYP,TE_N_BAS1,TE_N_BAS2}},
1445                  
1446         {NULL, "Magic", ID_TE, 0, 2, {TE_NDEPTH,TE_TURB}},
1447         
1448         {NULL, "Blend", ID_TE, 0, 1, {TE_MG_TYP}},      
1449                 
1450         {NULL, "Musgrave", ID_TE, 0, 6, 
1451                 {TE_MG_TYP,TE_MGH,TE_MG_LAC,
1452                  TE_MG_OCT,TE_MG_OFF,TE_MG_GAIN}},
1453                  
1454         {NULL, "Voronoi", ID_TE, 0, 9, 
1455                 {TE_VNW1,TE_VNW2,TE_VNW3,TE_VNW4,
1456                 TE_VNMEXP,TE_VN_DISTM,TE_VN_COLT,
1457                 TE_ISCA,TE_NSIZE}},
1458                 
1459         {NULL, "Distorted Noise", ID_TE, 0, 4, 
1460                 {TE_MG_OCT,TE_MG_OFF,TE_MG_GAIN,TE_DISTA}},
1461         
1462         {NULL, "Color Filter", ID_TE, 0, 5, 
1463                 {TE_COL_R,TE_COL_G,TE_COL_B,TE_BRIGHT,TE_CONTRA}},
1464         
1465         {NULL, "%l", 0, -1, 0, {0}}, // separator
1466         
1467         {NULL, "Available", ID_TE, -2, 0, {0}}
1468 };
1469
1470 /* Object Buttons KeyingSets  ------ */
1471
1472 /* check if include particles entry  */
1473 static short incl_buts_ob (bKeyingSet *ks, const char mode[])
1474 {
1475         //Object *ob= OBACT; // xxx
1476         Object *ob= NULL;
1477         /* only if object is mesh type */
1478         
1479         if(ob==NULL) return 0;
1480         return (ob->type == OB_MESH);
1481 }
1482
1483 /* array for texture keyingset defines */
1484 bKeyingSet defks_buts_object[] = 
1485 {
1486         /* include_cb, name, blocktype, flag, chan_num, adrcodes */
1487         {incl_buts_ob, "Surface Damping", ID_OB, 0, 1, {OB_PD_SDAMP}},
1488         {incl_buts_ob, "Random Damping", ID_OB, 0, 1, {OB_PD_RDAMP}},
1489         {incl_buts_ob, "Permeability", ID_OB, 0, 1, {OB_PD_PERM}},
1490         
1491         {NULL, "%l", 0, -1, 0, {0}}, // separator
1492         
1493         {NULL, "Force Strength", ID_OB, 0, 1, {OB_PD_FSTR}},
1494         {NULL, "Force Falloff", ID_OB, 0, 1, {OB_PD_FFALL}},
1495         
1496         {NULL, "%l", 0, -1, 0, {0}}, // separator
1497         
1498         {NULL, "Available", ID_OB, -2, 0, {0}}  // this will include ob-transforms too!
1499 };
1500
1501 /* Camera Buttons KeyingSets  ------ */
1502
1503 /* check if include internal-renderer entry  */
1504 static short incl_buts_cam1 (bKeyingSet *ks, const char mode[])
1505 {
1506         Scene *scene= NULL; // FIXME this will cause a crash, but we need an extra arg first!
1507         /* only if renderer is internal renderer */
1508         return (scene->r.renderer==R_INTERN);
1509 }
1510
1511 /* check if include external-renderer entry  */
1512 static short incl_buts_cam2 (bKeyingSet *ks, const char mode[])
1513 {
1514         Scene *scene= NULL; // FIXME this will cause a crash, but we need an extra arg first!
1515         /* only if renderer is internal renderer */
1516         return (scene->r.renderer!=R_INTERN);
1517 }
1518
1519 /* array for camera keyingset defines */
1520 bKeyingSet defks_buts_cam[] = 
1521 {
1522         /* include_cb, name, blocktype, flag, chan_num, adrcodes */
1523         {NULL, "Lens", ID_CA, 0, 1, {CAM_LENS}},
1524         {NULL, "Clipping", ID_CA, 0, 2, {CAM_STA,CAM_END}},
1525         {NULL, "Focal Distance", ID_CA, 0, 1, {CAM_YF_FDIST}},
1526         
1527         {NULL, "%l", 0, -1, 0, {0}}, // separator
1528         
1529         
1530         {incl_buts_cam2, "Aperture", ID_CA, 0, 1, {CAM_YF_APERT}},
1531         {incl_buts_cam1, "Viewplane Shift", ID_CA, 0, 2, {CAM_SHIFT_X,CAM_SHIFT_Y}},
1532         
1533         {NULL, "%l", 0, -1, 0, {0}}, // separator
1534         
1535         {NULL, "Available", ID_CA, -2, 0, {0}}
1536 };
1537
1538 /* --- */
1539
1540 /* Keying Context Defines - Must keep in sync with enumeration (eKS_Contexts) */
1541 bKeyingContext ks_contexts[] = 
1542 {
1543         KSC_TEMPLATE(v3d_object),
1544         KSC_TEMPLATE(v3d_pchan),
1545         
1546         KSC_TEMPLATE(buts_shading_mat),
1547         KSC_TEMPLATE(buts_shading_wo),
1548         KSC_TEMPLATE(buts_shading_la),
1549         KSC_TEMPLATE(buts_shading_tex),
1550
1551         KSC_TEMPLATE(buts_object),
1552         KSC_TEMPLATE(buts_cam)
1553 };
1554
1555 /* Keying Context Enumeration - Must keep in sync with definitions*/
1556 typedef enum eKS_Contexts {
1557         KSC_V3D_OBJECT = 0,
1558         KSC_V3D_PCHAN,
1559         
1560         KSC_BUTS_MAT,
1561         KSC_BUTS_WO,
1562         KSC_BUTS_LA,
1563         KSC_BUTS_TEX,
1564         
1565         KSC_BUTS_OB,
1566         KSC_BUTS_CAM,
1567         
1568                 /* make sure this last one remains untouched! */
1569         KSC_TOT_TYPES
1570 } eKS_Contexts;
1571
1572
1573 /* ---------------- KeyingSet Tools ------------------- */
1574
1575 /* helper for commonkey_context_get() -  get keyingsets for 3d-view */
1576 static void commonkey_context_getv3d (const bContext *C, ListBase *sources, bKeyingContext **ksc)
1577 {
1578         Scene *scene= CTX_data_scene(C);
1579         Object *ob;
1580         IpoCurve *icu;
1581         
1582         if ((OBACT) && (OBACT->flag & OB_POSEMODE)) {
1583                 bPoseChannel *pchan;
1584                 
1585                 /* pose-level */
1586                 ob= OBACT;
1587                 *ksc= &ks_contexts[KSC_V3D_PCHAN];
1588                         // XXX
1589                 //set_pose_keys(ob);  /* sets pchan->flag to POSE_KEY if bone selected, and clears if not */
1590                 
1591                 /* loop through posechannels */
1592                 for (pchan=ob->pose->chanbase.first; pchan; pchan=pchan->next) {
1593                         if (pchan->flag & POSE_KEY) {
1594                                 bCommonKeySrc *cks;
1595                                 
1596                                 /* add new keyframing destination */
1597                                 cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc");
1598                                 BLI_addtail(sources, cks);
1599                                 
1600                                 /* set id-block to key to, and action */
1601                                 cks->id= (ID *)ob;
1602                                 cks->act= ob->action;
1603                                 
1604                                 /* set pchan */
1605                                 cks->pchan= pchan;
1606                                 cks->actname= pchan->name;
1607                         }
1608                 }
1609         }
1610         else {
1611                 /* object-level */
1612                 *ksc= &ks_contexts[KSC_V3D_OBJECT];
1613                 
1614                 /* loop through bases */
1615                 // XXX but we're only supposed to do this on editable ones, not just selected ones!
1616                 CTX_DATA_BEGIN(C, Base*, base, selected_bases) {
1617                         bCommonKeySrc *cks;
1618                         
1619                         /* add new keyframing destination */
1620                         cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc");
1621                         BLI_addtail(sources, cks);
1622                         
1623                         /* set id-block to key to */
1624                         ob= base->object;
1625                         cks->id= (ID *)ob;
1626                 }
1627                 CTX_DATA_END;
1628         }
1629 }
1630
1631 /* helper for commonkey_context_get() -  get keyingsets for buttons window */
1632 static void commonkey_context_getsbuts (const bContext *C, ListBase *sources, bKeyingContext **ksc)
1633 {
1634 #if 0 // XXX dunno what's the future of this stuff...   
1635         bCommonKeySrc *cks;
1636         
1637         /* check on tab-type */
1638         switch (G.buts->mainb) {
1639         case CONTEXT_SHADING:   /* ------------- Shading buttons ---------------- */
1640                 /* subtabs include "Material", "Texture", "Lamp", "World"*/
1641                 switch (G.buts->tab[CONTEXT_SHADING]) {
1642                         case TAB_SHADING_MAT: /* >------------- Material Tab -------------< */
1643                         {
1644                                 Material *ma= editnode_get_active_material(G.buts->lockpoin);
1645                                 
1646                                 if (ma) {
1647                                         /* add new keyframing destination */
1648                                         cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc");
1649                                         BLI_addtail(sources, cks); 
1650                                         
1651                                         /* set data */
1652                                         cks->id= (ID *)ma;
1653                                         cks->ipo= ma->ipo;
1654                                         cks->map= texchannel_to_adrcode(ma->texact);
1655                                         
1656                                         /* set keyingsets */
1657                                         *ksc= &ks_contexts[KSC_BUTS_MAT];
1658                                         return;
1659                                 }
1660                         }
1661                                 break;
1662                         case TAB_SHADING_WORLD: /* >------------- World Tab -------------< */
1663                         {
1664                                 World *wo= G.buts->lockpoin;
1665                                 
1666                                 if (wo) {
1667                                         /* add new keyframing destination */
1668                                         cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc");
1669                                         BLI_addtail(sources, cks); 
1670                                         
1671                                         /* set data */
1672                                         cks->id= (ID *)wo;
1673                                         cks->ipo= wo->ipo;
1674                                         cks->map= texchannel_to_adrcode(wo->texact);
1675                                         
1676                                         /* set keyingsets */
1677                                         *ksc= &ks_contexts[KSC_BUTS_WO];
1678                                         return;
1679                                 }
1680                         }
1681                                 break;
1682                         case TAB_SHADING_LAMP: /* >------------- Lamp Tab -------------< */
1683                         {
1684                                 Lamp *la= G.buts->lockpoin;
1685                                 
1686                                 if (la) {
1687                                         /* add new keyframing destination */
1688                                         cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc");
1689                                         BLI_addtail(sources, cks); 
1690                                         
1691                                         /* set data */
1692                                         cks->id= (ID *)la;
1693                                         cks->ipo= la->ipo;
1694                                         cks->map= texchannel_to_adrcode(la->texact);
1695                                         
1696                                         /* set keyingsets */
1697                                         *ksc= &ks_contexts[KSC_BUTS_LA];
1698                                         return;
1699                                 }
1700                         }
1701                                 break;
1702                         case TAB_SHADING_TEX: /* >------------- Texture Tab -------------< */
1703                         {
1704                                 Tex *tex= G.buts->lockpoin;
1705                                 
1706                                 if (tex) {
1707                                         /* add new keyframing destination */
1708                                         cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc");
1709                                         BLI_addtail(sources, cks); 
1710                                         
1711                                         /* set data */
1712                                         cks->id= (ID *)tex;
1713                                         cks->ipo= tex->ipo;
1714                                         
1715                                         /* set keyingsets */
1716                                         *ksc= &ks_contexts[KSC_BUTS_TEX];
1717                                         return;
1718                                 }
1719                         }
1720                                 break;
1721                 }
1722                 break;
1723         
1724         case CONTEXT_OBJECT:    /* ------------- Object buttons ---------------- */
1725                 {
1726                         Object *ob= OBACT;
1727                         
1728                         if (ob) {
1729                                 /* add new keyframing destination */
1730                                 cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc");
1731                                 BLI_addtail(sources, cks);
1732                                 
1733                                 /* set id-block to key to */
1734                                 cks->id= (ID *)ob;
1735                                 cks->ipo= ob->ipo;
1736                                 
1737                                 /* set keyingsets */
1738                                 *ksc= &ks_contexts[KSC_BUTS_OB];
1739                                 return;
1740                         }
1741                 }
1742                 break;
1743         
1744         case CONTEXT_EDITING:   /* ------------- Editing buttons ---------------- */
1745                 {
1746                         Object *ob= OBACT;
1747                         
1748                         if ((ob) && (ob->type==OB_CAMERA) && (G.buts->lockpoin)) { /* >---------------- camera buttons ---------------< */
1749                                 Camera *ca= G.buts->lockpoin;
1750                                 
1751                                 /* add new keyframing destination */
1752                                 cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc");
1753                                 BLI_addtail(sources, cks);
1754                                 
1755                                 /* set id-block to key to */
1756                                 cks->id= (ID *)ca;
1757                                 cks->ipo= ca->ipo;
1758                                 
1759                                 /* set keyingsets */
1760                                 *ksc= &ks_contexts[KSC_BUTS_CAM];
1761                                 return;
1762                         }
1763                 }
1764                 break;
1765         }
1766 #endif // XXX end of buttons stuff to port...
1767         
1768         /* if nothing happened... */
1769         *ksc= NULL;
1770 }
1771
1772 #endif // XXX old keyingsets code based on adrcodes... to be restored in due course
1773
1774 #if 0 // XXX new relative keyingsets code
1775
1776 /* Check if context data is suitable for the given absolute Keying Set */
1777 static short keyingset_context_ok_poll (bContext *C, KeyingSet *ks)
1778 {
1779         
1780         return 1;
1781 }
1782
1783 /* Get list of data-sources from context for inserting keyframes using the given relative Keying Set */
1784 static short commonkey_get_context_data (bContext *C, ListBase *dsources, KeyingSet *ks)
1785 {
1786         
1787
1788
1789 #endif // XXX new relative keyingsets code
1790
1791 /* Given a KeyingSet and context info (if required), modify keyframes for the channels specified
1792  * by the KeyingSet. This takes into account many of the different combinations of using KeyingSets.
1793  * Returns the number of channels that keyframes were added to
1794  */
1795 static int commonkey_modifykey (ListBase *dsources, KeyingSet *ks, short mode, float cfra)
1796 {
1797         KS_Path *ksp;
1798         int kflag=0, success= 0;
1799         char *groupname= NULL;
1800         
1801         /* get flags to use */
1802         if (mode == COMMONKEY_MODE_INSERT) {
1803                 /* use KeyingSet's flags as base */
1804                 kflag= ks->keyingflag;
1805                 
1806                 /* suppliment with info from the context */
1807                 if (IS_AUTOKEY_FLAG(AUTOMATKEY)) kflag |= INSERTKEY_MATRIX;
1808                 if (IS_AUTOKEY_FLAG(INSERTNEEDED)) kflag |= INSERTKEY_NEEDED;
1809                 // if (IS_AUTOKEY_MODE(EDITKEYS)) flag |= INSERTKEY_REPLACE;
1810         }
1811         else if (mode == COMMONKEY_MODE_DELETE)
1812                 kflag= 0;
1813         
1814         /* check if the KeyingSet is absolute or not (i.e. does it requires sources info) */
1815         if (ks->flag & KEYINGSET_ABSOLUTE) {
1816                 /* Absolute KeyingSets are simpler to use, as all the destination info has already been
1817                  * provided by the user, and is stored, ready to use, in the KeyingSet paths.
1818                  */
1819                 for (ksp= ks->paths.first; ksp; ksp= ksp->next) {
1820                         int arraylen, i;
1821                         
1822                         /* get pointer to name of group to add channels to */
1823                         if (ksp->groupmode == KSP_GROUP_NONE)
1824                                 groupname= NULL;
1825                         else if (ksp->groupmode == KSP_GROUP_KSNAME)
1826                                 groupname= ks->name;
1827                         else
1828                                 groupname= ksp->group;
1829                         
1830                         /* init arraylen and i - arraylen should be greater than i so that
1831                          * normal non-array entries get keyframed correctly
1832                          */
1833                         i= ksp->array_index;
1834                         arraylen= i+1;
1835                         
1836                         /* get length of array if whole array option is enabled */
1837                         if (ksp->flag & KSP_FLAG_WHOLE_ARRAY) {
1838                                 PointerRNA id_ptr, ptr;
1839                                 PropertyRNA *prop;
1840                                 
1841                                 RNA_id_pointer_create(ksp->id, &id_ptr);
1842                                 if (RNA_path_resolve(&id_ptr, ksp->rna_path, &ptr, &prop) && prop)
1843                                         arraylen= RNA_property_array_length(&ptr, prop);
1844                         }
1845                         
1846                         /* for each possible index, perform operation 
1847                          *      - assume that arraylen is greater than index
1848                          */
1849                         for (; i < arraylen; i++) {
1850                                 /* action to take depends on mode */
1851                                 if (mode == COMMONKEY_MODE_INSERT)
1852                                         success+= insertkey(ksp->id, groupname, ksp->rna_path, i, cfra, kflag);
1853                                 else if (mode == COMMONKEY_MODE_DELETE)
1854                                         success+= deletekey(ksp->id, groupname,  ksp->rna_path, i, cfra, kflag);
1855                         }
1856                         
1857                         // TODO: set recalc tags on the ID?
1858                 }
1859         }
1860 #if 0 // XXX still need to figure out how to get such keyingsets working
1861         else if (dsources) {
1862                 /* for each one of the 'sources', resolve the template markers and expand arrays, then insert keyframes */
1863                 bCommonKeySrc *cks;
1864                 char *path = NULL;
1865                 int index=0, tot=0;
1866                 
1867                 /* for each 'source' for keyframe data, resolve each of the paths from the KeyingSet */
1868                 for (cks= dsources->first; cks; cks= cks->next) {
1869                         
1870                 }
1871         }
1872 #endif // XXX still need to figure out how to get such 
1873         
1874         return success;
1875 }
1876
1877
1878 /* Polling callback for use with ANIM_*_keyframe() operators
1879  * This is based on the standard ED_operator_areaactive callback,
1880  * except that it does special checks for a few spacetypes too...
1881  */
1882 static int modify_key_op_poll(bContext *C)
1883 {
1884         ScrArea *sa= CTX_wm_area(C);
1885         Scene *scene= CTX_data_scene(C);
1886         
1887         /* if no area or active scene */
1888         if (ELEM(NULL, sa, scene)) 
1889                 return 0;
1890         
1891         /* if Outliner, only allow in DataBlocks view */
1892         if (sa->spacetype == SPACE_OOPS) {
1893                 SpaceOops *so= (SpaceOops *)CTX_wm_space_data(C);
1894                 
1895                 if ((so->type != SO_OUTLINER) || (so->outlinevis != SO_DATABLOCKS))
1896                         return 0;
1897         }
1898         
1899         /* TODO: checks for other space types can be added here */
1900         
1901         /* should be fine */
1902         return 1;
1903 }
1904
1905 /* Insert Key Operator ------------------------ */
1906
1907 /* NOTE:
1908  * This is one of the 'simpler new-style' Insert Keyframe operators which relies on Keying Sets.
1909  * For now, these are absolute Keying Sets only, so there is very little context info involved.
1910  *
1911  *      -- Joshua Leung, Feb 2009
1912  */
1913  
1914 static int insert_key_exec (bContext *C, wmOperator *op)
1915 {
1916         ListBase dsources = {NULL, NULL};
1917         Scene *scene= CTX_data_scene(C);
1918         KeyingSet *ks= NULL;
1919         float cfra= (float)CFRA; // XXX for now, don't bother about all the yucky offset crap
1920         short success;
1921         
1922         /* try to get KeyingSet */
1923         if (scene->active_keyingset > 0)
1924                 ks= BLI_findlink(&scene->keyingsets, scene->active_keyingset-1);
1925         /* report failure */
1926         if (ks == NULL) {
1927                 BKE_report(op->reports, RPT_ERROR, "No active Keying Set");
1928                 return OPERATOR_CANCELLED;
1929         }
1930         
1931         /* try to insert keyframes for the channels specified by KeyingSet */
1932         success= commonkey_modifykey(&dsources, ks, COMMONKEY_MODE_INSERT, cfra);
1933         printf("KeyingSet '%s' - Successfully added %d Keyframes \n", ks->name, success);
1934         
1935         /* report failure? */
1936         if (success == 0)
1937                 BKE_report(op->reports, RPT_WARNING, "Keying Set failed to insert any keyframes");
1938         
1939         /* send updates */
1940         ED_anim_dag_flush_update(C);    
1941         
1942         /* for now, only send ND_KEYS for KeyingSets */
1943         WM_event_add_notifier(C, ND_KEYS, NULL);
1944         
1945         return OPERATOR_FINISHED;
1946 }
1947
1948 void ANIM_OT_insert_keyframe (wmOperatorType *ot)
1949 {
1950         /* identifiers */
1951         ot->name= "Insert Keyframe";
1952         ot->idname= "ANIM_OT_insert_keyframe";
1953         
1954         /* callbacks */
1955         ot->exec= insert_key_exec; 
1956         ot->poll= modify_key_op_poll;
1957         
1958         /* flags */
1959         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1960 }
1961
1962 /* Delete Key Operator ------------------------ */
1963
1964 /* NOTE:
1965  * This is one of the 'simpler new-style' Insert Keyframe operators which relies on Keying Sets.
1966  * For now, these are absolute Keying Sets only, so there is very little context info involved.
1967  *
1968  *      -- Joshua Leung, Feb 2009
1969  */
1970  
1971 static int delete_key_exec (bContext *C, wmOperator *op)
1972 {
1973         ListBase dsources = {NULL, NULL};
1974         Scene *scene= CTX_data_scene(C);
1975         KeyingSet *ks= NULL;
1976         float cfra= (float)CFRA; // XXX for now, don't bother about all the yucky offset crap
1977         short success;
1978         
1979         /* try to get KeyingSet */
1980         if (scene->active_keyingset > 0)
1981                 ks= BLI_findlink(&scene->keyingsets, scene->active_keyingset-1);
1982         /* report failure */
1983         if (ks == NULL) {
1984                 BKE_report(op->reports, RPT_ERROR, "No active Keying Set");
1985                 return OPERATOR_CANCELLED;
1986         }
1987         
1988         /* try to insert keyframes for the channels specified by KeyingSet */
1989         success= commonkey_modifykey(&dsources, ks, COMMONKEY_MODE_DELETE, cfra);
1990         printf("KeyingSet '%s' - Successfully removed %d Keyframes \n", ks->name, success);
1991         
1992         /* report failure? */
1993         if (success == 0)
1994                 BKE_report(op->reports, RPT_WARNING, "Keying Set failed to remove any keyframes");
1995         
1996         /* send updates */
1997         ED_anim_dag_flush_update(C);    
1998         
1999         /* for now, only send ND_KEYS for KeyingSets */
2000         WM_event_add_notifier(C, ND_KEYS, NULL);
2001         
2002         return OPERATOR_FINISHED;
2003 }
2004
2005 void ANIM_OT_delete_keyframe (wmOperatorType *ot)
2006 {
2007         /* identifiers */
2008         ot->name= "Delete Keyframe";
2009         ot->idname= "ANIM_OT_delete_keyframe";
2010         
2011         /* callbacks */
2012         ot->exec= delete_key_exec; 
2013         ot->poll= modify_key_op_poll;
2014         
2015         /* flags */
2016         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
2017 }
2018
2019 /* Insert Key Operator ------------------------ */
2020
2021 /* XXX WARNING:
2022  * This is currently just a basic operator, which work in 3d-view context on objects/bones only
2023  * and will insert keyframes for a few settings only. This is until it becomes clear how
2024  * to separate (or not) the process for RNA-path creation between context + keyingsets.
2025  * 
2026  * -- Joshua Leung, Jan 2009
2027  */
2028
2029 /* defines for basic insert-key testing operator  */
2030         // XXX this will definitely be replaced
2031 EnumPropertyItem prop_insertkey_types[] = {
2032         {0, "KEYINGSET", "Active KeyingSet", ""},
2033         {1, "OBLOC", "Object Location", ""},
2034         {2, "OBROT", "Object Rotation", ""},
2035         {3, "OBSCALE", "Object Scale", ""},
2036         {4, "MAT_COL", "Active Material - Color", ""},
2037         {5, "PCHANLOC", "Pose-Channel Location", ""},
2038         {6, "PCHANROT", "Pose-Channel Rotation", ""},
2039         {7, "PCHANSCALE", "Pose-Channel Scale", ""},
2040         {0, NULL, NULL, NULL}
2041 };
2042
2043 static int insert_key_old_invoke (bContext *C, wmOperator *op, wmEvent *event)
2044 {
2045         Object *ob= CTX_data_active_object(C);
2046         uiMenuItem *head;
2047         
2048         if (ob == NULL)
2049                 return OPERATOR_CANCELLED;
2050                 
2051         head= uiPupMenuBegin("Insert Keyframe", 0);
2052         
2053         /* active keyingset */
2054         uiMenuItemEnumO(head, "", 0, "ANIM_OT_insert_keyframe_old", "type", 0);
2055         
2056         /* selective inclusion */
2057         if ((ob->pose) && (ob->flag & OB_POSEMODE)) {
2058                 /* bone types */        
2059                 uiMenuItemEnumO(head, "", 0, "ANIM_OT_insert_keyframe_old", "type", 5);
2060                 uiMenuItemEnumO(head, "", 0, "ANIM_OT_insert_keyframe_old", "type", 6);
2061                 uiMenuItemEnumO(head, "", 0, "ANIM_OT_insert_keyframe_old", "type", 7);
2062         }
2063         else {
2064                 /* object types */
2065                 uiMenuItemEnumO(head, "", 0, "ANIM_OT_insert_keyframe_old", "type", 1);
2066                 uiMenuItemEnumO(head, "", 0, "ANIM_OT_insert_keyframe_old", "type", 2);
2067                 uiMenuItemEnumO(head, "", 0, "ANIM_OT_insert_keyframe_old", "type", 3);
2068                 uiMenuItemEnumO(head, "", 0, "ANIM_OT_insert_keyframe_old", "type", 4);
2069         }
2070         
2071         uiPupMenuEnd(C, head);
2072         
2073         return OPERATOR_CANCELLED;
2074 }
2075  
2076 static int insert_key_old_exec (bContext *C, wmOperator *op)
2077 {
2078         Scene *scene= CTX_data_scene(C);
2079         short mode= RNA_enum_get(op->ptr, "type");
2080         float cfra= (float)CFRA; // XXX for now, don't bother about all the yucky offset crap
2081         
2082         /* for now, handle 'active keyingset' one separately */
2083         if (mode == 0) {
2084                 ListBase dsources = {NULL, NULL};
2085                 KeyingSet *ks= NULL;
2086                 short success;
2087                 
2088                 /* try to get KeyingSet */
2089                 if (scene->active_keyingset > 0)
2090                         ks= BLI_findlink(&scene->keyingsets, scene->active_keyingset-1);
2091                 /* report failure */
2092                 if (ks == NULL) {
2093                         BKE_report(op->reports, RPT_ERROR, "No active Keying Set");
2094                         return OPERATOR_CANCELLED;
2095                 }
2096                 
2097                 /* try to insert keyframes for the channels specified by KeyingSet */
2098                 success= commonkey_modifykey(&dsources, ks, COMMONKEY_MODE_INSERT, cfra);
2099                 printf("KeyingSet '%s' - Successfully added %d Keyframes \n", ks->name, success);
2100                 
2101                 /* report failure? */
2102                 if (success == 0)
2103                         BKE_report(op->reports, RPT_WARNING, "Keying Set failed to insert any keyframes");
2104         }
2105         else {
2106                 // more comprehensive tests will be needed
2107                 CTX_DATA_BEGIN(C, Base*, base, selected_bases) 
2108                 {
2109                         Object *ob= base->object;
2110                         ID *id= (ID *)ob;
2111                         short success= 0;
2112                         
2113                         /* check which keyframing mode chosen for this object */
2114                         if (mode < 4) {
2115                                 /* object-based keyframes */
2116                                 switch (mode) {
2117                                 case 4: /* color of active material (only for geometry...) */
2118                                         // NOTE: this is just a demo... but ideally we'd go through materials instead of active one only so reference stays same
2119                                         // XXX no group for now
2120                                         success+= insertkey(id, NULL, "active_material.diffuse_color", 0, cfra, 0);
2121                                         success+= insertkey(id, NULL, "active_material.diffuse_color", 1, cfra, 0);
2122                                         success+= insertkey(id, NULL, "active_material.diffuse_color", 2, cfra, 0);
2123                                         break;
2124                                 case 3: /* object scale */
2125                                         success+= insertkey(id, "Object Transforms", "scale", 0, cfra, 0);
2126                                         success+= insertkey(id, "Object Transforms", "scale", 1, cfra, 0);
2127                                         success+= insertkey(id, "Object Transforms", "scale", 2, cfra, 0);
2128                                         break;
2129                                 case 2: /* object rotation */
2130                                         success+= insertkey(id, "Object Transforms", "rotation", 0, cfra, 0);
2131                                         success+= insertkey(id, "Object Transforms", "rotation", 1, cfra, 0);
2132                                         success+= insertkey(id, "Object Transforms", "rotation", 2, cfra, 0);
2133                                         break;
2134                                 default: /* object location */
2135                                         success+= insertkey(id, "Object Transforms", "location", 0, cfra, 0);
2136                                         success+= insertkey(id, "Object Transforms", "location", 1, cfra, 0);
2137                                         success+= insertkey(id, "Object Transforms", "location", 2, cfra, 0);
2138                                         break;
2139                                 }
2140                                 
2141                                 ob->recalc |= OB_RECALC_OB;
2142                         }
2143                         else if ((ob->pose) && (ob->flag & OB_POSEMODE)) {
2144                                 /* PoseChannel based keyframes */
2145                                 bPoseChannel *pchan;
2146                                 
2147                                 for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
2148                                         /* only if selected */
2149                                         if ((pchan->bone) && (pchan->bone->flag & BONE_SELECTED)) {
2150                                                 char buf[512];
2151                                                 
2152                                                 switch (mode) {
2153                                                 case 7: /* pchan scale */
2154                                                         sprintf(buf, "pose.pose_channels[\"%s\"].scale", pchan->name);
2155                                                         success+= insertkey(id, pchan->name, buf, 0, cfra, 0);
2156                                                         success+= insertkey(id, pchan->name, buf, 1, cfra, 0);
2157                                                         success+= insertkey(id, pchan->name, buf, 2, cfra, 0);
2158                                                         break;
2159                                                 case 6: /* pchan rotation */
2160                                                         if (pchan->rotmode == PCHAN_ROT_QUAT) {
2161                                                                 sprintf(buf, "pose.pose_channels[\"%s\"].rotation", pchan->name);
2162                                                                 success+= insertkey(id, pchan->name, buf, 0, cfra, 0);
2163                                                                 success+= insertkey(id, pchan->name, buf, 1, cfra, 0);
2164                                                                 success+= insertkey(id, pchan->name, buf, 2, cfra, 0);
2165                                                                 success+= insertkey(id, pchan->name, buf, 3, cfra, 0);
2166                                                         }
2167                                                         else {
2168                                                                 sprintf(buf, "pose.pose_channels[\"%s\"].euler_rotation", pchan->name);
2169                                                                 success+= insertkey(id, pchan->name, buf, 0, cfra, 0);
2170                                                                 success+= insertkey(id, pchan->name, buf, 1, cfra, 0);
2171                                                                 success+= insertkey(id, pchan->name, buf, 2, cfra, 0);
2172                                                         }
2173                                                         break;
2174                                                 default: /* pchan location */
2175                                                         sprintf(buf, "pose.pose_channels[\"%s\"].location", pchan->name);
2176                                                         success+= insertkey(id, pchan->name, buf, 0, cfra, 0);
2177                                                         success+= insertkey(id, pchan->name, buf, 1, cfra, 0);
2178                                                         success+= insertkey(id, pchan->name, buf, 2, cfra, 0);
2179                                                         break;
2180                                                 }
2181                                         }
2182                                 }
2183                                 
2184                                 ob->recalc |= OB_RECALC_OB;
2185                         }
2186                         
2187                         printf("Ob '%s' - Successfully added %d Keyframes \n", id->name+2, success);
2188                 }
2189                 CTX_DATA_END;
2190         }
2191         
2192         /* send updates */
2193         ED_anim_dag_flush_update(C);    
2194         
2195         if (mode == 0) /* for now, only send ND_KEYS for KeyingSets */
2196                 WM_event_add_notifier(C, ND_KEYS, NULL);
2197         else if (mode == 4) /* material color requires different notifiers */
2198                 WM_event_add_notifier(C, NC_MATERIAL|ND_KEYS, NULL);
2199         else
2200                 WM_event_add_notifier(C, NC_OBJECT|ND_KEYS, NULL);
2201         
2202         return OPERATOR_FINISHED;
2203 }
2204
2205 void ANIM_OT_insert_keyframe_old (wmOperatorType *ot)
2206 {
2207         PropertyRNA *prop;
2208         
2209         /* identifiers */
2210         ot->name= "Insert Keyframe";
2211         ot->idname= "ANIM_OT_insert_keyframe_old";
2212         
2213         /* callbacks */
2214         ot->invoke= insert_key_old_invoke;
2215         ot->exec= insert_key_old_exec; 
2216         ot->poll= ED_operator_areaactive;
2217         
2218         /* flags */
2219         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
2220         
2221         /* properties */
2222                 // XXX update this for the latest RNA stuff styles...
2223         prop= RNA_def_property(ot->srna, "type", PROP_ENUM, PROP_NONE);
2224         RNA_def_property_enum_items(prop, prop_insertkey_types);
2225 }
2226
2227 /* Delete Key Operator ------------------------ */
2228
2229 /* XXX WARNING:
2230  * This is currently just a basic operator, which work in 3d-view context on objects only. 
2231  * -- Joshua Leung, Jan 2009
2232  */
2233  
2234 static int delete_key_old_exec (bContext *C, wmOperator *op)
2235 {
2236         Scene *scene= CTX_data_scene(C);
2237         float cfra= (float)CFRA; // XXX for now, don't bother about all the yucky offset crap
2238         
2239         // XXX more comprehensive tests will be needed
2240         CTX_DATA_BEGIN(C, Base*, base, selected_bases) 
2241         {
2242                 Object *ob= base->object;
2243                 ID *id= (ID *)ob;
2244                 FCurve *fcu, *fcn;
2245                 short success= 0;
2246                 
2247                 /* loop through all curves in animdata and delete keys on this frame */
2248                 if (ob->adt) {
2249                         AnimData *adt= ob->adt;
2250                         bAction *act= adt->action;
2251                         
2252                         for (fcu= act->curves.first; fcu; fcu= fcn) {
2253                                 fcn= fcu->next;
2254                                 success+= deletekey(id, NULL, fcu->rna_path, fcu->array_index, cfra, 0);
2255                         }
2256                 }
2257                 
2258                 printf("Ob '%s' - Successfully removed %d keyframes \n", id->name+2, success);
2259                 
2260                 ob->recalc |= OB_RECALC_OB;
2261         }
2262         CTX_DATA_END;
2263         
2264         /* send updates */
2265         ED_anim_dag_flush_update(C);    
2266         
2267                 // XXX what if it was a material keyframe?
2268         WM_event_add_notifier(C, NC_OBJECT|ND_KEYS, NULL);
2269         
2270         return OPERATOR_FINISHED;
2271 }
2272
2273 void ANIM_OT_delete_keyframe_old (wmOperatorType *ot)
2274 {
2275         /* identifiers */
2276         ot->name= "Delete Keyframe";
2277         ot->idname= "ANIM_OT_delete_keyframe_old";
2278         
2279         /* callbacks */
2280         ot->invoke= WM_operator_confirm; // XXX we will need our own one eventually, to cope with the dynamic menus...
2281         ot->exec= delete_key_old_exec; 
2282         
2283         ot->poll= ED_operator_areaactive;
2284         
2285         /* flags */
2286         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
2287 }
2288
2289 /* ******************************************* */
2290 /* KEYFRAME DETECTION */
2291
2292 /* --------------- API/Per-Datablock Handling ------------------- */
2293
2294 /* Checks whether an IPO-block has a keyframe for a given frame 
2295  * Since we're only concerned whether a keyframe exists, we can simply loop until a match is found...
2296  */
2297 short action_frame_has_keyframe (bAction *act, float frame, short filter)
2298 {
2299         FCurve *fcu;
2300         
2301         /* can only find if there is data */
2302         if (act == NULL)
2303                 return 0;
2304                 
2305         /* if only check non-muted, check if muted */
2306         if ((filter & ANIMFILTER_KEYS_MUTED) || (act->flag & ACT_MUTED))
2307                 return 0;
2308         
2309         /* loop over F-Curves, using binary-search to try to find matches 
2310          *      - this assumes that keyframes are only beztriples
2311          */
2312         for (fcu= act->curves.first; fcu; fcu= fcu->next) {
2313                 /* only check if there are keyframes (currently only of type BezTriple) */
2314                 if (fcu->bezt && fcu->totvert) {
2315                         /* we either include all regardless of muting, or only non-muted  */
2316                         if ((filter & ANIMFILTER_KEYS_MUTED) || (fcu->flag & FCURVE_MUTED)==0) {
2317                                 short replace = -1;
2318                                 int i = binarysearch_bezt_index(fcu->bezt, frame, fcu->totvert, &replace);
2319                                 
2320                                 /* binarysearch_bezt_index will set replace to be 0 or 1
2321                                  *      - obviously, 1 represents a match
2322                                  */
2323                                 if (replace) {                  
2324                                         /* sanity check: 'i' may in rare cases exceed arraylen */
2325                                         if ((i >= 0) && (i < fcu->totvert))
2326                                                 return 1;
2327                                 }
2328                         }
2329                 }
2330         }
2331         
2332         /* nothing found */
2333         return 0;
2334 }
2335
2336 /* Checks whether an Object has a keyframe for a given frame */
2337 short object_frame_has_keyframe (Object *ob, float frame, short filter)
2338 {
2339         /* error checking */
2340         if (ob == NULL)
2341                 return 0;
2342         
2343         /* check own animation data - specifically, the action it contains */
2344         if ((ob->adt) && (ob->adt->action)) {
2345                 if (action_frame_has_keyframe(ob->adt->action, frame, filter))
2346                         return 1;
2347         }
2348         
2349         /* try shapekey keyframes (if available, and allowed by filter) */
2350         if ( !(filter & ANIMFILTER_KEYS_LOCAL) && !(filter & ANIMFILTER_KEYS_NOSKEY) ) {
2351                 Key *key= ob_get_key(ob);
2352                 
2353                 /* shapekeys can have keyframes ('Relative Shape Keys') 
2354                  * or depend on time (old 'Absolute Shape Keys') 
2355                  */
2356                  
2357                         /* 1. test for relative (with keyframes) */
2358                 if (id_frame_has_keyframe((ID *)key, frame, filter))
2359                         return 1;
2360                         
2361                         /* 2. test for time */
2362                 // TODO... yet to be implemented (this feature may evolve before then anyway)
2363         }
2364         
2365         /* try materials */
2366         if ( !(filter & ANIMFILTER_KEYS_LOCAL) && !(filter & ANIMFILTER_KEYS_NOMAT) ) {
2367                 /* if only active, then we can skip a lot of looping */
2368                 if (filter & ANIMFILTER_KEYS_ACTIVE) {
2369                         Material *ma= give_current_material(ob, (ob->actcol + 1));
2370                         
2371                         /* we only retrieve the active material... */
2372                         if (id_frame_has_keyframe((ID *)ma, frame, filter))
2373                                 return 1;
2374                 }
2375                 else {
2376                         int a;
2377                         
2378                         /* loop over materials */
2379                         for (a=0; a<ob->totcol; a++) {
2380                                 Material *ma= give_current_material(ob, a+1);
2381                                 
2382                                 if (id_frame_has_keyframe((ID *)ma, frame, filter))
2383                                         return 1;
2384                         }
2385                 }
2386         }
2387         
2388         /* nothing found */
2389         return 0;
2390 }
2391
2392 /* --------------- API ------------------- */
2393
2394 /* Checks whether a keyframe exists for the given ID-block one the given frame */
2395 short id_frame_has_keyframe (ID *id, float frame, short filter)
2396 {
2397         /* sanity checks */
2398         if (id == NULL)
2399                 return 0;
2400         
2401         /* perform special checks for 'macro' types */
2402         switch (GS(id->name)) {
2403                 case ID_OB: /* object */
2404                         return object_frame_has_keyframe((Object *)id, frame, filter);
2405                         break;
2406                         
2407                 case ID_SCE: /* scene */
2408                 // XXX TODO... for now, just use 'normal' behaviour
2409                 //      break;
2410                 
2411                 default:        /* 'normal type' */
2412                 {
2413                         AnimData *adt= BKE_animdata_from_id(id);
2414                         
2415                         /* only check keyframes in active action */
2416                         if (adt)
2417                                 return action_frame_has_keyframe(adt->action, frame, filter);
2418                 }
2419                         break;
2420         }
2421         
2422         
2423         /* no keyframe found */
2424         return 0;
2425 }
2426
2427 /* ************************************************** */