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 specific 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_OUTLINER) {
1893                 SpaceOops *so= (SpaceOops *)CTX_wm_space_data(C);
1894
1895                 if ((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 /* ************************************************** */