source/blender/editors/animation/keyingsets.c

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