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