source/blender/editors/animation/keyingsets.c

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