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_utildefines.h"
  72
  73 #include "UI_view2d.h"
  74
  75 #include "ED_anim_api.h"
  76 #include "ED_keyframing.h"
  77 #include "ED_keyframes_draw.h"
  78 #include "ED_keyframes_edit.h"
  79 #include "ED_screen.h"
  80 #include "ED_space_api.h"
  81
  82 #include "WM_api.h"
  83 #include "WM_types.h"
  84
  85 #include "graph_intern.h"
  86
  87 #if 0 // XXX code to be sanitied for new system
  88
  89 /* ************************************************************************** */
  90 /* KEYFRAME-RANGE STUFF */
  91
  92 /* *************************** Calculate Range ************************** */
  93
  94 /* Get the min/max keyframes*/
  95 static void get_keyframe_extents (bAnimContext *ac, float *xmin, float *xmax, float *ymin, float *ymax)
  96 {
  97         ListBase anim_data = {NULL, NULL};
  98         bAnimListElem *ale;
  99         int filter;
 100
 101         /* get data to filter, from Dopesheet */
 102         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
 103         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 104
 105         /* set large values to try to override */
 106         if (xmin) *xmin= 999999999.0f;
 107         if (xmax) *xmax= -999999999.0f;
 108         //if (ymin) *ymin= 999999999.0f;
 109         //if (ymax) *ymax= -999999999.0f;
 110
 111                 // XXX
 112         if (ymin) *ymin= -10;
 113         if (ymax) *ymax= 10;
 114
 115         /* check if any channels to set range with */
 116         if (anim_data.first) {
 117                 /* go through channels, finding max extents */
 118                 for (ale= anim_data.first; ale; ale= ale->next) {
 119                         Object *nob= ANIM_nla_mapping_get(ac, ale);
 120                         FCurve *fcu= (FCurve *)ale->key_data;
 121                         float tmin, tmax;
 122
 123                         /* get range and apply necessary scaling before */
 124                         calc_fcurve_range(fcu, &tmin, &tmax);
 125
 126                         if (nob) {
 127                                 tmin= get_action_frame_inv(nob, tmin);
 128                                 tmax= get_action_frame_inv(nob, tmax);
 129                         }
 130
 131                         /* try to set cur using these values, if they're more extreme than previously set values */
 132                         if (xmin) *xmin= MIN2(*xmin, tmin);
 133                         if (xmax) *xmax= MAX2(*xmax, tmax);
 134                 }
 135
 136                 /* free memory */
 137                 BLI_freelistN(&anim_data);
 138         }
 139         else {
 140                 /* set default range */
 141                 if (ac->scene) {
 142                         if (xmin) *xmin= (float)ac->scene->r.sfra;
 143                         if (xmax) *xmax= (float)ac->scene->r.efra;
 144                 }
 145                 else {
 146                         if (xmin) *xmin= -5;
 147                         if (xmax) *xmax= 100;
 148                 }
 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_keyframe_extents(&ac, &min, &max);
 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_keyframe_extents(&ac, &v2d->cur.xmin, &v2d->cur.xmax, &v2d->cur.ymin, &v2d->cur.ymax);
 209
 210         extra= 0.05f * (v2d->cur.xmax - v2d->cur.xmin);
 211         v2d->cur.xmin -= extra;
 212         v2d->cur.xmax += extra;
 213
 214         extra= 0.05f * (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 /* GENERAL STUFF */
 243
 244 // TODO:
 245 //      - insert key
 246
 247 /* ******************** Copy/Paste Keyframes Operator ************************* */
 248 /* - The copy/paste buffer currently stores a set of Action Channels, with temporary
 249  *      IPO-blocks, and also temporary IpoCurves which only contain the selected keyframes.
 250  * - Only pastes between compatable data is possible (i.e. same achan->name, ipo-curve type, etc.)
 251  *      Unless there is only one element in the buffer, names are also tested to check for compatability.
 252  * - All pasted frames are offset by the same amount. This is calculated as the difference in the times of
 253  *      the current frame and the 'first keyframe' (i.e. the earliest one in all channels).
 254  * - The earliest frame is calculated per copy operation.
 255  */
 256
 257 #if 0
 258 /* globals for copy/paste data (like for other copy/paste buffers) */
 259 ListBase actcopybuf = {NULL, NULL};
 260 static float actcopy_firstframe= 999999999.0f;
 261
 262 /* This function frees any MEM_calloc'ed copy/paste buffer data */
 263 // XXX find some header to put this in!
 264 void free_actcopybuf ()
 265 {
 266         FCurve *fcu, *fcn;
 267
 268         /* free_fcurve() frees F-Curve memory too, but we don't need to do remlink first, as we're freeing all
 269          * channels anyway, and the freeing func only cares about the data it's given
 270          */
 271         for (fcu= actcopybuf.first; fcu; fcu= fcn) {
 272                 fcn= fcu->next;
 273                 free_fcurve(fcu);
 274         }
 275
 276         actcopybuf.first= actcopybuf.last= NULL;
 277         actcopy_firstframe= 999999999.0f;
 278 }
 279 #endif
 280
 281 /* ------------------- */
 282
 283 /* This function adds data to the copy/paste buffer, freeing existing data first
 284  * Only the selected action channels gets their selected keyframes copied.
 285  */
 286 static short copy_graph_keys (bAnimContext *ac)
 287 {
 288 #if 0 // XXX old animation system
 289         ListBase anim_data = {NULL, NULL};
 290         bAnimListElem *ale;
 291         int filter;
 292
 293         /* clear buffer first */
 294         free_actcopybuf();
 295
 296         /* filter data */
 297         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_SEL | ANIMFILTER_IPOKEYS);
 298         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 299
 300         /* assume that each of these is an ipo-block */
 301         for (ale= anim_data.first; ale; ale= ale->next) {
 302                 bActionChannel *achan;
 303                 Ipo *ipo= ale->key_data;
 304                 Ipo *ipn;
 305                 IpoCurve *icu, *icn;
 306                 BezTriple *bezt;
 307                 int i;
 308
 309                 /* coerce an action-channel out of owner */
 310                 if (ale->ownertype == ANIMTYPE_ACHAN) {
 311                         bActionChannel *achanO= ale->owner;
 312                         achan= MEM_callocN(sizeof(bActionChannel), "ActCopyPasteAchan");
 313                         strcpy(achan->name, achanO->name);
 314                 }
 315                 else if (ale->ownertype == ANIMTYPE_SHAPEKEY) {
 316                         achan= MEM_callocN(sizeof(bActionChannel), "ActCopyPasteAchan");
 317                         strcpy(achan->name, "#ACP_ShapeKey");
 318                 }
 319                 else
 320                         continue;
 321                 BLI_addtail(&actcopybuf, achan);
 322
 323                 /* add constraint channel if needed, then add new ipo-block */
 324                 if (ale->type == ANIMTYPE_CONCHAN) {
 325                         bConstraintChannel *conchanO= ale->data;
 326                         bConstraintChannel *conchan;
 327
 328                         conchan= MEM_callocN(sizeof(bConstraintChannel), "ActCopyPasteConchan");
 329                         strcpy(conchan->name, conchanO->name);
 330                         BLI_addtail(&achan->constraintChannels, conchan);
 331
 332                         conchan->ipo= ipn= MEM_callocN(sizeof(Ipo), "ActCopyPasteIpo");
 333                 }
 334                 else {
 335                         achan->ipo= ipn= MEM_callocN(sizeof(Ipo), "ActCopyPasteIpo");
 336                 }
 337                 ipn->blocktype = ipo->blocktype;
 338
 339                 /* now loop through curves, and only copy selected keyframes */
 340                 for (icu= ipo->curve.first; icu; icu= icu->next) {
 341                         /* allocate a new curve */
 342                         icn= MEM_callocN(sizeof(IpoCurve), "ActCopyPasteIcu");
 343                         icn->blocktype = icu->blocktype;
 344                         icn->adrcode = icu->adrcode;
 345                         BLI_addtail(&ipn->curve, icn);
 346
 347                         /* find selected BezTriples to add to the buffer (and set first frame) */
 348                         for (i=0, bezt=icu->bezt; i < icu->totvert; i++, bezt++) {
 349                                 if (BEZSELECTED(bezt)) {
 350                                         /* add to buffer ipo-curve */
 351                                         //insert_bezt_icu(icn, bezt); // XXX
 352
 353                                         /* check if this is the earliest frame encountered so far */
 354                                         if (bezt->vec[1][0] < actcopy_firstframe)
 355                                                 actcopy_firstframe= bezt->vec[1][0];
 356                                 }
 357                         }
 358                 }
 359         }
 360
 361         /* check if anything ended up in the buffer */
 362         if (ELEM(NULL, actcopybuf.first, actcopybuf.last))
 363         //      error("Nothing copied to buffer");
 364                 return -1;
 365
 366         /* free temp memory */
 367         BLI_freelistN(&anim_data);
 368 #endif // XXX old animation system
 369
 370         /* everything went fine */
 371         return 0;
 372 }
 373
 374 static short paste_graph_keys (bAnimContext *ac)
 375 {
 376 #if 0 // XXX old animation system
 377         ListBase anim_data = {NULL, NULL};
 378         bAnimListElem *ale;
 379         int filter;
 380
 381         const Scene *scene= (ac->scene);
 382         const float offset = (float)(CFRA - actcopy_firstframe);
 383         char *actname = NULL, *conname = NULL;
 384         short no_name= 0;
 385
 386         /* check if buffer is empty */
 387         if (ELEM(NULL, actcopybuf.first, actcopybuf.last)) {
 388                 //error("No data in buffer to paste");
 389                 return -1;
 390         }
 391         /* check if single channel in buffer (disregard names if so)  */
 392         if (actcopybuf.first == actcopybuf.last)
 393                 no_name= 1;
 394
 395         /* filter data */
 396         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_IPOKEYS);
 397         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 398
 399         /* from selected channels */
 400         for (ale= anim_data.first; ale; ale= ale->next) {
 401                 Ipo *ipo_src = NULL;
 402                 bActionChannel *achan;
 403                 IpoCurve *ico, *icu;
 404                 BezTriple *bezt;
 405                 int i;
 406
 407                 /* find suitable IPO-block from buffer to paste from */
 408                 for (achan= actcopybuf.first; achan; achan= achan->next) {
 409                         /* try to match data */
 410                         if (ale->ownertype == ANIMTYPE_ACHAN) {
 411                                 bActionChannel *achant= ale->owner;
 412
 413                                 /* check if we have a corresponding action channel */
 414                                 if ((no_name) || (strcmp(achan->name, achant->name)==0)) {
 415                                         actname= achant->name;
 416
 417                                         /* check if this is a constraint channel */
 418                                         if (ale->type == ANIMTYPE_CONCHAN) {
 419                                                 bConstraintChannel *conchant= ale->data;
 420                                                 bConstraintChannel *conchan;
 421
 422                                                 for (conchan=achan->constraintChannels.first; conchan; conchan=conchan->next) {
 423                                                         if (strcmp(conchan->name, conchant->name)==0) {
 424                                                                 conname= conchant->name;
 425                                                                 ipo_src= conchan->ipo;
 426                                                                 break;
 427                                                         }
 428                                                 }
 429                                                 if (ipo_src) break;
 430                                         }
 431                                         else {
 432                                                 ipo_src= achan->ipo;
 433                                                 break;
 434                                         }
 435                                 }
 436                         }
 437                         else if (ale->ownertype == ANIMTYPE_SHAPEKEY) {
 438                                 /* check if this action channel is "#ACP_ShapeKey" */
 439                                 if ((no_name) || (strcmp(achan->name, "#ACP_ShapeKey")==0)) {
 440                                         actname= NULL;
 441                                         ipo_src= achan->ipo;
 442                                         break;
 443                                 }
 444                         }
 445                 }
 446
 447                 /* this shouldn't happen, but it might */
 448                 if (ipo_src == NULL)
 449                         continue;
 450
 451                 /* loop over curves, pasting keyframes */
 452                 for (ico= ipo_src->curve.first; ico; ico= ico->next) {
 453                         /* get IPO-curve to paste to (IPO-curve might not exist for destination, so gets created) */
 454                         //icu= verify_ipocurve(ale->id, ico->blocktype, actname, conname, NULL, ico->adrcode, 1);
 455
 456
 457                         if (icu) {
 458                                 /* just start pasting, with the the first keyframe on the current frame, and so on */
 459                                 for (i=0, bezt=ico->bezt; i < ico->totvert; i++, bezt++) {
 460                                         /* temporarily apply offset to src beztriple while copying */
 461                                         bezt->vec[0][0] += offset;
 462                                         bezt->vec[1][0] += offset;
 463                                         bezt->vec[2][0] += offset;
 464
 465                                         /* insert the keyframe */
 466                                         //insert_bezt_icu(icu, bezt); // XXX
 467
 468                                         /* un-apply offset from src beztriple after copying */
 469                                         bezt->vec[0][0] -= offset;
 470                                         bezt->vec[1][0] -= offset;
 471                                         bezt->vec[2][0] -= offset;
 472                                 }
 473
 474                                 /* recalculate channel's handles? */
 475                                 //calchandles_fcurve(fcu);
 476                         }
 477                 }
 478         }
 479
 480         /* free temp memory */
 481         BLI_freelistN(&anim_data);
 482 #endif // XXX old animation system
 483
 484         return 0;
 485 }
 486
 487 /* ------------------- */
 488
 489 static int graphkeys_copy_exec(bContext *C, wmOperator *op)
 490 {
 491         bAnimContext ac;
 492
 493         /* get editor data */
 494         if (ANIM_animdata_get_context(C, &ac) == 0)
 495                 return OPERATOR_CANCELLED;
 496
 497         /* copy keyframes */
 498         if (copy_graph_keys(&ac)) {
 499                 // XXX errors - need a way to inform the user
 500                 printf("Action Copy: No keyframes copied to copy-paste buffer\n");
 501         }
 502
 503         /* set notifier tha things have changed */
 504         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
 505
 506         return OPERATOR_FINISHED;
 507 }
 508
 509 void GRAPHEDIT_OT_keyframes_copy (wmOperatorType *ot)
 510 {
 511         /* identifiers */
 512         ot->name= "Copy Keyframes";
 513         ot->idname= "GRAPHEDIT_OT_keyframes_copy";
 514
 515         /* api callbacks */
 516         ot->exec= graphkeys_copy_exec;
 517         ot->poll= ED_operator_areaactive;
 518
 519         /* flags */
 520         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 521 }
 522
 523
 524
 525 static int graphkeys_paste_exec(bContext *C, wmOperator *op)
 526 {
 527         bAnimContext ac;
 528
 529         /* get editor data */
 530         if (ANIM_animdata_get_context(C, &ac) == 0)
 531                 return OPERATOR_CANCELLED;
 532
 533         /* paste keyframes */
 534         if (paste_graph_keys(&ac)) {
 535                 // XXX errors - need a way to inform the user
 536                 printf("Action Paste: Nothing to paste, as Copy-Paste buffer was empty.\n");
 537         }
 538
 539         /* validate keyframes after editing */
 540         ANIM_editkeyframes_refresh(&ac);
 541
 542         /* set notifier tha things have changed */
 543         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
 544
 545         return OPERATOR_FINISHED;
 546 }
 547
 548 void GRAPHEDIT_OT_keyframes_paste (wmOperatorType *ot)
 549 {
 550         /* identifiers */
 551         ot->name= "Paste Keyframes";
 552         ot->idname= "GRAPHEDIT_OT_keyframes_paste";
 553
 554         /* api callbacks */
 555         ot->exec= graphkeys_paste_exec;
 556         ot->poll= ED_operator_areaactive;
 557
 558         /* flags */
 559         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 560 }
 561
 562 #endif // XXX code to be sanitied for new system
 563
 564 /* ******************** Delete Keyframes Operator ************************* */
 565
 566 static void delete_graph_keys (bAnimContext *ac)
 567 {
 568         ListBase anim_data = {NULL, NULL};
 569         bAnimListElem *ale;
 570         int filter;
 571
 572         /* filter data */
 573         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
 574         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 575
 576         /* loop through filtered data and delete selected keys */
 577         for (ale= anim_data.first; ale; ale= ale->next) {
 578                 delete_fcurve_keys((FCurve *)ale->key_data); // XXX... this doesn't delete empty curves anymore
 579         }
 580
 581         /* free filtered list */
 582         BLI_freelistN(&anim_data);
 583 }
 584
 585 /* ------------------- */
 586
 587 static int graphkeys_delete_exec(bContext *C, wmOperator *op)
 588 {
 589         bAnimContext ac;
 590
 591         /* get editor data */
 592         if (ANIM_animdata_get_context(C, &ac) == 0)
 593                 return OPERATOR_CANCELLED;
 594
 595         /* delete keyframes */
 596         delete_graph_keys(&ac);
 597
 598         /* validate keyframes after editing */
 599         ANIM_editkeyframes_refresh(&ac);
 600
 601         /* set notifier tha things have changed */
 602         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
 603
 604         return OPERATOR_FINISHED;
 605 }
 606
 607 void GRAPHEDIT_OT_keyframes_delete (wmOperatorType *ot)
 608 {
 609         /* identifiers */
 610         ot->name= "Delete Keyframes";
 611         ot->idname= "GRAPHEDIT_OT_keyframes_delete";
 612
 613         /* api callbacks */
 614         ot->invoke= WM_operator_confirm;
 615         ot->exec= graphkeys_delete_exec;
 616         ot->poll= ED_operator_areaactive;
 617
 618         /* flags */
 619         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 620 }
 621
 622 /* ******************** Clean Keyframes Operator ************************* */
 623
 624 static void clean_graph_keys (bAnimContext *ac, float thresh)
 625 {
 626         ListBase anim_data = {NULL, NULL};
 627         bAnimListElem *ale;
 628         int filter;
 629
 630         /* filter data */
 631         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_SEL | ANIMFILTER_CURVESONLY);
 632         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 633
 634         /* loop through filtered data and clean curves */
 635         for (ale= anim_data.first; ale; ale= ale->next)
 636                 clean_fcurve((FCurve *)ale->key_data, thresh);
 637
 638         /* free temp data */
 639         BLI_freelistN(&anim_data);
 640 }
 641
 642 /* ------------------- */
 643
 644 static int graphkeys_clean_exec(bContext *C, wmOperator *op)
 645 {
 646         bAnimContext ac;
 647         float thresh;
 648
 649         /* get editor data */
 650         if (ANIM_animdata_get_context(C, &ac) == 0)
 651                 return OPERATOR_CANCELLED;
 652
 653         /* get cleaning threshold */
 654         thresh= RNA_float_get(op->ptr, "threshold");
 655
 656         /* clean keyframes */
 657         clean_graph_keys(&ac, thresh);
 658
 659         /* validate keyframes after editing */
 660         ANIM_editkeyframes_refresh(&ac);
 661
 662         /* set notifier tha things have changed */
 663         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
 664
 665         return OPERATOR_FINISHED;
 666 }
 667
 668 void GRAPHEDIT_OT_keyframes_clean (wmOperatorType *ot)
 669 {
 670         /* identifiers */
 671         ot->name= "Clean Keyframes";
 672         ot->idname= "GRAPHEDIT_OT_keyframes_clean";
 673
 674         /* api callbacks */
 675         //ot->invoke=  // XXX we need that number popup for this!
 676         ot->exec= graphkeys_clean_exec;
 677         ot->poll= ED_operator_areaactive;
 678
 679         /* flags */
 680         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 681
 682         /* properties */
 683         RNA_def_float(ot->srna, "threshold", 0.001f, 0.0f, FLT_MAX, "Threshold", "", 0.0f, 1000.0f);
 684 }
 685
 686 /* ******************** Sample Keyframes Operator *********************** */
 687
 688 // XXX some of the common parts (with DopeSheet) should be unified in animation module...
 689
 690 /* little cache for values... */
 691 typedef struct tempFrameValCache {
 692         float frame, val;
 693 } tempFrameValCache;
 694
 695 /* Evaluates the curves between each selected keyframe on each frame, and keys the value  */
 696 static void sample_graph_keys (bAnimContext *ac)
 697 {
 698         ListBase anim_data = {NULL, NULL};
 699         bAnimListElem *ale;
 700         int filter;
 701
 702         /* filter data */
 703         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
 704         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 705
 706         /* loop through filtered data and add keys between selected keyframes on every frame  */
 707         for (ale= anim_data.first; ale; ale= ale->next) {
 708                 FCurve *fcu= (FCurve *)ale->key_data;
 709                 BezTriple *bezt, *start=NULL, *end=NULL;
 710                 tempFrameValCache *value_cache, *fp;
 711                 int sfra, range;
 712                 int i, n;
 713
 714                 /* find selected keyframes... once pair has been found, add keyframes  */
 715                 for (i=0, bezt=fcu->bezt; i < fcu->totvert; i++, bezt++) {
 716                         /* check if selected, and which end this is */
 717                         if (BEZSELECTED(bezt)) {
 718                                 if (start) {
 719                                         /* set end */
 720                                         end= bezt;
 721
 722                                         /* cache values then add keyframes using these values, as adding
 723                                          * keyframes while sampling will affect the outcome...
 724                                          */
 725                                         range= (int)( ceil(end->vec[1][0] - start->vec[1][0]) );
 726                                         sfra= (int)( floor(start->vec[1][0]) );
 727
 728                                         if (range) {
 729                                                 value_cache= MEM_callocN(sizeof(tempFrameValCache)*range, "IcuFrameValCache");
 730
 731                                                 /*      sample values   */
 732                                                 for (n=0, fp=value_cache; n<range && fp; n++, fp++) {
 733                                                         fp->frame= (float)(sfra + n);
 734                                                         fp->val= evaluate_fcurve(fcu, fp->frame);
 735                                                 }
 736
 737                                                 /*      add keyframes with these        */
 738                                                 for (n=0, fp=value_cache; n<range && fp; n++, fp++) {
 739                                                         insert_vert_fcurve(fcu, fp->frame, fp->val, 1);
 740                                                 }
 741
 742                                                 /* free temp cache */
 743                                                 MEM_freeN(value_cache);
 744
 745                                                 /* as we added keyframes, we need to compensate so that bezt is at the right place */
 746                                                 bezt = fcu->bezt + i + range - 1;
 747                                                 i += (range - 1);
 748                                         }
 749
 750                                         /* bezt was selected, so it now marks the start of a whole new chain to search */
 751                                         start= bezt;
 752                                         end= NULL;
 753                                 }
 754                                 else {
 755                                         /* just set start keyframe */
 756                                         start= bezt;
 757                                         end= NULL;
 758                                 }
 759                         }
 760                 }
 761
 762                 /* recalculate channel's handles? */
 763                 calchandles_fcurve(fcu);
 764         }
 765
 766         /* admin and redraws */
 767         BLI_freelistN(&anim_data);
 768 }
 769
 770 /* ------------------- */
 771
 772 static int graphkeys_sample_exec(bContext *C, wmOperator *op)
 773 {
 774         bAnimContext ac;
 775
 776         /* get editor data */
 777         if (ANIM_animdata_get_context(C, &ac) == 0)
 778                 return OPERATOR_CANCELLED;
 779
 780         /* sample keyframes */
 781         sample_graph_keys(&ac);
 782
 783         /* validate keyframes after editing */
 784         ANIM_editkeyframes_refresh(&ac);
 785
 786         /* set notifier tha things have changed */
 787         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
 788
 789         return OPERATOR_FINISHED;
 790 }
 791
 792 void GRAPHEDIT_OT_keyframes_sample (wmOperatorType *ot)
 793 {
 794         /* identifiers */
 795         ot->name= "Sample Keyframes";
 796         ot->idname= "GRAPHEDIT_OT_keyframes_sample";
 797
 798         /* api callbacks */
 799         ot->exec= graphkeys_sample_exec;
 800         ot->poll= ED_operator_areaactive;
 801
 802         /* flags */
 803         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 804 }
 805
 806
 807 /* ************************************************************************** */
 808 /* SETTINGS STUFF */
 809
 810 /* ******************** Set Extrapolation-Type Operator *********************** */
 811
 812 /* defines for set extrapolation-type for selected keyframes tool */
 813 EnumPropertyItem prop_graphkeys_expo_types[] = {
 814         {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", "Constant Extrapolation", ""},
 815         {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", "Linear Extrapolation", ""},
 816         {0, NULL, NULL, NULL}
 817 };
 818
 819 /* this function is responsible for setting extrapolation mode for keyframes */
 820 static void setexpo_graph_keys(bAnimContext *ac, short mode)
 821 {
 822         ListBase anim_data = {NULL, NULL};
 823         bAnimListElem *ale;
 824         int filter;
 825
 826         /* filter data */
 827         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
 828         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 829
 830         /* loop through setting mode per F-Curve */
 831         for (ale= anim_data.first; ale; ale= ale->next) {
 832                 FCurve *fcu= (FCurve *)ale->data;
 833                 fcu->extend= mode;
 834         }
 835
 836         /* cleanup */
 837         BLI_freelistN(&anim_data);
 838 }
 839
 840 /* ------------------- */
 841
 842 static int graphkeys_expo_exec(bContext *C, wmOperator *op)
 843 {
 844         bAnimContext ac;
 845         short mode;
 846
 847         /* get editor data */
 848         if (ANIM_animdata_get_context(C, &ac) == 0)
 849                 return OPERATOR_CANCELLED;
 850
 851         /* get handle setting mode */
 852         mode= RNA_enum_get(op->ptr, "type");
 853
 854         /* set handle type */
 855         setexpo_graph_keys(&ac, mode);
 856
 857         /* validate keyframes after editing */
 858         ANIM_editkeyframes_refresh(&ac);
 859
 860         /* set notifier tha things have changed */
 861         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
 862
 863         return OPERATOR_FINISHED;
 864 }
 865
 866 void GRAPHEDIT_OT_keyframes_extrapolation_type (wmOperatorType *ot)
 867 {
 868         /* identifiers */
 869         ot->name= "Set Keyframe Extrapolation";
 870         ot->idname= "GRAPHEDIT_OT_keyframes_extrapolation_type";
 871
 872         /* api callbacks */
 873         ot->invoke= WM_menu_invoke;
 874         ot->exec= graphkeys_expo_exec;
 875         ot->poll= ED_operator_areaactive;
 876
 877         /* flags */
 878         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 879
 880         /* id-props */
 881         RNA_def_enum(ot->srna, "type", prop_graphkeys_expo_types, 0, "Type", "");
 882 }
 883
 884 /* ******************** Set Interpolation-Type Operator *********************** */
 885
 886 /* defines for set ipo-type for selected keyframes tool */
 887 EnumPropertyItem prop_graphkeys_ipo_types[] = {
 888         {BEZT_IPO_CONST, "CONSTANT", "Constant Interpolation", ""},
 889         {BEZT_IPO_LIN, "LINEAR", "Linear Interpolation", ""},
 890         {BEZT_IPO_BEZ, "BEZIER", "Bezier Interpolation", ""},
 891         {0, NULL, NULL, NULL}
 892 };
 893
 894 /* this function is responsible for setting interpolation mode for keyframes */
 895 static void setipo_graph_keys(bAnimContext *ac, short mode)
 896 {
 897         ListBase anim_data = {NULL, NULL};
 898         bAnimListElem *ale;
 899         int filter;
 900         BeztEditFunc set_cb= ANIM_editkeyframes_ipo(mode);
 901
 902         /* filter data */
 903         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
 904         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 905
 906         /* loop through setting BezTriple interpolation
 907          * Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
 908          */
 909         for (ale= anim_data.first; ale; ale= ale->next)
 910                 ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
 911
 912         /* cleanup */
 913         BLI_freelistN(&anim_data);
 914 }
 915
 916 /* ------------------- */
 917
 918 static int graphkeys_ipo_exec(bContext *C, wmOperator *op)
 919 {
 920         bAnimContext ac;
 921         short mode;
 922
 923         /* get editor data */
 924         if (ANIM_animdata_get_context(C, &ac) == 0)
 925                 return OPERATOR_CANCELLED;
 926
 927         /* get handle setting mode */
 928         mode= RNA_enum_get(op->ptr, "type");
 929
 930         /* set handle type */
 931         setipo_graph_keys(&ac, mode);
 932
 933         /* validate keyframes after editing */
 934         ANIM_editkeyframes_refresh(&ac);
 935
 936         /* set notifier tha things have changed */
 937         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
 938
 939         return OPERATOR_FINISHED;
 940 }
 941
 942 void GRAPHEDIT_OT_keyframes_interpolation_type (wmOperatorType *ot)
 943 {
 944         /* identifiers */
 945         ot->name= "Set Keyframe Interpolation";
 946         ot->idname= "GRAPHEDIT_OT_keyframes_interpolation_type";
 947
 948         /* api callbacks */
 949         ot->invoke= WM_menu_invoke;
 950         ot->exec= graphkeys_ipo_exec;
 951         ot->poll= ED_operator_areaactive;
 952
 953         /* flags */
 954         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 955
 956         /* id-props */
 957         RNA_def_enum(ot->srna, "type", prop_graphkeys_ipo_types, 0, "Type", "");
 958 }
 959
 960 /* ******************** Set Handle-Type Operator *********************** */
 961
 962 /* defines for set handle-type for selected keyframes tool */
 963 EnumPropertyItem prop_graphkeys_handletype_types[] = {
 964         {HD_AUTO, "AUTO", "Auto Handles", ""},
 965         {HD_VECT, "VECTOR", "Vector Handles", ""},
 966         {HD_FREE, "FREE", "Free Handles", ""},
 967         {HD_ALIGN, "ALIGN", "Aligned Handles", ""},
 968 //      {-1, "TOGGLE", "Toggle between Free and Aligned Handles", ""},
 969         {0, NULL, NULL, NULL}
 970 };
 971
 972 /* this function is responsible for setting handle-type of selected keyframes */
 973 static void sethandles_graph_keys(bAnimContext *ac, short mode)
 974 {
 975         ListBase anim_data = {NULL, NULL};
 976         bAnimListElem *ale;
 977         int filter;
 978         BeztEditFunc set_cb= ANIM_editkeyframes_handles(mode);
 979
 980         /* filter data */
 981         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
 982         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 983
 984         /* loop through setting flags for handles
 985          * Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
 986          */
 987         // XXX we might need to supply BeztEditData to get it to only affect selected handles
 988         for (ale= anim_data.first; ale; ale= ale->next) {
 989                 if (mode == -1) {
 990                         BeztEditFunc toggle_cb;
 991
 992                         /* check which type of handle to set (free or aligned)
 993                          *      - check here checks for handles with free alignment already
 994                          */
 995                         if (ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, NULL))
 996                                 toggle_cb= ANIM_editkeyframes_handles(HD_FREE);
 997                         else
 998                                 toggle_cb= ANIM_editkeyframes_handles(HD_ALIGN);
 999
1000                         /* set handle-type */
1001                         ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, toggle_cb, calchandles_fcurve);
1002                 }
1003                 else {
1004                         /* directly set handle-type */
1005                         ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
1006                 }
1007         }
1008
1009         /* cleanup */
1010         BLI_freelistN(&anim_data);
1011 }
1012
1013 /* ------------------- */
1014
1015 static int graphkeys_handletype_exec(bContext *C, wmOperator *op)
1016 {
1017         bAnimContext ac;
1018         short mode;
1019
1020         /* get editor data */
1021         if (ANIM_animdata_get_context(C, &ac) == 0)
1022                 return OPERATOR_CANCELLED;
1023
1024         /* get handle setting mode */
1025         mode= RNA_enum_get(op->ptr, "type");
1026
1027         /* set handle type */
1028         sethandles_graph_keys(&ac, mode);
1029
1030         /* validate keyframes after editing */
1031         ANIM_editkeyframes_refresh(&ac);
1032
1033         /* set notifier tha things have changed */
1034         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1035
1036         return OPERATOR_FINISHED;
1037 }
1038
1039 void GRAPHEDIT_OT_keyframes_handletype (wmOperatorType *ot)
1040 {
1041         /* identifiers */
1042         ot->name= "Set Keyframe Handle Type";
1043         ot->idname= "GRAPHEDIT_OT_keyframes_handletype";
1044
1045         /* api callbacks */
1046         ot->invoke= WM_menu_invoke;
1047         ot->exec= graphkeys_handletype_exec;
1048         ot->poll= ED_operator_areaactive;
1049
1050         /* flags */
1051         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1052
1053         /* id-props */
1054         RNA_def_enum(ot->srna, "type", prop_graphkeys_handletype_types, 0, "Type", "");
1055 }
1056
1057 /* ************************************************************************** */
1058 /* TRANSFORM STUFF */
1059
1060 /* ***************** Snap Current Frame Operator *********************** */
1061
1062 /* helper callback for graphkeys_cfrasnap_exec() -> used to help get the average time of all selected beztriples */
1063 // TODO: if some other code somewhere needs this, it'll be time to port this over to keyframes_edit.c!!!
1064 static short bezt_calc_average(BeztEditData *bed, BezTriple *bezt)
1065 {
1066         /* only if selected */
1067         if (bezt->f2 & SELECT) {
1068                 /* store average time in float (only do rounding at last step */
1069                 bed->f1 += bezt->vec[1][0];
1070
1071                 /* increment number of items */
1072                 bed->i1++;
1073         }
1074
1075         return 0;
1076 }
1077
1078 /* snap current-frame indicator to 'average time' of selected keyframe */
1079 static int graphkeys_cfrasnap_exec(bContext *C, wmOperator *op)
1080 {
1081         bAnimContext ac;
1082         ListBase anim_data= {NULL, NULL};
1083         bAnimListElem *ale;
1084         int filter;
1085         BeztEditData bed;
1086
1087         /* get editor data */
1088         if (ANIM_animdata_get_context(C, &ac) == 0)
1089                 return OPERATOR_CANCELLED;
1090
1091         /* init edit data */
1092         memset(&bed, 0, sizeof(BeztEditData));
1093
1094         /* loop over action data, averaging values */
1095         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_CURVESONLY);
1096         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1097
1098         for (ale= anim_data.first; ale; ale= ale->next)
1099                 ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, bezt_calc_average, NULL);
1100
1101         BLI_freelistN(&anim_data);
1102
1103         /* set the new current frame value, based on the average time */
1104         if (bed.i1) {
1105                 Scene *scene= ac.scene;
1106                 CFRA= (int)floor((bed.f1 / bed.i1) + 0.5f);
1107         }
1108
1109         /* set notifier tha things have changed */
1110         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene);
1111
1112         return OPERATOR_FINISHED;
1113 }
1114
1115 void GRAPHEDIT_OT_keyframes_cfrasnap (wmOperatorType *ot)
1116 {
1117         /* identifiers */
1118         ot->name= "Snap Current Frame to Keys";
1119         ot->idname= "GRAPHEDIT_OT_keyframes_cfrasnap";
1120
1121         /* api callbacks */
1122         ot->exec= graphkeys_cfrasnap_exec;
1123         ot->poll= ED_operator_areaactive;
1124
1125         /* flags */
1126         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1127 }
1128
1129 /* ******************** Snap Keyframes Operator *********************** */
1130
1131 /* defines for snap keyframes tool */
1132 EnumPropertyItem prop_graphkeys_snap_types[] = {
1133         {GRAPHKEYS_SNAP_CFRA, "CFRA", "Current frame", ""},
1134         {GRAPHKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", "Nearest Frame", ""}, // XXX as single entry?
1135         {GRAPHKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", "Nearest Second", ""}, // XXX as single entry?
1136         {GRAPHKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", "Nearest Marker", ""},
1137         {GRAPHKEYS_SNAP_HORIZONTAL, "HORIZONTAL", "Flatten Handles", ""},
1138         {0, NULL, NULL, NULL}
1139 };
1140
1141 /* this function is responsible for snapping keyframes to frame-times */
1142 static void snap_graph_keys(bAnimContext *ac, short mode)
1143 {
1144         ListBase anim_data = {NULL, NULL};
1145         bAnimListElem *ale;
1146         int filter;
1147
1148         BeztEditData bed;
1149         BeztEditFunc edit_cb;
1150
1151         /* filter data */
1152         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1153         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1154
1155         /* get beztriple editing callbacks */
1156         edit_cb= ANIM_editkeyframes_snap(mode);
1157
1158         memset(&bed, 0, sizeof(BeztEditData));
1159         bed.scene= ac->scene;
1160
1161         /* snap keyframes */
1162         for (ale= anim_data.first; ale; ale= ale->next) {
1163                 Object *nob= ANIM_nla_mapping_get(ac, ale);
1164
1165                 if (nob) {
1166                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 0, 1);
1167                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1168                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 1, 1);
1169                 }
1170                 else
1171                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1172         }
1173         BLI_freelistN(&anim_data);
1174 }
1175
1176 /* ------------------- */
1177
1178 static int graphkeys_snap_exec(bContext *C, wmOperator *op)
1179 {
1180         bAnimContext ac;
1181         short mode;
1182
1183         /* get editor data */
1184         if (ANIM_animdata_get_context(C, &ac) == 0)
1185                 return OPERATOR_CANCELLED;
1186
1187         /* get snapping mode */
1188         mode= RNA_enum_get(op->ptr, "type");
1189
1190         /* snap keyframes */
1191         snap_graph_keys(&ac, mode);
1192
1193         /* validate keyframes after editing */
1194         ANIM_editkeyframes_refresh(&ac);
1195
1196         /* set notifier tha things have changed */
1197         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1198
1199         return OPERATOR_FINISHED;
1200 }
1201
1202 void GRAPHEDIT_OT_keyframes_snap (wmOperatorType *ot)
1203 {
1204         /* identifiers */
1205         ot->name= "Snap Keys";
1206         ot->idname= "GRAPHEDIT_OT_keyframes_snap";
1207
1208         /* api callbacks */
1209         ot->invoke= WM_menu_invoke;
1210         ot->exec= graphkeys_snap_exec;
1211         ot->poll= ED_operator_areaactive;
1212
1213         /* flags */
1214         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1215
1216         /* id-props */
1217         RNA_def_enum(ot->srna, "type", prop_graphkeys_snap_types, 0, "Type", "");
1218 }
1219
1220 /* ******************** Mirror Keyframes Operator *********************** */
1221
1222 /* defines for mirror keyframes tool */
1223 EnumPropertyItem prop_graphkeys_mirror_types[] = {
1224         {GRAPHKEYS_MIRROR_CFRA, "CFRA", "Current frame", ""},
1225         {GRAPHKEYS_MIRROR_YAXIS, "YAXIS", "Vertical Axis", ""},
1226         {GRAPHKEYS_MIRROR_XAXIS, "XAXIS", "Horizontal Axis", ""},
1227         {GRAPHKEYS_MIRROR_MARKER, "MARKER", "First Selected Marker", ""},
1228         {0, NULL, NULL, NULL}
1229 };
1230
1231 /* this function is responsible for mirroring keyframes */
1232 static void mirror_graph_keys(bAnimContext *ac, short mode)
1233 {
1234         ListBase anim_data = {NULL, NULL};
1235         bAnimListElem *ale;
1236         int filter;
1237
1238         BeztEditData bed;
1239         BeztEditFunc edit_cb;
1240
1241         /* get beztriple editing callbacks */
1242         edit_cb= ANIM_editkeyframes_mirror(mode);
1243
1244         memset(&bed, 0, sizeof(BeztEditData));
1245         bed.scene= ac->scene;
1246
1247         /* for 'first selected marker' mode, need to find first selected marker first! */
1248         // XXX should this be made into a helper func in the API?
1249         if (mode == GRAPHKEYS_MIRROR_MARKER) {
1250                 Scene *scene= ac->scene;
1251                 TimeMarker *marker= NULL;
1252
1253                 /* find first selected marker */
1254                 for (marker= scene->markers.first; marker; marker=marker->next) {
1255                         if (marker->flag & SELECT) {
1256                                 break;
1257                         }
1258                 }
1259
1260                 /* store marker's time (if available) */
1261                 if (marker)
1262                         bed.f1= (float)marker->frame;
1263                 else
1264                         return;
1265         }
1266
1267         /* filter data */
1268         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1269         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1270
1271         /* mirror keyframes */
1272         for (ale= anim_data.first; ale; ale= ale->next) {
1273                 Object *nob= ANIM_nla_mapping_get(ac, ale);
1274
1275                 if (nob) {
1276                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 0, 1);
1277                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1278                         ANIM_nla_mapping_apply_fcurve(nob, ale->key_data, 1, 1);
1279                 }
1280                 else
1281                         ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1282         }
1283         BLI_freelistN(&anim_data);
1284 }
1285
1286 /* ------------------- */
1287
1288 static int graphkeys_mirror_exec(bContext *C, wmOperator *op)
1289 {
1290         bAnimContext ac;
1291         short mode;
1292
1293         /* get editor data */
1294         if (ANIM_animdata_get_context(C, &ac) == 0)
1295                 return OPERATOR_CANCELLED;
1296
1297         /* get mirroring mode */
1298         mode= RNA_enum_get(op->ptr, "type");
1299
1300         /* mirror keyframes */
1301         mirror_graph_keys(&ac, mode);
1302
1303         /* validate keyframes after editing */
1304         ANIM_editkeyframes_refresh(&ac);
1305
1306         /* set notifier tha things have changed */
1307         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1308
1309         return OPERATOR_FINISHED;
1310 }
1311
1312 void GRAPHEDIT_OT_keyframes_mirror (wmOperatorType *ot)
1313 {
1314         /* identifiers */
1315         ot->name= "Mirror Keys";
1316         ot->idname= "GRAPHEDIT_OT_keyframes_mirror";
1317
1318         /* api callbacks */
1319         ot->invoke= WM_menu_invoke;
1320         ot->exec= graphkeys_mirror_exec;
1321         ot->poll= ED_operator_areaactive;
1322
1323         /* flags */
1324         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1325
1326         /* id-props */
1327         RNA_def_enum(ot->srna, "type", prop_graphkeys_mirror_types, 0, "Type", "");
1328 }
1329
1330 /* ******************** Smooth Keyframes Operator *********************** */
1331
1332 static int graphkeys_smooth_exec(bContext *C, wmOperator *op)
1333 {
1334         bAnimContext ac;
1335         ListBase anim_data = {NULL, NULL};
1336         bAnimListElem *ale;
1337         int filter;
1338
1339         /* get editor data */
1340         if (ANIM_animdata_get_context(C, &ac) == 0)
1341                 return OPERATOR_CANCELLED;
1342
1343         /* filter data */
1344         filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
1345         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1346
1347         /* smooth keyframes */
1348         for (ale= anim_data.first; ale; ale= ale->next) {
1349                 /* For now, we can only smooth by flattening handles AND smoothing curve values.
1350                  * Perhaps the mode argument could be removed, as that functionality is offerred through
1351                  * Snap->Flatten Handles anyway.
1352                  */
1353                 smooth_fcurve(ale->key_data);
1354         }
1355         BLI_freelistN(&anim_data);
1356
1357         /* validate keyframes after editing */
1358         ANIM_editkeyframes_refresh(&ac);
1359
1360         /* set notifier tha things have changed */
1361         ANIM_animdata_send_notifiers(C, &ac, ANIM_CHANGED_KEYFRAMES_VALUES);
1362
1363         return OPERATOR_FINISHED;
1364 }
1365
1366 void GRAPHEDIT_OT_keyframes_smooth (wmOperatorType *ot)
1367 {
1368         /* identifiers */
1369         ot->name= "Smooth Keys";
1370         ot->idname= "GRAPHEDIT_OT_keyframes_smooth";
1371
1372         /* api callbacks */
1373         ot->exec= graphkeys_smooth_exec;
1374         ot->poll= ED_operator_areaactive;
1375
1376         /* flags */
1377         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1378 }
1379
1380 /* ************************************************************************** */