source/blender/editors/space_action/action_edit.c

   1 /**
   2  * $Id: editaction.c 17746 2008-12-08 11:19:44Z aligorith $
   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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19  *
  20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  21  * All rights reserved.
  22  *
  23  * The Original Code is: all of this file.
  24  *
  25  * Contributor(s): Joshua Leung
  26  *
  27  * ***** END GPL LICENSE BLOCK *****
  28  */
  29
  30 #include <math.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <float.h>
  34
  35 #ifdef HAVE_CONFIG_H
  36 #include <config.h>
  37 #endif
  38
  39 #include "MEM_guardedalloc.h"
  40
  41 #include "BLI_blenlib.h"
  42 #include "BLI_arithb.h"
  43
  44 #include "DNA_anim_types.h"
  45 #include "DNA_action_types.h"
  46 #include "DNA_armature_types.h"
  47 #include "DNA_camera_types.h"
  48 #include "DNA_curve_types.h"
  49 #include "DNA_object_types.h"
  50 #include "DNA_screen_types.h"
  51 #include "DNA_scene_types.h"
  52 #include "DNA_space_types.h"
  53 #include "DNA_constraint_types.h"
  54 #include "DNA_key_types.h"
  55 #include "DNA_lamp_types.h"
  56 #include "DNA_material_types.h"
  57 #include "DNA_userdef_types.h"
  58 #include "DNA_gpencil_types.h"
  59 #include "DNA_windowmanager_types.h"
  60
  61 #include "RNA_access.h"
  62 #include "RNA_define.h"
  63 #include "RNA_enum_types.h"
  64
  65 #include "BKE_action.h"
  66 #include "BKE_depsgraph.h"
  67 #include "BKE_fcurve.h"
  68 #include "BKE_key.h"
  69 #include "BKE_material.h"
  70 #include "BKE_object.h"
  71 #include "BKE_context.h"
  72 #include "BKE_report.h"
  73 #include "BKE_utildefines.h"
  74
  75 #include "UI_view2d.h"
  76
  77 #include "BIF_transform.h"
  78
  79 #include "ED_anim_api.h"
  80 #include "ED_keyframing.h"
  81 #include "ED_keyframes_draw.h"
  82 #include "ED_keyframes_edit.h"
  83 #include "ED_screen.h"
  84 #include "ED_space_api.h"
  85
  86 #include "WM_api.h"
  87 #include "WM_types.h"
  88
  89 #include "action_intern.h"
  90
  91 /* ************************************************************************** */
  92 /* KEYFRAME-RANGE STUFF */
  93
  94 /* *************************** Calculate Range ************************** */
  95
  96 /* Get the min/max keyframes*/
  97 static void get_keyframe_extents (bAnimContext *ac, float *min, float *max)
  98 {
  99         ListBase anim_data = {NULL, NULL};
 100         bAnimListElem *ale;
 101         int filter;
 102
 103         /* get data to filter, from Action or Dopesheet */
 104         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
 105         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 106
 107         /* set large values to try to override */
 108         *min= 999999999.0f;
 109         *max= -999999999.0f;
 110
 111         /* check if any channels to set range with */
 112         if (anim_data.first) {
 113                 /* go through channels, finding max extents */
 114                 for (ale= anim_data.first; ale; ale= ale->next) {
 115                         Object *nob= ANIM_nla_mapping_get(ac, ale);
 116                         FCurve *fcu= (FCurve *)ale->key_data;
 117                         float tmin, tmax;
 118
 119                         /* get range and apply necessary scaling before */
 120                         calc_fcurve_range(fcu, &tmin, &tmax);
 121
 122                         if (nob) {
 123                                 tmin= get_action_frame_inv(nob, tmin);
 124                                 tmax= get_action_frame_inv(nob, tmax);
 125                         }
 126
 127                         /* try to set cur using these values, if they're more extreme than previously set values */
 128                         *min= MIN2(*min, tmin);
 129                         *max= MAX2(*max, tmax);
 130                 }
 131
 132                 /* free memory */
 133                 BLI_freelistN(&anim_data);
 134         }
 135         else {
 136                 /* set default range */
 137                 if (ac->scene) {
 138                         *min= (float)ac->scene->r.sfra;
 139                         *max= (float)ac->scene->r.efra;
 140                 }
 141                 else {
 142                         *min= -5;
 143                         *max= 100;
 144                 }
 145         }
 146 }
 147
 148 /* ****************** Automatic Preview-Range Operator ****************** */
 149
 150 static int actkeys_previewrange_exec(bContext *C, wmOperator *op)
 151 {
 152         bAnimContext ac;
 153         Scene *scene;
 154         float min, max;
 155
 156         /* get editor data */
 157         if (ANIM_animdata_get_context(C, &ac) == 0)
 158                 return OPERATOR_CANCELLED;
 159         if (ac.scene == NULL)
 160                 return OPERATOR_CANCELLED;
 161         else
 162                 scene= ac.scene;
 163
 164         /* set the range directly */
 165         get_keyframe_extents(&ac, &min, &max);
 166         scene->r.psfra= (int)floor(min + 0.5f);
 167         scene->r.pefra= (int)floor(max + 0.5f);
 168
 169         /* set notifier that things have changed */
 170         // XXX err... there's nothing for frame ranges yet, but this should do fine too
 171         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene);
 172
 173         return OPERATOR_FINISHED;
 174 }
 175
 176 void ACT_OT_previewrange_set (wmOperatorType *ot)
 177 {
 178         /* identifiers */
 179         ot->name= "Auto-Set Preview Range";
 180         ot->idname= "ACT_OT_previewrange_set";
 181
 182         /* api callbacks */
 183         ot->exec= actkeys_previewrange_exec;
 184         ot->poll= ED_operator_areaactive;
 185
 186         /* flags */
 187         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 188 }
 189
 190 /* ****************** View-All Operator ****************** */
 191
 192 static int actkeys_viewall_exec(bContext *C, wmOperator *op)
 193 {
 194         bAnimContext ac;
 195         View2D *v2d;
 196         float extra;
 197
 198         /* get editor data */
 199         if (ANIM_animdata_get_context(C, &ac) == 0)
 200                 return OPERATOR_CANCELLED;
 201         v2d= &ac.ar->v2d;
 202
 203         /* set the horizontal range, with an extra offset so that the extreme keys will be in view */
 204         get_keyframe_extents(&ac, &v2d->cur.xmin, &v2d->cur.xmax);
 205
 206         extra= 0.1f * (v2d->cur.xmax - v2d->cur.xmin);
 207         v2d->cur.xmin -= extra;
 208         v2d->cur.xmax += extra;
 209
 210         /* set vertical range */
 211         v2d->cur.ymax= 0.0f;
 212         v2d->cur.ymin= (float)-(v2d->mask.ymax - v2d->mask.ymin);
 213
 214         /* do View2D syncing */
 215         UI_view2d_sync(CTX_wm_screen(C), CTX_wm_area(C), v2d, V2D_LOCK_COPY);
 216
 217         /* set notifier that things have changed */
 218         ED_area_tag_redraw(CTX_wm_area(C));
 219
 220         return OPERATOR_FINISHED;
 221 }
 222
 223 void ACT_OT_view_all (wmOperatorType *ot)
 224 {
 225         /* identifiers */
 226         ot->name= "View All";
 227         ot->idname= "ACT_OT_view_all";
 228
 229         /* api callbacks */
 230         ot->exec= actkeys_viewall_exec;
 231         ot->poll= ED_operator_areaactive;
 232
 233         /* flags */
 234         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 235 }
 236
 237 /* ************************************************************************** */
 238 /* GENERAL STUFF */
 239
 240 /* ******************** Copy/Paste Keyframes Operator ************************* */
 241 /* NOTE: the backend code for this is shared with the graph editor */
 242
 243 static short copy_action_keys (bAnimContext *ac)
 244 {
 245         ListBase anim_data = {NULL, NULL};
 246         int filter, ok=0;
 247
 248         /* clear buffer first */
 249         free_anim_copybuf();
 250
 251         /* filter data */
 252         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVESONLY);
 253         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 254
 255         /* copy keyframes */
 256         ok= copy_animedit_keys(ac, &anim_data);
 257
 258         /* clean up */
 259         BLI_freelistN(&anim_data);
 260
 261         return ok;
 262 }
 263
 264
 265 static short paste_action_keys (bAnimContext *ac)
 266 {
 267         ListBase anim_data = {NULL, NULL};
 268         int filter, ok=0;
 269
 270         /* filter data */
 271         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
 272         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 273
 274         /* paste keyframes */
 275         ok= paste_animedit_keys(ac, &anim_data);
 276
 277         /* clean up */
 278         BLI_freelistN(&anim_data);
 279
 280         return ok;
 281 }
 282
 283 /* ------------------- */
 284
 285 static int actkeys_copy_exec(bContext *C, wmOperator *op)
 286 {
 287         bAnimContext ac;
 288
 289         /* get editor data */
 290         if (ANIM_animdata_get_context(C, &ac) == 0)
 291                 return OPERATOR_CANCELLED;
 292
 293         /* copy keyframes */
 294         if (ac.datatype == ANIMCONT_GPENCIL) {
 295                 // FIXME...
 296         }
 297         else {
 298                 if (copy_action_keys(&ac)) {
 299                         BKE_report(op->reports, RPT_ERROR, "No keyframes copied to keyframes copy/paste buffer");
 300                         return OPERATOR_CANCELLED;
 301                 }
 302         }
 303
 304         /* set notifier that things have changed */
 305         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
 306
 307         return OPERATOR_FINISHED;
 308 }
 309
 310 void ACT_OT_keyframes_copy (wmOperatorType *ot)
 311 {
 312         /* identifiers */
 313         ot->name= "Copy Keyframes";
 314         ot->idname= "ACT_OT_keyframes_copy";
 315
 316         /* api callbacks */
 317         ot->exec= actkeys_copy_exec;
 318         ot->poll= ED_operator_areaactive;
 319
 320         /* flags */
 321         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 322 }
 323
 324
 325
 326 static int actkeys_paste_exec(bContext *C, wmOperator *op)
 327 {
 328         bAnimContext ac;
 329
 330         /* get editor data */
 331         if (ANIM_animdata_get_context(C, &ac) == 0)
 332                 return OPERATOR_CANCELLED;
 333
 334         /* paste keyframes */
 335         if (ac.datatype == ANIMCONT_GPENCIL) {
 336                 // FIXME...
 337         }
 338         else {
 339                 if (paste_action_keys(&ac)) {
 340                         BKE_report(op->reports, RPT_ERROR, "No keyframes to paste");
 341                         return OPERATOR_CANCELLED;
 342                 }
 343         }
 344
 345         /* validate keyframes after editing */
 346         ANIM_editkeyframes_refresh(&ac);
 347
 348         /* set notifier that things have changed */
 349         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
 350
 351         return OPERATOR_FINISHED;
 352 }
 353
 354 void ACT_OT_keyframes_paste (wmOperatorType *ot)
 355 {
 356         /* identifiers */
 357         ot->name= "Paste Keyframes";
 358         ot->idname= "ACT_OT_keyframes_paste";
 359
 360         /* api callbacks */
 361         ot->exec= actkeys_paste_exec;
 362         ot->poll= ED_operator_areaactive;
 363
 364         /* flags */
 365         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 366 }
 367
 368 /* ******************** Insert Keyframes Operator ************************* */
 369
 370 /* defines for insert keyframes tool */
 371 EnumPropertyItem prop_actkeys_insertkey_types[] = {
 372         {1, "ALL", "All Channels", ""},
 373         {2, "SEL", "Only Selected Channels", ""},
 374         {3, "GROUP", "In Active Group", ""}, // xxx not in all cases
 375         {0, NULL, NULL, NULL}
 376 };
 377
 378 /* this function is responsible for snapping keyframes to frame-times */
 379 static void insert_action_keys(bAnimContext *ac, short mode)
 380 {
 381         ListBase anim_data = {NULL, NULL};
 382         bAnimListElem *ale;
 383         int filter;
 384
 385         Scene *scene= ac->scene;
 386         float cfra= (float)CFRA;
 387         short flag = 0;
 388
 389         /* filter data */
 390         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
 391         if (mode == 2)                  filter |= ANIMFILTER_SEL;
 392         else if (mode == 3)     filter |= ANIMFILTER_ACTGROUPED;
 393
 394         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 395
 396         /* init keyframing flag */
 397         if (IS_AUTOKEY_FLAG(AUTOMATKEY)) flag |= INSERTKEY_MATRIX;
 398         if (IS_AUTOKEY_FLAG(INSERTNEEDED)) flag |= INSERTKEY_NEEDED;
 399         // if (IS_AUTOKEY_MODE(EDITKEYS)) flag |= INSERTKEY_REPLACE;
 400
 401         /* insert keyframes */
 402         for (ale= anim_data.first; ale; ale= ale->next) {
 403                 //Object *nob= ANIM_nla_mapping_get(ac, ale);
 404                 FCurve *fcu= (FCurve *)ale->key_data;
 405
 406                 /* adjust current frame for NLA-scaling */
 407                 //if (nob)
 408                 //      cfra= get_action_frame(nob, CFRA);
 409                 //else
 410                 //      cfra= (float)CFRA;
 411
 412                 /* if there's an id */
 413                 if (ale->id)
 414                         insert_keyframe(ale->id, NULL, ((fcu->grp)?(fcu->grp->name):(NULL)), fcu->rna_path, fcu->array_index, cfra, flag);
 415                 else
 416                         insert_vert_fcurve(fcu, cfra, fcu->curval, 0);
 417         }
 418
 419         BLI_freelistN(&anim_data);
 420 }
 421
 422 /* ------------------- */
 423
 424 static int actkeys_insertkey_exec(bContext *C, wmOperator *op)
 425 {
 426         bAnimContext ac;
 427         short mode;
 428
 429         /* get editor data */
 430         if (ANIM_animdata_get_context(C, &ac) == 0)
 431                 return OPERATOR_CANCELLED;
 432         if (ac.datatype == ANIMCONT_GPENCIL)
 433                 return OPERATOR_CANCELLED;
 434
 435         /* get snapping mode */
 436         mode= RNA_enum_get(op->ptr, "type");
 437
 438         /* snap keyframes */
 439         insert_action_keys(&ac, mode);
 440
 441         /* validate keyframes after editing */
 442         ANIM_editkeyframes_refresh(&ac);
 443
 444         /* set notifier that things have changed */
 445         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
 446
 447         return OPERATOR_FINISHED;
 448 }
 449
 450 void ACT_OT_keyframes_insert (wmOperatorType *ot)
 451 {
 452         /* identifiers */
 453         ot->name= "Insert Keyframes";
 454         ot->idname= "ACT_OT_keyframes_insert";
 455
 456         /* api callbacks */
 457         ot->invoke= WM_menu_invoke;
 458         ot->exec= actkeys_insertkey_exec;
 459         ot->poll= ED_operator_areaactive;
 460
 461         /* flags */
 462         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 463
 464         /* id-props */
 465         RNA_def_enum(ot->srna, "type", prop_actkeys_insertkey_types, 0, "Type", "");
 466 }
 467
 468 /* ******************** Duplicate Keyframes Operator ************************* */
 469
 470 static void duplicate_action_keys (bAnimContext *ac)
 471 {
 472         ListBase anim_data = {NULL, NULL};
 473         bAnimListElem *ale;
 474         int filter;
 475
 476         /* filter data */
 477         if (ac->datatype == ANIMCONT_GPENCIL)
 478                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT);
 479         else
 480                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
 481         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 482
 483         /* loop through filtered data and delete selected keys */
 484         for (ale= anim_data.first; ale; ale= ale->next) {
 485                 //if (ale->type == ANIMTYPE_GPLAYER)
 486                 //      delete_gplayer_frames((bGPDlayer *)ale->data);
 487                 //else
 488                         duplicate_fcurve_keys((FCurve *)ale->key_data);
 489         }
 490
 491         /* free filtered list */
 492         BLI_freelistN(&anim_data);
 493 }
 494
 495 /* ------------------- */
 496
 497 static int actkeys_duplicate_exec(bContext *C, wmOperator *op)
 498 {
 499         bAnimContext ac;
 500
 501         /* get editor data */
 502         if (ANIM_animdata_get_context(C, &ac) == 0)
 503                 return OPERATOR_CANCELLED;
 504
 505         /* duplicate keyframes */
 506         duplicate_action_keys(&ac);
 507
 508         /* validate keyframes after editing */
 509         ANIM_editkeyframes_refresh(&ac);
 510
 511         /* set notifier that things have changed */
 512         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
 513
 514         return OPERATOR_FINISHED; // xxx - start transform
 515 }
 516
 517 static int actkeys_duplicate_invoke(bContext *C, wmOperator *op, wmEvent *event)
 518 {
 519         actkeys_duplicate_exec(C, op);
 520
 521         RNA_int_set(op->ptr, "mode", TFM_TIME_TRANSLATE);
 522         WM_operator_name_call(C, "TFM_OT_transform", WM_OP_INVOKE_REGION_WIN, op->ptr);
 523
 524         return OPERATOR_FINISHED;
 525 }
 526
 527 void ACT_OT_keyframes_duplicate (wmOperatorType *ot)
 528 {
 529         /* identifiers */
 530         ot->name= "Duplicate Keyframes";
 531         ot->idname= "ACT_OT_keyframes_duplicate";
 532
 533         /* api callbacks */
 534         ot->invoke= actkeys_duplicate_invoke;
 535         ot->exec= actkeys_duplicate_exec;
 536         ot->poll= ED_operator_areaactive;
 537
 538         /* flags */
 539         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 540
 541         /* to give to transform */
 542         RNA_def_int(ot->srna, "mode", TFM_TIME_TRANSLATE, 0, INT_MAX, "Mode", "", 0, INT_MAX);
 543 }
 544
 545 /* ******************** Delete Keyframes Operator ************************* */
 546
 547 static void delete_action_keys (bAnimContext *ac)
 548 {
 549         ListBase anim_data = {NULL, NULL};
 550         bAnimListElem *ale;
 551         int filter;
 552
 553         /* filter data */
 554         if (ac->datatype == ANIMCONT_GPENCIL)
 555                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT);
 556         else
 557                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
 558         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 559
 560         /* loop through filtered data and delete selected keys */
 561         for (ale= anim_data.first; ale; ale= ale->next) {
 562                 //if (ale->type == ANIMTYPE_GPLAYER)
 563                 //      delete_gplayer_frames((bGPDlayer *)ale->data);
 564                 //else
 565                         delete_fcurve_keys((FCurve *)ale->key_data); // XXX... this doesn't delete empty curves anymore
 566         }
 567
 568         /* free filtered list */
 569         BLI_freelistN(&anim_data);
 570 }
 571
 572 /* ------------------- */
 573
 574 static int actkeys_delete_exec(bContext *C, wmOperator *op)
 575 {
 576         bAnimContext ac;
 577
 578         /* get editor data */
 579         if (ANIM_animdata_get_context(C, &ac) == 0)
 580                 return OPERATOR_CANCELLED;
 581
 582         /* delete keyframes */
 583         delete_action_keys(&ac);
 584
 585         /* validate keyframes after editing */
 586         ANIM_editkeyframes_refresh(&ac);
 587
 588         /* set notifier that things have changed */
 589         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
 590
 591         return OPERATOR_FINISHED;
 592 }
 593
 594 void ACT_OT_keyframes_delete (wmOperatorType *ot)
 595 {
 596         /* identifiers */
 597         ot->name= "Delete Keyframes";
 598         ot->idname= "ACT_OT_keyframes_delete";
 599
 600         /* api callbacks */
 601         ot->invoke= WM_operator_confirm;
 602         ot->exec= actkeys_delete_exec;
 603         ot->poll= ED_operator_areaactive;
 604
 605         /* flags */
 606         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 607 }
 608
 609 /* ******************** Clean Keyframes Operator ************************* */
 610
 611 static void clean_action_keys (bAnimContext *ac, float thresh)
 612 {
 613         ListBase anim_data = {NULL, NULL};
 614         bAnimListElem *ale;
 615         int filter;
 616
 617         /* filter data */
 618         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_SEL | ANIMFILTER_CURVESONLY);
 619         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 620
 621         /* loop through filtered data and clean curves */
 622         for (ale= anim_data.first; ale; ale= ale->next)
 623                 clean_fcurve((FCurve *)ale->key_data, thresh);
 624
 625         /* free temp data */
 626         BLI_freelistN(&anim_data);
 627 }
 628
 629 /* ------------------- */
 630
 631 static int actkeys_clean_exec(bContext *C, wmOperator *op)
 632 {
 633         bAnimContext ac;
 634         float thresh;
 635
 636         /* get editor data */
 637         if (ANIM_animdata_get_context(C, &ac) == 0)
 638                 return OPERATOR_CANCELLED;
 639         if (ac.datatype == ANIMCONT_GPENCIL)
 640                 return OPERATOR_PASS_THROUGH;
 641
 642         /* get cleaning threshold */
 643         thresh= RNA_float_get(op->ptr, "threshold");
 644
 645         /* clean keyframes */
 646         clean_action_keys(&ac, thresh);
 647
 648         /* validate keyframes after editing */
 649         ANIM_editkeyframes_refresh(&ac);
 650
 651         /* set notifier that things have changed */
 652         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
 653
 654         return OPERATOR_FINISHED;
 655 }
 656
 657 void ACT_OT_keyframes_clean (wmOperatorType *ot)
 658 {
 659         /* identifiers */
 660         ot->name= "Clean Keyframes";
 661         ot->idname= "ACT_OT_keyframes_clean";
 662
 663         /* api callbacks */
 664         //ot->invoke=  // XXX we need that number popup for this!
 665         ot->exec= actkeys_clean_exec;
 666         ot->poll= ED_operator_areaactive;
 667
 668         /* flags */
 669         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 670
 671         /* properties */
 672         RNA_def_float(ot->srna, "threshold", 0.001f, 0.0f, FLT_MAX, "Threshold", "", 0.0f, 1000.0f);
 673 }
 674
 675 /* ******************** Sample Keyframes Operator *********************** */
 676
 677 /* little cache for values... */
 678 typedef struct tempFrameValCache {
 679         float frame, val;
 680 } tempFrameValCache;
 681
 682 /* Evaluates the curves between each selected keyframe on each frame, and keys the value  */
 683 static void sample_action_keys (bAnimContext *ac)
 684 {
 685         ListBase anim_data = {NULL, NULL};
 686         bAnimListElem *ale;
 687         int filter;
 688
 689         /* filter data */
 690         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
 691         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 692
 693         /* loop through filtered data and add keys between selected keyframes on every frame  */
 694         for (ale= anim_data.first; ale; ale= ale->next) {
 695                 FCurve *fcu= (FCurve *)ale->key_data;
 696                 BezTriple *bezt, *start=NULL, *end=NULL;
 697                 tempFrameValCache *value_cache, *fp;
 698                 int sfra, range;
 699                 int i, n;
 700
 701                 /* find selected keyframes... once pair has been found, add keyframes  */
 702                 for (i=0, bezt=fcu->bezt; i < fcu->totvert; i++, bezt++) {
 703                         /* check if selected, and which end this is */
 704                         if (BEZSELECTED(bezt)) {
 705                                 if (start) {
 706                                         /* set end */
 707                                         end= bezt;
 708
 709                                         /* cache values then add keyframes using these values, as adding
 710                                          * keyframes while sampling will affect the outcome...
 711                                          */
 712                                         range= (int)( ceil(end->vec[1][0] - start->vec[1][0]) );
 713                                         sfra= (int)( floor(start->vec[1][0]) );
 714
 715                                         if (range) {
 716                                                 value_cache= MEM_callocN(sizeof(tempFrameValCache)*range, "IcuFrameValCache");
 717
 718                                                 /*      sample values   */
 719                                                 for (n=0, fp=value_cache; n<range && fp; n++, fp++) {
 720                                                         fp->frame= (float)(sfra + n);
 721                                                         fp->val= evaluate_fcurve(fcu, fp->frame);
 722                                                 }
 723
 724                                                 /*      add keyframes with these        */
 725                                                 for (n=0, fp=value_cache; n<range && fp; n++, fp++) {
 726                                                         insert_vert_fcurve(fcu, fp->frame, fp->val, 1);
 727                                                 }
 728
 729                                                 /* free temp cache */
 730                                                 MEM_freeN(value_cache);
 731
 732                                                 /* as we added keyframes, we need to compensate so that bezt is at the right place */
 733                                                 bezt = fcu->bezt + i + range - 1;
 734                                                 i += (range - 1);
 735                                         }
 736
 737                                         /* bezt was selected, so it now marks the start of a whole new chain to search */
 738                                         start= bezt;
 739                                         end= NULL;
 740                                 }
 741                                 else {
 742                                         /* just set start keyframe */
 743                                         start= bezt;
 744                                         end= NULL;
 745                                 }
 746                         }
 747                 }
 748
 749                 /* recalculate channel's handles? */
 750                 calchandles_fcurve(fcu);
 751         }
 752
 753         /* admin and redraws */
 754         BLI_freelistN(&anim_data);
 755 }
 756
 757 /* ------------------- */
 758
 759 static int actkeys_sample_exec(bContext *C, wmOperator *op)
 760 {
 761         bAnimContext ac;
 762
 763         /* get editor data */
 764         if (ANIM_animdata_get_context(C, &ac) == 0)
 765                 return OPERATOR_CANCELLED;
 766         if (ac.datatype == ANIMCONT_GPENCIL)
 767                 return OPERATOR_PASS_THROUGH;
 768
 769         /* sample keyframes */
 770         sample_action_keys(&ac);
 771
 772         /* validate keyframes after editing */
 773         ANIM_editkeyframes_refresh(&ac);
 774
 775         /* set notifier that things have changed */
 776         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
 777
 778         return OPERATOR_FINISHED;
 779 }
 780
 781 void ACT_OT_keyframes_sample (wmOperatorType *ot)
 782 {
 783         /* identifiers */
 784         ot->name= "Sample Keyframes";
 785         ot->idname= "ACT_OT_keyframes_sample";
 786
 787         /* api callbacks */
 788         ot->exec= actkeys_sample_exec;
 789         ot->poll= ED_operator_areaactive;
 790
 791         /* flags */
 792         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 793 }
 794
 795 /* ************************************************************************** */
 796 /* SETTINGS STUFF */
 797
 798 /* ******************** Set Extrapolation-Type Operator *********************** */
 799
 800 /* defines for set extrapolation-type for selected keyframes tool */
 801 EnumPropertyItem prop_actkeys_expo_types[] = {
 802         {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", "Constant Extrapolation", ""},
 803         {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", "Linear Extrapolation", ""},
 804         {0, NULL, NULL, NULL}
 805 };
 806
 807 /* this function is responsible for setting extrapolation mode for keyframes */
 808 static void setexpo_action_keys(bAnimContext *ac, short mode)
 809 {
 810         ListBase anim_data = {NULL, NULL};
 811         bAnimListElem *ale;
 812         int filter;
 813
 814         /* filter data */
 815         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
 816         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 817
 818         /* loop through setting mode per F-Curve */
 819         for (ale= anim_data.first; ale; ale= ale->next) {
 820                 FCurve *fcu= (FCurve *)ale->data;
 821                 fcu->extend= mode;
 822         }
 823
 824         /* cleanup */
 825         BLI_freelistN(&anim_data);
 826 }
 827
 828 /* ------------------- */
 829
 830 static int actkeys_expo_exec(bContext *C, wmOperator *op)
 831 {
 832         bAnimContext ac;
 833         short mode;
 834
 835         /* get editor data */
 836         if (ANIM_animdata_get_context(C, &ac) == 0)
 837                 return OPERATOR_CANCELLED;
 838         if (ac.datatype == ANIMCONT_GPENCIL)
 839                 return OPERATOR_PASS_THROUGH;
 840
 841         /* get handle setting mode */
 842         mode= RNA_enum_get(op->ptr, "type");
 843
 844         /* set handle type */
 845         setexpo_action_keys(&ac, mode);
 846
 847         /* validate keyframes after editing */
 848         ANIM_editkeyframes_refresh(&ac);
 849
 850         /* set notifier that things have changed */
 851         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
 852
 853         return OPERATOR_FINISHED;
 854 }
 855
 856 void ACT_OT_keyframes_extrapolation_type_set (wmOperatorType *ot)
 857 {
 858         /* identifiers */
 859         ot->name= "Set Keyframe Extrapolation";
 860         ot->idname= "ACT_OT_keyframes_extrapolation_type_set";
 861
 862         /* api callbacks */
 863         ot->invoke= WM_menu_invoke;
 864         ot->exec= actkeys_expo_exec;
 865         ot->poll= ED_operator_areaactive;
 866
 867         /* flags */
 868         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 869
 870         /* id-props */
 871         RNA_def_enum(ot->srna, "type", prop_actkeys_expo_types, 0, "Type", "");
 872 }
 873
 874 /* ******************** Set Interpolation-Type Operator *********************** */
 875
 876 /* this function is responsible for setting interpolation mode for keyframes */
 877 static void setipo_action_keys(bAnimContext *ac, short mode)
 878 {
 879         ListBase anim_data = {NULL, NULL};
 880         bAnimListElem *ale;
 881         int filter;
 882         BeztEditFunc set_cb= ANIM_editkeyframes_ipo(mode);
 883
 884         /* filter data */
 885         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
 886         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 887
 888         /* loop through setting BezTriple interpolation
 889          * Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
 890          */
 891         for (ale= anim_data.first; ale; ale= ale->next)
 892                 ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
 893
 894         /* cleanup */
 895         BLI_freelistN(&anim_data);
 896 }
 897
 898 /* ------------------- */
 899
 900 static int actkeys_ipo_exec(bContext *C, wmOperator *op)
 901 {
 902         bAnimContext ac;
 903         short mode;
 904
 905         /* get editor data */
 906         if (ANIM_animdata_get_context(C, &ac) == 0)
 907                 return OPERATOR_CANCELLED;
 908         if (ac.datatype == ANIMCONT_GPENCIL)
 909                 return OPERATOR_PASS_THROUGH;
 910
 911         /* get handle setting mode */
 912         mode= RNA_enum_get(op->ptr, "type");
 913
 914         /* set handle type */
 915         setipo_action_keys(&ac, mode);
 916
 917         /* validate keyframes after editing */
 918         ANIM_editkeyframes_refresh(&ac);
 919
 920         /* set notifier that things have changed */
 921         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
 922
 923         return OPERATOR_FINISHED;
 924 }
 925
 926 void ACT_OT_keyframes_interpolation_type (wmOperatorType *ot)
 927 {
 928         /* identifiers */
 929         ot->name= "Set Keyframe Interpolation";
 930         ot->idname= "ACT_OT_keyframes_interpolation_type";
 931
 932         /* api callbacks */
 933         ot->invoke= WM_menu_invoke;
 934         ot->exec= actkeys_ipo_exec;
 935         ot->poll= ED_operator_areaactive;
 936
 937         /* flags */
 938         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 939
 940         /* id-props */
 941         RNA_def_enum(ot->srna, "type", beztriple_interpolation_mode_items, 0, "Type", "");
 942 }
 943
 944 /* ******************** Set Handle-Type Operator *********************** */
 945
 946 /* this function is responsible for setting handle-type of selected keyframes */
 947 static void sethandles_action_keys(bAnimContext *ac, short mode)
 948 {
 949         ListBase anim_data = {NULL, NULL};
 950         bAnimListElem *ale;
 951         int filter;
 952         BeztEditFunc set_cb= ANIM_editkeyframes_handles(mode);
 953
 954         /* filter data */
 955         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
 956         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 957
 958         /* loop through setting flags for handles
 959          * Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
 960          */
 961         for (ale= anim_data.first; ale; ale= ale->next) {
 962                 if (mode == -1) {
 963                         BeztEditFunc toggle_cb;
 964
 965                         /* check which type of handle to set (free or aligned)
 966                          *      - check here checks for handles with free alignment already
 967                          */
 968                         if (ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, NULL))
 969                                 toggle_cb= ANIM_editkeyframes_handles(HD_FREE);
 970                         else
 971                                 toggle_cb= ANIM_editkeyframes_handles(HD_ALIGN);
 972
 973                         /* set handle-type */
 974                         ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, toggle_cb, calchandles_fcurve);
 975                 }
 976                 else {
 977                         /* directly set handle-type */
 978                         ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
 979                 }
 980         }
 981
 982         /* cleanup */
 983         BLI_freelistN(&anim_data);
 984 }
 985
 986 /* ------------------- */
 987
 988 static int actkeys_handletype_exec(bContext *C, wmOperator *op)
 989 {
 990         bAnimContext ac;
 991         short mode;
 992
 993         /* get editor data */
 994         if (ANIM_animdata_get_context(C, &ac) == 0)
 995                 return OPERATOR_CANCELLED;
 996         if (ac.datatype == ANIMCONT_GPENCIL)
 997                 return OPERATOR_PASS_THROUGH;
 998
 999         /* get handle setting mode */
1000         mode= RNA_enum_get(op->ptr, "type");
1001
1002         /* set handle type */
1003         sethandles_action_keys(&ac, mode);
1004
1005         /* validate keyframes after editing */
1006         ANIM_editkeyframes_refresh(&ac);
1007
1008         /* set notifier that things have changed */
1009         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1010
1011         return OPERATOR_FINISHED;
1012 }
1013
1014 void ACT_OT_keyframes_handle_type_set (wmOperatorType *ot)
1015 {
1016         /* identifiers */
1017         ot->name= "Set Keyframe Handle Type";
1018         ot->idname= "ACT_OT_keyframes_handle_type_set";
1019
1020         /* api callbacks */
1021         ot->invoke= WM_menu_invoke;
1022         ot->exec= actkeys_handletype_exec;
1023         ot->poll= ED_operator_areaactive;
1024
1025         /* flags */
1026         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1027
1028         /* id-props */
1029         RNA_def_enum(ot->srna, "type", beztriple_handle_type_items, 0, "Type", "");
1030 }
1031
1032 /* ************************************************************************** */
1033 /* TRANSFORM STUFF */
1034
1035 /* ***************** Snap Current Frame Operator *********************** */
1036
1037 /* snap current-frame indicator to 'average time' of selected keyframe */
1038 static int actkeys_cfrasnap_exec(bContext *C, wmOperator *op)
1039 {
1040         bAnimContext ac;
1041         ListBase anim_data= {NULL, NULL};
1042         bAnimListElem *ale;
1043         int filter;
1044         BeztEditData bed;
1045
1046         /* get editor data */
1047         if (ANIM_animdata_get_context(C, &ac) == 0)
1048                 return OPERATOR_CANCELLED;
1049
1050         /* init edit data */
1051         memset(&bed, 0, sizeof(BeztEditData));
1052
1053         /* loop over action data, averaging values */
1054         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVESONLY);
1055         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1056
1057         for (ale= anim_data.first; ale; ale= ale->next)
1058                 ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, bezt_calc_average, NULL);
1059
1060         BLI_freelistN(&anim_data);
1061
1062         /* set the new current frame value, based on the average time */
1063         if (bed.i1) {
1064                 Scene *scene= ac.scene;
1065                 CFRA= (int)floor((bed.f1 / bed.i1) + 0.5f);
1066         }
1067
1068         /* set notifier that things have changed */
1069         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene);
1070
1071         return OPERATOR_FINISHED;
1072 }
1073
1074 void ACT_OT_keyframes_cfrasnap (wmOperatorType *ot)
1075 {
1076         /* identifiers */
1077         ot->name= "Snap Current Frame to Keys";
1078         ot->idname= "ACT_OT_keyframes_cfrasnap";
1079
1080         /* api callbacks */
1081         ot->exec= actkeys_cfrasnap_exec;
1082         ot->poll= ED_operator_areaactive;
1083
1084         /* flags */
1085         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1086 }
1087
1088 /* ******************** Snap Keyframes Operator *********************** */
1089
1090 /* defines for snap keyframes tool */
1091 EnumPropertyItem prop_actkeys_snap_types[] = {
1092         {ACTKEYS_SNAP_CFRA, "CFRA", "Current frame", ""},
1093         {ACTKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", "Nearest Frame", ""}, // XXX as single entry?
1094         {ACTKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", "Nearest Second", ""}, // XXX as single entry?
1095         {ACTKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", "Nearest Marker", ""},
1096         {0, NULL, NULL, NULL}
1097 };
1098
1099 /* this function is responsible for snapping keyframes to frame-times */
1100 static void snap_action_keys(bAnimContext *ac, short mode)
1101 {
1102         ListBase anim_data = {NULL, NULL};
1103         bAnimListElem *ale;
1104         int filter;
1105
1106         BeztEditData bed;
1107         BeztEditFunc edit_cb;
1108
1109         /* filter data */
1110         if (ac->datatype == ANIMCONT_GPENCIL)
1111                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT);
1112         else
1113                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1114         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1115
1116         /* get beztriple editing callbacks */
1117         edit_cb= ANIM_editkeyframes_snap(mode);
1118
1119         memset(&bed, 0, sizeof(BeztEditData));
1120         bed.scene= ac->scene;
1121
1122         /* snap keyframes */
1123         for (ale= anim_data.first; ale; ale= ale->next) {
1124                 Object *nob= ANIM_nla_mapping_get(ac, ale);
1125
1126                 if (nob) {
1127                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 0, 1);
1128                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1129                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 1, 1);
1130                 }
1131                 //else if (ale->type == ACTTYPE_GPLAYER)
1132                 //      snap_gplayer_frames(ale->data, mode);
1133                 else
1134                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1135         }
1136         BLI_freelistN(&anim_data);
1137 }
1138
1139 /* ------------------- */
1140
1141 static int actkeys_snap_exec(bContext *C, wmOperator *op)
1142 {
1143         bAnimContext ac;
1144         short mode;
1145
1146         /* get editor data */
1147         if (ANIM_animdata_get_context(C, &ac) == 0)
1148                 return OPERATOR_CANCELLED;
1149
1150         /* get snapping mode */
1151         mode= RNA_enum_get(op->ptr, "type");
1152
1153         /* snap keyframes */
1154         snap_action_keys(&ac, mode);
1155
1156         /* validate keyframes after editing */
1157         ANIM_editkeyframes_refresh(&ac);
1158
1159         /* set notifier that things have changed */
1160         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1161
1162         return OPERATOR_FINISHED;
1163 }
1164
1165 void ACT_OT_keyframes_snap (wmOperatorType *ot)
1166 {
1167         /* identifiers */
1168         ot->name= "Snap Keys";
1169         ot->idname= "ACT_OT_keyframes_snap";
1170
1171         /* api callbacks */
1172         ot->invoke= WM_menu_invoke;
1173         ot->exec= actkeys_snap_exec;
1174         ot->poll= ED_operator_areaactive;
1175
1176         /* flags */
1177         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1178
1179         /* id-props */
1180         RNA_def_enum(ot->srna, "type", prop_actkeys_snap_types, 0, "Type", "");
1181 }
1182
1183 /* ******************** Mirror Keyframes Operator *********************** */
1184
1185 /* defines for mirror keyframes tool */
1186 EnumPropertyItem prop_actkeys_mirror_types[] = {
1187         {ACTKEYS_MIRROR_CFRA, "CFRA", "Current frame", ""},
1188         {ACTKEYS_MIRROR_YAXIS, "YAXIS", "Vertical Axis", ""},
1189         {ACTKEYS_MIRROR_XAXIS, "XAXIS", "Horizontal Axis", ""},
1190         {ACTKEYS_MIRROR_MARKER, "MARKER", "First Selected Marker", ""},
1191         {0, NULL, NULL, NULL}
1192 };
1193
1194 /* this function is responsible for mirroring keyframes */
1195 static void mirror_action_keys(bAnimContext *ac, short mode)
1196 {
1197         ListBase anim_data = {NULL, NULL};
1198         bAnimListElem *ale;
1199         int filter;
1200
1201         BeztEditData bed;
1202         BeztEditFunc edit_cb;
1203
1204         /* get beztriple editing callbacks */
1205         edit_cb= ANIM_editkeyframes_mirror(mode);
1206
1207         memset(&bed, 0, sizeof(BeztEditData));
1208         bed.scene= ac->scene;
1209
1210         /* for 'first selected marker' mode, need to find first selected marker first! */
1211         // XXX should this be made into a helper func in the API?
1212         if (mode == ACTKEYS_MIRROR_MARKER) {
1213                 Scene *scene= ac->scene;
1214                 TimeMarker *marker= NULL;
1215
1216                 /* find first selected marker */
1217                 for (marker= scene->markers.first; marker; marker=marker->next) {
1218                         if (marker->flag & SELECT) {
1219                                 break;
1220                         }
1221                 }
1222
1223                 /* store marker's time (if available) */
1224                 if (marker)
1225                         bed.f1= (float)marker->frame;
1226                 else
1227                         return;
1228         }
1229
1230         /* filter data */
1231         if (ac->datatype == ANIMCONT_GPENCIL)
1232                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT);
1233         else
1234                 filter= (ANIMFILTER_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1235         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1236
1237         /* mirror keyframes */
1238         for (ale= anim_data.first; ale; ale= ale->next) {
1239                 Object *nob= ANIM_nla_mapping_get(ac, ale);
1240
1241                 if (nob) {
1242                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 0, 1);
1243                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1244                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 1, 1);
1245                 }
1246                 //else if (ale->type == ACTTYPE_GPLAYER)
1247                 //      snap_gplayer_frames(ale->data, mode);
1248                 else
1249                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1250         }
1251         BLI_freelistN(&anim_data);
1252 }
1253
1254 /* ------------------- */
1255
1256 static int actkeys_mirror_exec(bContext *C, wmOperator *op)
1257 {
1258         bAnimContext ac;
1259         short mode;
1260
1261         /* get editor data */
1262         if (ANIM_animdata_get_context(C, &ac) == 0)
1263                 return OPERATOR_CANCELLED;
1264
1265         /* get mirroring mode */
1266         mode= RNA_enum_get(op->ptr, "type");
1267
1268         /* mirror keyframes */
1269         mirror_action_keys(&ac, mode);
1270
1271         /* validate keyframes after editing */
1272         ANIM_editkeyframes_refresh(&ac);
1273
1274         /* set notifier that things have changed */
1275         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1276
1277         return OPERATOR_FINISHED;
1278 }
1279
1280 void ACT_OT_keyframes_mirror (wmOperatorType *ot)
1281 {
1282         /* identifiers */
1283         ot->name= "Mirror Keys";
1284         ot->idname= "ACT_OT_keyframes_mirror";
1285
1286         /* api callbacks */
1287         ot->invoke= WM_menu_invoke;
1288         ot->exec= actkeys_mirror_exec;
1289         ot->poll= ED_operator_areaactive;
1290
1291         /* flags */
1292         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1293
1294         /* id-props */
1295         RNA_def_enum(ot->srna, "type", prop_actkeys_mirror_types, 0, "Type", "");
1296 }
1297
1298 /* ************************************************************************** */