source/blender/editors/space_action/action_edit.c

   1 /*
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  *
  20  * The Original Code is Copyright (C) 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 /** \file blender/editors/space_action/action_edit.c
  31  *  \ingroup spaction
  32  */
  33
  34
  35 #include <math.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <float.h>
  39
  40
  41 #include "BLI_blenlib.h"
  42 #include "BLI_math.h"
  43 #include "BLI_utildefines.h"
  44
  45 #include "DNA_anim_types.h"
  46 #include "DNA_gpencil_types.h"
  47 #include "DNA_object_types.h"
  48 #include "DNA_scene_types.h"
  49
  50 #include "RNA_access.h"
  51 #include "RNA_define.h"
  52 #include "RNA_enum_types.h"
  53
  54 #include "BKE_action.h"
  55 #include "BKE_fcurve.h"
  56 #include "BKE_nla.h"
  57 #include "BKE_context.h"
  58 #include "BKE_report.h"
  59
  60 #include "UI_view2d.h"
  61
  62 #include "ED_anim_api.h"
  63 #include "ED_gpencil.h"
  64 #include "ED_keyframing.h"
  65 #include "ED_keyframes_edit.h"
  66 #include "ED_screen.h"
  67 #include "ED_transform.h"
  68 #include "ED_markers.h"
  69
  70 #include "WM_api.h"
  71 #include "WM_types.h"
  72
  73 #include "UI_interface.h"
  74
  75 #include "action_intern.h"
  76
  77 /* ************************************************************************** */
  78 /* ACTION MANAGEMENT */
  79
  80 /* ******************** New Action Operator *********************** */
  81
  82 static int act_new_exec(bContext *C, wmOperator *UNUSED(op))
  83 {
  84         PointerRNA ptr, idptr;
  85         PropertyRNA *prop;
  86
  87         /* hook into UI */
  88         uiIDContextProperty(C, &ptr, &prop);
  89
  90         if (prop) {
  91                 bAction *action=NULL, *oldact=NULL;
  92                 PointerRNA oldptr;
  93
  94                 /* create action - the way to do this depends on whether we've got an
  95                  * existing one there already, in which case we make a copy of it
  96                  * (which is useful for "versioning" actions within the same file)
  97                  */
  98                 oldptr = RNA_property_pointer_get(&ptr, prop);
  99                 oldact = (bAction *)oldptr.id.data;
 100
 101                 if (oldact && GS(oldact->id.name)==ID_AC) {
 102                         /* make a copy of the existing action */
 103                         action= copy_action(oldact);
 104                 }
 105                 else {
 106                         /* just make a new (empty) action */
 107                         action= add_empty_action("Action");
 108                 }
 109
 110                 /* when creating new ID blocks, use is already 1 (fake user),
 111                  * but RNA pointer use also increases user, so this compensates it
 112                  */
 113                 action->id.us--;
 114
 115                 RNA_id_pointer_create(&action->id, &idptr);
 116                 RNA_property_pointer_set(&ptr, prop, idptr);
 117                 RNA_property_update(C, &ptr, prop);
 118         }
 119
 120         /* set notifier that keyframes have changed */
 121         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 122
 123         return OPERATOR_FINISHED;
 124 }
 125
 126 void ACTION_OT_new (wmOperatorType *ot)
 127 {
 128         /* identifiers */
 129         ot->name= "New Action";
 130         ot->idname= "ACTION_OT_new";
 131         ot->description= "Create new action";
 132
 133         /* api callbacks */
 134         ot->exec= act_new_exec;
 135                 // NOTE: this is used in the NLA too...
 136         //ot->poll= ED_operator_action_active;
 137
 138         /* flags */
 139         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 140 }
 141
 142 /* ************************************************************************** */
 143 /* POSE MARKERS STUFF */
 144
 145 /* *************************** Localise Markers ***************************** */
 146
 147 /* ensure that there is:
 148  *      1) an active action editor
 149  *      2) that the mode will have an active action available
 150  *      3) that the set of markers being shown are the scene markers, not the list we're merging
 151  *      4) that there are some selected markers
 152  */
 153 static int act_markers_make_local_poll(bContext *C)
 154 {
 155         SpaceAction *sact = CTX_wm_space_action(C);
 156
 157         /* 1) */
 158         if (sact == NULL)
 159                 return 0;
 160
 161         /* 2) */
 162         if (ELEM(sact->mode, SACTCONT_ACTION, SACTCONT_SHAPEKEY) == 0)
 163                 return 0;
 164         if (sact->action == NULL)
 165                 return 0;
 166
 167         /* 3) */
 168         if (sact->flag & SACTION_POSEMARKERS_SHOW)
 169                 return 0;
 170
 171         /* 4) */
 172         return ED_markers_get_first_selected(ED_context_get_markers(C)) != NULL;
 173 }
 174
 175 static int act_markers_make_local_exec (bContext *C, wmOperator *UNUSED(op))
 176 {
 177         ListBase *markers = ED_context_get_markers(C);
 178
 179         SpaceAction *sact = CTX_wm_space_action(C);
 180         bAction *act = (sact)? sact->action : NULL;
 181
 182         TimeMarker *marker, *markern=NULL;
 183
 184         /* sanity checks */
 185         if (ELEM(NULL, markers, act))
 186                 return OPERATOR_CANCELLED;
 187
 188         /* migrate markers */
 189         for (marker = markers->first; marker; marker = markern) {
 190                 markern = marker->next;
 191
 192                 /* move if marker is selected */
 193                 if (marker->flag & SELECT) {
 194                         BLI_remlink(markers, marker);
 195                         BLI_addtail(&act->markers, marker);
 196                 }
 197         }
 198
 199         /* now enable the "show posemarkers only" setting, so that we can see that something did happen */
 200         sact->flag |= SACTION_POSEMARKERS_SHOW;
 201
 202         /* notifiers - both sets, as this change affects both */
 203         WM_event_add_notifier(C, NC_SCENE|ND_MARKERS, NULL);
 204         WM_event_add_notifier(C, NC_ANIMATION|ND_MARKERS, NULL);
 205
 206         return OPERATOR_FINISHED;
 207 }
 208
 209 void ACTION_OT_markers_make_local (wmOperatorType *ot)
 210 {
 211         /* identifiers */
 212         ot->name= "Make Markers Local";
 213         ot->idname= "ACTION_OT_markers_make_local";
 214         ot->description= "Move selected scene markers to the active Action as local 'pose' markers";
 215
 216         /* callbacks */
 217         ot->exec = act_markers_make_local_exec;
 218         ot->poll = act_markers_make_local_poll;
 219
 220         /* flags */
 221         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 222 }
 223
 224 /* ************************************************************************** */
 225 /* KEYFRAME-RANGE STUFF */
 226
 227 /* *************************** Calculate Range ************************** */
 228
 229 /* Get the min/max keyframes*/
 230 static void get_keyframe_extents (bAnimContext *ac, float *min, float *max, const short onlySel)
 231 {
 232         ListBase anim_data = {NULL, NULL};
 233         bAnimListElem *ale;
 234         int filter;
 235
 236         /* get data to filter, from Action or Dopesheet */
 237         // XXX: what is sel doing here?!
 238         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_SEL /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
 239         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 240
 241         /* set large values to try to override */
 242         *min= 999999999.0f;
 243         *max= -999999999.0f;
 244
 245         /* check if any channels to set range with */
 246         if (anim_data.first) {
 247                 /* go through channels, finding max extents */
 248                 for (ale= anim_data.first; ale; ale= ale->next) {
 249                         AnimData *adt= ANIM_nla_mapping_get(ac, ale);
 250                         FCurve *fcu= (FCurve *)ale->key_data;
 251                         float tmin, tmax;
 252
 253                         /* get range and apply necessary scaling before processing */
 254                         calc_fcurve_range(fcu, &tmin, &tmax, onlySel);
 255
 256                         if (adt) {
 257                                 tmin= BKE_nla_tweakedit_remap(adt, tmin, NLATIME_CONVERT_MAP);
 258                                 tmax= BKE_nla_tweakedit_remap(adt, tmax, NLATIME_CONVERT_MAP);
 259                         }
 260
 261                         /* try to set cur using these values, if they're more extreme than previously set values */
 262                         *min= MIN2(*min, tmin);
 263                         *max= MAX2(*max, tmax);
 264                 }
 265
 266                 /* free memory */
 267                 BLI_freelistN(&anim_data);
 268         }
 269         else {
 270                 /* set default range */
 271                 if (ac->scene) {
 272                         *min= (float)ac->scene->r.sfra;
 273                         *max= (float)ac->scene->r.efra;
 274                 }
 275                 else {
 276                         *min= -5;
 277                         *max= 100;
 278                 }
 279         }
 280 }
 281
 282 /* ****************** Automatic Preview-Range Operator ****************** */
 283
 284 static int actkeys_previewrange_exec(bContext *C, wmOperator *UNUSED(op))
 285 {
 286         bAnimContext ac;
 287         Scene *scene;
 288         float min, max;
 289
 290         /* get editor data */
 291         if (ANIM_animdata_get_context(C, &ac) == 0)
 292                 return OPERATOR_CANCELLED;
 293         if (ac.scene == NULL)
 294                 return OPERATOR_CANCELLED;
 295         else
 296                 scene= ac.scene;
 297
 298         /* set the range directly */
 299         get_keyframe_extents(&ac, &min, &max, FALSE);
 300         scene->r.flag |= SCER_PRV_RANGE;
 301         scene->r.psfra= (int)floor(min + 0.5f);
 302         scene->r.pefra= (int)floor(max + 0.5f);
 303
 304         /* set notifier that things have changed */
 305         // XXX err... there's nothing for frame ranges yet, but this should do fine too
 306         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene);
 307
 308         return OPERATOR_FINISHED;
 309 }
 310
 311 void ACTION_OT_previewrange_set (wmOperatorType *ot)
 312 {
 313         /* identifiers */
 314         ot->name= "Auto-Set Preview Range";
 315         ot->idname= "ACTION_OT_previewrange_set";
 316         ot->description= "Set Preview Range based on extents of selected Keyframes";
 317
 318         /* api callbacks */
 319         ot->exec= actkeys_previewrange_exec;
 320         ot->poll= ED_operator_action_active;
 321
 322         /* flags */
 323         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 324 }
 325
 326 /* ****************** View-All Operator ****************** */
 327
 328 static int actkeys_viewall(bContext *C, const short onlySel)
 329 {
 330         bAnimContext ac;
 331         View2D *v2d;
 332         float extra;
 333
 334         /* get editor data */
 335         if (ANIM_animdata_get_context(C, &ac) == 0)
 336                 return OPERATOR_CANCELLED;
 337         v2d= &ac.ar->v2d;
 338
 339         /* set the horizontal range, with an extra offset so that the extreme keys will be in view */
 340         get_keyframe_extents(&ac, &v2d->cur.xmin, &v2d->cur.xmax, onlySel);
 341
 342         extra= 0.1f * (v2d->cur.xmax - v2d->cur.xmin);
 343         v2d->cur.xmin -= extra;
 344         v2d->cur.xmax += extra;
 345
 346         /* set vertical range */
 347         v2d->cur.ymax= 0.0f;
 348         v2d->cur.ymin= (float)-(v2d->mask.ymax - v2d->mask.ymin);
 349
 350         /* do View2D syncing */
 351         UI_view2d_sync(CTX_wm_screen(C), CTX_wm_area(C), v2d, V2D_LOCK_COPY);
 352
 353         /* just redraw this view */
 354         ED_area_tag_redraw(CTX_wm_area(C));
 355
 356         return OPERATOR_FINISHED;
 357 }
 358
 359 /* ......... */
 360
 361 static int actkeys_viewall_exec(bContext *C, wmOperator *UNUSED(op))
 362 {
 363         /* whole range */
 364         return actkeys_viewall(C, FALSE);
 365 }
 366
 367 static int actkeys_viewsel_exec(bContext *C, wmOperator *UNUSED(op))
 368 {
 369         /* only selected */
 370         return actkeys_viewall(C, TRUE);
 371 }
 372
 373 void ACTION_OT_view_all (wmOperatorType *ot)
 374 {
 375         /* identifiers */
 376         ot->name= "View All";
 377         ot->idname= "ACTION_OT_view_all";
 378         ot->description= "Reset viewable area to show full keyframe range";
 379
 380         /* api callbacks */
 381         ot->exec= actkeys_viewall_exec;
 382         ot->poll= ED_operator_action_active;
 383
 384         /* flags */
 385         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 386 }
 387
 388 void ACTION_OT_view_selected (wmOperatorType *ot)
 389 {
 390         /* identifiers */
 391         ot->name= "View Selected";
 392         ot->idname= "ACTION_OT_view_selected";
 393         ot->description= "Reset viewable area to show selected keyframes range";
 394
 395         /* api callbacks */
 396         ot->exec= actkeys_viewsel_exec;
 397         ot->poll= ED_operator_action_active;
 398
 399         /* flags */
 400         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 401 }
 402
 403 /* ************************************************************************** */
 404 /* GENERAL STUFF */
 405
 406 /* ******************** Copy/Paste Keyframes Operator ************************* */
 407 /* NOTE: the backend code for this is shared with the graph editor */
 408
 409 static short copy_action_keys (bAnimContext *ac)
 410 {
 411         ListBase anim_data = {NULL, NULL};
 412         int filter, ok=0;
 413
 414         /* clear buffer first */
 415         free_anim_copybuf();
 416
 417         /* filter data */
 418         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
 419         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 420
 421         /* copy keyframes */
 422         ok= copy_animedit_keys(ac, &anim_data);
 423
 424         /* clean up */
 425         BLI_freelistN(&anim_data);
 426
 427         return ok;
 428 }
 429
 430
 431 static short paste_action_keys (bAnimContext *ac,
 432         const eKeyPasteOffset offset_mode, const eKeyMergeMode merge_mode)
 433 {
 434         ListBase anim_data = {NULL, NULL};
 435         int filter, ok=0;
 436
 437         /* filter data */
 438         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
 439         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 440
 441         /* paste keyframes */
 442         ok= paste_animedit_keys(ac, &anim_data, offset_mode, merge_mode);
 443
 444         /* clean up */
 445         BLI_freelistN(&anim_data);
 446
 447         return ok;
 448 }
 449
 450 /* ------------------- */
 451
 452 static int actkeys_copy_exec(bContext *C, wmOperator *op)
 453 {
 454         bAnimContext ac;
 455
 456         /* get editor data */
 457         if (ANIM_animdata_get_context(C, &ac) == 0)
 458                 return OPERATOR_CANCELLED;
 459
 460         /* copy keyframes */
 461         if (ac.datatype == ANIMCONT_GPENCIL) {
 462                 // FIXME...
 463         }
 464         else {
 465                 if (copy_action_keys(&ac)) {
 466                         BKE_report(op->reports, RPT_ERROR, "No keyframes copied to keyframes copy/paste buffer");
 467                         return OPERATOR_CANCELLED;
 468                 }
 469         }
 470
 471         return OPERATOR_FINISHED;
 472 }
 473
 474 void ACTION_OT_copy (wmOperatorType *ot)
 475 {
 476         /* identifiers */
 477         ot->name= "Copy Keyframes";
 478         ot->idname= "ACTION_OT_copy";
 479         ot->description= "Copy selected keyframes to the copy/paste buffer";
 480
 481         /* api callbacks */
 482 //      ot->invoke= WM_operator_props_popup; // better wait for graph redo panel
 483         ot->exec= actkeys_copy_exec;
 484         ot->poll= ED_operator_action_active;
 485
 486         /* flags */
 487         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 488 }
 489
 490 static int actkeys_paste_exec(bContext *C, wmOperator *op)
 491 {
 492         bAnimContext ac;
 493
 494         const eKeyPasteOffset offset_mode= RNA_enum_get(op->ptr, "offset");
 495         const eKeyMergeMode merge_mode= RNA_enum_get(op->ptr, "merge");
 496
 497         /* get editor data */
 498         if (ANIM_animdata_get_context(C, &ac) == 0)
 499                 return OPERATOR_CANCELLED;
 500
 501         if(ac.reports==NULL) {
 502                 ac.reports= op->reports;
 503         }
 504
 505         /* paste keyframes */
 506         if (ac.datatype == ANIMCONT_GPENCIL) {
 507                 // FIXME...
 508         }
 509         else {
 510                 if (paste_action_keys(&ac, offset_mode, merge_mode)) {
 511                         BKE_report(op->reports, RPT_ERROR, "No keyframes to paste");
 512                         return OPERATOR_CANCELLED;
 513                 }
 514         }
 515
 516         /* validate keyframes after editing */
 517         ANIM_editkeyframes_refresh(&ac);
 518
 519         /* set notifier that keyframes have changed */
 520         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 521
 522         return OPERATOR_FINISHED;
 523 }
 524
 525 void ACTION_OT_paste (wmOperatorType *ot)
 526 {
 527         /* identifiers */
 528         ot->name= "Paste Keyframes";
 529         ot->idname= "ACTION_OT_paste";
 530         ot->description= "Paste keyframes from copy/paste buffer for the selected channels, starting on the current frame";
 531
 532         /* api callbacks */
 533         ot->exec= actkeys_paste_exec;
 534         ot->poll= ED_operator_action_active;
 535
 536         /* flags */
 537         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 538
 539         RNA_def_enum(ot->srna, "offset", keyframe_paste_offset_items, KEYFRAME_PASTE_OFFSET_CFRA_START, "Offset", "Paste time offset of keys");
 540         RNA_def_enum(ot->srna, "merge", keyframe_paste_merge_items, KEYFRAME_PASTE_MERGE_MIX, "Type", "Method of merking pasted keys and existing");
 541 }
 542
 543 /* ******************** Insert Keyframes Operator ************************* */
 544
 545 /* defines for insert keyframes tool */
 546 static EnumPropertyItem prop_actkeys_insertkey_types[] = {
 547         {1, "ALL", 0, "All Channels", ""},
 548         {2, "SEL", 0, "Only Selected Channels", ""},
 549         {3, "GROUP", 0, "In Active Group", ""}, // xxx not in all cases
 550         {0, NULL, 0, NULL, NULL}
 551 };
 552
 553 /* this function is responsible for snapping keyframes to frame-times */
 554 static void insert_action_keys(bAnimContext *ac, short mode)
 555 {
 556         ListBase anim_data = {NULL, NULL};
 557         bAnimListElem *ale;
 558         int filter;
 559
 560         ReportList *reports = ac->reports;
 561         Scene *scene= ac->scene;
 562         short flag = 0;
 563
 564         /* filter data */
 565         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
 566         if (mode == 2)                  filter |= ANIMFILTER_SEL;
 567         else if (mode == 3)     filter |= ANIMFILTER_ACTGROUPED;
 568
 569         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 570
 571         /* init keyframing flag */
 572         flag = ANIM_get_keyframing_flags(scene, 1);
 573
 574         /* insert keyframes */
 575         for (ale= anim_data.first; ale; ale= ale->next) {
 576                 AnimData *adt= ANIM_nla_mapping_get(ac, ale);
 577                 FCurve *fcu= (FCurve *)ale->key_data;
 578                 float cfra;
 579
 580                 /* adjust current frame for NLA-scaling */
 581                 if (adt)
 582                         cfra= BKE_nla_tweakedit_remap(adt, (float)CFRA, NLATIME_CONVERT_UNMAP);
 583                 else
 584                         cfra= (float)CFRA;
 585
 586                 /* if there's an id */
 587                 if (ale->id)
 588                         insert_keyframe(reports, ale->id, NULL, ((fcu->grp)?(fcu->grp->name):(NULL)), fcu->rna_path, fcu->array_index, cfra, flag);
 589                 else
 590                         insert_vert_fcurve(fcu, cfra, fcu->curval, 0);
 591         }
 592
 593         BLI_freelistN(&anim_data);
 594 }
 595
 596 /* ------------------- */
 597
 598 static int actkeys_insertkey_exec(bContext *C, wmOperator *op)
 599 {
 600         bAnimContext ac;
 601         short mode;
 602
 603         /* get editor data */
 604         if (ANIM_animdata_get_context(C, &ac) == 0)
 605                 return OPERATOR_CANCELLED;
 606         if (ac.datatype == ANIMCONT_GPENCIL)
 607                 return OPERATOR_CANCELLED;
 608
 609         /* what channels to affect? */
 610         mode= RNA_enum_get(op->ptr, "type");
 611
 612         /* insert keyframes */
 613         insert_action_keys(&ac, mode);
 614
 615         /* validate keyframes after editing */
 616         ANIM_editkeyframes_refresh(&ac);
 617
 618         /* set notifier that keyframes have changed */
 619         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 620
 621         return OPERATOR_FINISHED;
 622 }
 623
 624 void ACTION_OT_keyframe_insert (wmOperatorType *ot)
 625 {
 626         /* identifiers */
 627         ot->name= "Insert Keyframes";
 628         ot->idname= "ACTION_OT_keyframe_insert";
 629         ot->description= "Insert keyframes for the specified channels";
 630
 631         /* api callbacks */
 632         ot->invoke= WM_menu_invoke;
 633         ot->exec= actkeys_insertkey_exec;
 634         ot->poll= ED_operator_action_active;
 635
 636         /* flags */
 637         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 638
 639         /* id-props */
 640         ot->prop= RNA_def_enum(ot->srna, "type", prop_actkeys_insertkey_types, 0, "Type", "");
 641 }
 642
 643 /* ******************** Duplicate Keyframes Operator ************************* */
 644
 645 static void duplicate_action_keys (bAnimContext *ac)
 646 {
 647         ListBase anim_data = {NULL, NULL};
 648         bAnimListElem *ale;
 649         int filter;
 650
 651         /* filter data */
 652         if (ac->datatype == ANIMCONT_GPENCIL)
 653                 filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
 654         else
 655                 filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
 656         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 657
 658         /* loop through filtered data and delete selected keys */
 659         for (ale= anim_data.first; ale; ale= ale->next) {
 660                 if (ale->type == ANIMTYPE_FCURVE)
 661                         duplicate_fcurve_keys((FCurve *)ale->key_data);
 662                 else
 663                         duplicate_gplayer_frames((bGPDlayer *)ale->data);
 664         }
 665
 666         /* free filtered list */
 667         BLI_freelistN(&anim_data);
 668 }
 669
 670 /* ------------------- */
 671
 672 static int actkeys_duplicate_exec(bContext *C, wmOperator *UNUSED(op))
 673 {
 674         bAnimContext ac;
 675
 676         /* get editor data */
 677         if (ANIM_animdata_get_context(C, &ac) == 0)
 678                 return OPERATOR_CANCELLED;
 679
 680         /* duplicate keyframes */
 681         duplicate_action_keys(&ac);
 682
 683         /* validate keyframes after editing */
 684         ANIM_editkeyframes_refresh(&ac);
 685
 686         /* set notifier that keyframes have changed */
 687         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 688
 689         return OPERATOR_FINISHED; // xxx - start transform
 690 }
 691
 692 static int actkeys_duplicate_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
 693 {
 694         actkeys_duplicate_exec(C, op);
 695
 696         return OPERATOR_FINISHED;
 697 }
 698
 699 void ACTION_OT_duplicate (wmOperatorType *ot)
 700 {
 701         /* identifiers */
 702         ot->name= "Duplicate Keyframes";
 703         ot->idname= "ACTION_OT_duplicate";
 704         ot->description= "Make a copy of all selected keyframes";
 705
 706         /* api callbacks */
 707         ot->invoke= actkeys_duplicate_invoke;
 708         ot->exec= actkeys_duplicate_exec;
 709         ot->poll= ED_operator_action_active;
 710
 711         /* flags */
 712         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 713
 714         /* to give to transform */
 715         RNA_def_enum(ot->srna, "mode", transform_mode_types, TFM_TRANSLATION, "Mode", "");
 716 }
 717
 718 /* ******************** Delete Keyframes Operator ************************* */
 719
 720 static void delete_action_keys (bAnimContext *ac)
 721 {
 722         ListBase anim_data = {NULL, NULL};
 723         bAnimListElem *ale;
 724         int filter;
 725
 726         /* filter data */
 727         if (ac->datatype == ANIMCONT_GPENCIL)
 728                 filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
 729         else
 730                 filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
 731         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 732
 733         /* loop through filtered data and delete selected keys */
 734         for (ale= anim_data.first; ale; ale= ale->next) {
 735                 if (ale->type != ANIMTYPE_GPLAYER) {
 736                         FCurve *fcu= (FCurve *)ale->key_data;
 737                         AnimData *adt= ale->adt;
 738
 739                         /* delete selected keyframes only */
 740                         delete_fcurve_keys(fcu);
 741
 742                         /* Only delete curve too if it won't be doing anything anymore */
 743                         if ((fcu->totvert == 0) && (list_has_suitable_fmodifier(&fcu->modifiers, 0, FMI_TYPE_GENERATE_CURVE) == 0))
 744                                 ANIM_fcurve_delete_from_animdata(ac, adt, fcu);
 745                 }
 746                 else
 747                         delete_gplayer_frames((bGPDlayer *)ale->data);
 748         }
 749
 750         /* free filtered list */
 751         BLI_freelistN(&anim_data);
 752 }
 753
 754 /* ------------------- */
 755
 756 static int actkeys_delete_exec(bContext *C, wmOperator *UNUSED(op))
 757 {
 758         bAnimContext ac;
 759
 760         /* get editor data */
 761         if (ANIM_animdata_get_context(C, &ac) == 0)
 762                 return OPERATOR_CANCELLED;
 763
 764         /* delete keyframes */
 765         delete_action_keys(&ac);
 766
 767         /* validate keyframes after editing */
 768         ANIM_editkeyframes_refresh(&ac);
 769
 770         /* set notifier that keyframes have changed */
 771         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 772
 773         return OPERATOR_FINISHED;
 774 }
 775
 776 void ACTION_OT_delete (wmOperatorType *ot)
 777 {
 778         /* identifiers */
 779         ot->name= "Delete Keyframes";
 780         ot->idname= "ACTION_OT_delete";
 781         ot->description= "Remove all selected keyframes";
 782
 783         /* api callbacks */
 784         ot->invoke= WM_operator_confirm;
 785         ot->exec= actkeys_delete_exec;
 786         ot->poll= ED_operator_action_active;
 787
 788         /* flags */
 789         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 790 }
 791
 792 /* ******************** Clean Keyframes Operator ************************* */
 793
 794 static void clean_action_keys (bAnimContext *ac, float thresh)
 795 {
 796         ListBase anim_data = {NULL, NULL};
 797         bAnimListElem *ale;
 798         int filter;
 799
 800         /* filter data */
 801         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_SEL /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
 802         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 803
 804         /* loop through filtered data and clean curves */
 805         for (ale= anim_data.first; ale; ale= ale->next)
 806                 clean_fcurve((FCurve *)ale->key_data, thresh);
 807
 808         /* free temp data */
 809         BLI_freelistN(&anim_data);
 810 }
 811
 812 /* ------------------- */
 813
 814 static int actkeys_clean_exec(bContext *C, wmOperator *op)
 815 {
 816         bAnimContext ac;
 817         float thresh;
 818
 819         /* get editor data */
 820         if (ANIM_animdata_get_context(C, &ac) == 0)
 821                 return OPERATOR_CANCELLED;
 822         if (ac.datatype == ANIMCONT_GPENCIL)
 823                 return OPERATOR_PASS_THROUGH;
 824
 825         /* get cleaning threshold */
 826         thresh= RNA_float_get(op->ptr, "threshold");
 827
 828         /* clean keyframes */
 829         clean_action_keys(&ac, thresh);
 830
 831         /* validate keyframes after editing */
 832         ANIM_editkeyframes_refresh(&ac);
 833
 834         /* set notifier that keyframes have changed */
 835         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 836
 837         return OPERATOR_FINISHED;
 838 }
 839
 840 void ACTION_OT_clean (wmOperatorType *ot)
 841 {
 842         /* identifiers */
 843         ot->name= "Clean Keyframes";
 844         ot->idname= "ACTION_OT_clean";
 845         ot->description= "Simplify F-Curves by removing closely spaced keyframes";
 846
 847         /* api callbacks */
 848         //ot->invoke=  // XXX we need that number popup for this!
 849         ot->exec= actkeys_clean_exec;
 850         ot->poll= ED_operator_action_active;
 851
 852         /* flags */
 853         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 854
 855         /* properties */
 856         ot->prop= RNA_def_float(ot->srna, "threshold", 0.001f, 0.0f, FLT_MAX, "Threshold", "", 0.0f, 1000.0f);
 857 }
 858
 859 /* ******************** Sample Keyframes Operator *********************** */
 860
 861 /* Evaluates the curves between each selected keyframe on each frame, and keys the value  */
 862 static void sample_action_keys (bAnimContext *ac)
 863 {
 864         ListBase anim_data = {NULL, NULL};
 865         bAnimListElem *ale;
 866         int filter;
 867
 868         /* filter data */
 869         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
 870         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 871
 872         /* loop through filtered data and add keys between selected keyframes on every frame  */
 873         for (ale= anim_data.first; ale; ale= ale->next)
 874                 sample_fcurve((FCurve *)ale->key_data);
 875
 876         /* admin and redraws */
 877         BLI_freelistN(&anim_data);
 878 }
 879
 880 /* ------------------- */
 881
 882 static int actkeys_sample_exec(bContext *C, wmOperator *UNUSED(op))
 883 {
 884         bAnimContext ac;
 885
 886         /* get editor data */
 887         if (ANIM_animdata_get_context(C, &ac) == 0)
 888                 return OPERATOR_CANCELLED;
 889         if (ac.datatype == ANIMCONT_GPENCIL)
 890                 return OPERATOR_PASS_THROUGH;
 891
 892         /* sample keyframes */
 893         sample_action_keys(&ac);
 894
 895         /* validate keyframes after editing */
 896         ANIM_editkeyframes_refresh(&ac);
 897
 898         /* set notifier that keyframes have changed */
 899         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 900
 901         return OPERATOR_FINISHED;
 902 }
 903
 904 void ACTION_OT_sample (wmOperatorType *ot)
 905 {
 906         /* identifiers */
 907         ot->name= "Sample Keyframes";
 908         ot->idname= "ACTION_OT_sample";
 909         ot->description= "Add keyframes on every frame between the selected keyframes";
 910
 911         /* api callbacks */
 912         ot->exec= actkeys_sample_exec;
 913         ot->poll= ED_operator_action_active;
 914
 915         /* flags */
 916         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 917 }
 918
 919 /* ************************************************************************** */
 920 /* SETTINGS STUFF */
 921
 922 /* ******************** Set Extrapolation-Type Operator *********************** */
 923
 924 /* defines for make/clear cyclic extrapolation tools */
 925 #define MAKE_CYCLIC_EXPO        -1
 926 #define CLEAR_CYCLIC_EXPO       -2
 927
 928 /* defines for set extrapolation-type for selected keyframes tool */
 929 static EnumPropertyItem prop_actkeys_expo_types[] = {
 930         {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", 0, "Constant Extrapolation", ""},
 931         {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", 0, "Linear Extrapolation", ""},
 932
 933         {MAKE_CYCLIC_EXPO, "MAKE_CYCLIC", 0, "Make Cyclic (F-Modifier)", "Add Cycles F-Modifier if one doesn't exist already"},
 934         {CLEAR_CYCLIC_EXPO, "CLEAR_CYCLIC", 0, "Clear Cyclic (F-Modifier)", "Remove Cycles F-Modifier if not needed anymore"},
 935         {0, NULL, 0, NULL, NULL}
 936 };
 937
 938 /* this function is responsible for setting extrapolation mode for keyframes */
 939 static void setexpo_action_keys(bAnimContext *ac, short mode)
 940 {
 941         ListBase anim_data = {NULL, NULL};
 942         bAnimListElem *ale;
 943         int filter;
 944
 945         /* filter data */
 946         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_SEL /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
 947         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
 948
 949         /* loop through setting mode per F-Curve */
 950         for (ale= anim_data.first; ale; ale= ale->next) {
 951                 FCurve *fcu= (FCurve *)ale->data;
 952
 953                 if (mode >= 0) {
 954                         /* just set mode setting */
 955                         fcu->extend= mode;
 956                 }
 957                 else {
 958                         /* shortcuts for managing Cycles F-Modifiers to make it easier to toggle cyclic animation
 959                          * without having to go through FModifier UI in Graph Editor to do so
 960                          */
 961                         if (mode == MAKE_CYCLIC_EXPO) {
 962                                 /* only add if one doesn't exist */
 963                                 if (list_has_suitable_fmodifier(&fcu->modifiers, FMODIFIER_TYPE_CYCLES, -1) == 0) {
 964                                         // TODO: add some more preset versions which set different extrapolation options?
 965                                         add_fmodifier(&fcu->modifiers, FMODIFIER_TYPE_CYCLES);
 966                                 }
 967                         }
 968                         else if (mode == CLEAR_CYCLIC_EXPO) {
 969                                 /* remove all the modifiers fitting this description */
 970                                 FModifier *fcm, *fcn=NULL;
 971
 972                                 for (fcm = fcu->modifiers.first; fcm; fcm = fcn) {
 973                                         fcn = fcm->next;
 974
 975                                         if (fcm->type == FMODIFIER_TYPE_CYCLES)
 976                                                 remove_fmodifier(&fcu->modifiers, fcm);
 977                                 }
 978                         }
 979                 }
 980         }
 981
 982         /* cleanup */
 983         BLI_freelistN(&anim_data);
 984 }
 985
 986 /* ------------------- */
 987
 988 static int actkeys_expo_exec(bContext *C, wmOperator *op)
 989 {
 990         bAnimContext ac;
 991         short mode;
 992
 993         /* get editor data */
 994         if (ANIM_animdata_get_context(C, &ac) == 0)
 995                 return OPERATOR_CANCELLED;
 996         if (ac.datatype == ANIMCONT_GPENCIL)
 997                 return OPERATOR_PASS_THROUGH;
 998
 999         /* get handle setting mode */
1000         mode= RNA_enum_get(op->ptr, "type");
1001
1002         /* set handle type */
1003         setexpo_action_keys(&ac, mode);
1004
1005         /* validate keyframes after editing */
1006         ANIM_editkeyframes_refresh(&ac);
1007
1008         /* set notifier that keyframe properties have changed */
1009         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
1010
1011         return OPERATOR_FINISHED;
1012 }
1013
1014 void ACTION_OT_extrapolation_type (wmOperatorType *ot)
1015 {
1016         /* identifiers */
1017         ot->name= "Set Keyframe Extrapolation";
1018         ot->idname= "ACTION_OT_extrapolation_type";
1019         ot->description= "Set extrapolation mode for selected F-Curves";
1020
1021         /* api callbacks */
1022         ot->invoke= WM_menu_invoke;
1023         ot->exec= actkeys_expo_exec;
1024         ot->poll= ED_operator_action_active;
1025
1026         /* flags */
1027         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1028
1029         /* id-props */
1030         ot->prop= RNA_def_enum(ot->srna, "type", prop_actkeys_expo_types, 0, "Type", "");
1031 }
1032
1033 /* ******************** Set Interpolation-Type Operator *********************** */
1034
1035 /* this function is responsible for setting interpolation mode for keyframes */
1036 static void setipo_action_keys(bAnimContext *ac, short mode)
1037 {
1038         ListBase anim_data = {NULL, NULL};
1039         bAnimListElem *ale;
1040         int filter;
1041         KeyframeEditFunc set_cb= ANIM_editkeyframes_ipo(mode);
1042
1043         /* filter data */
1044         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
1045         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1046
1047         /* loop through setting BezTriple interpolation
1048          * Note: we do not supply KeyframeEditData to the looper yet. Currently that's not necessary here...
1049          */
1050         for (ale= anim_data.first; ale; ale= ale->next)
1051                 ANIM_fcurve_keyframes_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
1052
1053         /* cleanup */
1054         BLI_freelistN(&anim_data);
1055 }
1056
1057 /* ------------------- */
1058
1059 static int actkeys_ipo_exec(bContext *C, wmOperator *op)
1060 {
1061         bAnimContext ac;
1062         short mode;
1063
1064         /* get editor data */
1065         if (ANIM_animdata_get_context(C, &ac) == 0)
1066                 return OPERATOR_CANCELLED;
1067         if (ac.datatype == ANIMCONT_GPENCIL)
1068                 return OPERATOR_PASS_THROUGH;
1069
1070         /* get handle setting mode */
1071         mode= RNA_enum_get(op->ptr, "type");
1072
1073         /* set handle type */
1074         setipo_action_keys(&ac, mode);
1075
1076         /* validate keyframes after editing */
1077         ANIM_editkeyframes_refresh(&ac);
1078
1079         /* set notifier that keyframe properties have changed */
1080         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
1081
1082         return OPERATOR_FINISHED;
1083 }
1084
1085 void ACTION_OT_interpolation_type (wmOperatorType *ot)
1086 {
1087         /* identifiers */
1088         ot->name= "Set Keyframe Interpolation";
1089         ot->idname= "ACTION_OT_interpolation_type";
1090         ot->description= "Set interpolation mode for the F-Curve segments starting from the selected keyframes";
1091
1092         /* api callbacks */
1093         ot->invoke= WM_menu_invoke;
1094         ot->exec= actkeys_ipo_exec;
1095         ot->poll= ED_operator_action_active;
1096
1097         /* flags */
1098         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1099
1100         /* id-props */
1101         ot->prop= RNA_def_enum(ot->srna, "type", beztriple_interpolation_mode_items, 0, "Type", "");
1102 }
1103
1104 /* ******************** Set Handle-Type Operator *********************** */
1105
1106 static EnumPropertyItem actkeys_handle_type_items[] = {
1107         {HD_FREE, "FREE", 0, "Free", ""},
1108         {HD_VECT, "VECTOR", 0, "Vector", ""},
1109         {HD_ALIGN, "ALIGNED", 0, "Aligned", ""},
1110         {0, "", 0, "", ""},
1111         {HD_AUTO, "AUTO", 0, "Auto", "Handles that are automatically adjusted upon moving the keyframe"},
1112         {HD_AUTO_ANIM, "ANIM_CLAMPED", 0, "Auto Clamped", "Auto handles clamped to not overshoot"},
1113         {0, NULL, 0, NULL, NULL}};
1114
1115 /* ------------------- */
1116
1117 /* this function is responsible for setting handle-type of selected keyframes */
1118 static void sethandles_action_keys(bAnimContext *ac, short mode)
1119 {
1120         ListBase anim_data = {NULL, NULL};
1121         bAnimListElem *ale;
1122         int filter;
1123
1124         KeyframeEditFunc edit_cb= ANIM_editkeyframes_handles(mode);
1125         KeyframeEditFunc sel_cb= ANIM_editkeyframes_ok(BEZT_OK_SELECTED);
1126
1127         /* filter data */
1128         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
1129         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1130
1131         /* loop through setting flags for handles
1132          * Note: we do not supply KeyframeEditData to the looper yet. Currently that's not necessary here...
1133          */
1134         for (ale= anim_data.first; ale; ale= ale->next) {
1135                 FCurve *fcu= (FCurve *)ale->key_data;
1136
1137                 /* any selected keyframes for editing? */
1138                 if (ANIM_fcurve_keyframes_loop(NULL, fcu, NULL, sel_cb, NULL)) {
1139                         /* for auto/auto-clamped, toggle the auto-handles flag on the F-Curve */
1140                         if (mode == HD_AUTO_ANIM)
1141                                 fcu->flag |= FCURVE_AUTO_HANDLES;
1142                         else if (mode == HD_AUTO)
1143                                 fcu->flag &= ~FCURVE_AUTO_HANDLES;
1144
1145                         /* change type of selected handles */
1146                         ANIM_fcurve_keyframes_loop(NULL, fcu, NULL, edit_cb, calchandles_fcurve);
1147                 }
1148         }
1149
1150         /* cleanup */
1151         BLI_freelistN(&anim_data);
1152 }
1153
1154 /* ------------------- */
1155
1156 static int actkeys_handletype_exec(bContext *C, wmOperator *op)
1157 {
1158         bAnimContext ac;
1159         short mode;
1160
1161         /* get editor data */
1162         if (ANIM_animdata_get_context(C, &ac) == 0)
1163                 return OPERATOR_CANCELLED;
1164         if (ac.datatype == ANIMCONT_GPENCIL)
1165                 return OPERATOR_PASS_THROUGH;
1166
1167         /* get handle setting mode */
1168         mode= RNA_enum_get(op->ptr, "type");
1169
1170         /* set handle type */
1171         sethandles_action_keys(&ac, mode);
1172
1173         /* validate keyframes after editing */
1174         ANIM_editkeyframes_refresh(&ac);
1175
1176         /* set notifier that keyframe properties have changed */
1177         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
1178
1179         return OPERATOR_FINISHED;
1180 }
1181
1182 void ACTION_OT_handle_type (wmOperatorType *ot)
1183 {
1184         /* identifiers */
1185         ot->name= "Set Keyframe Handle Type";
1186         ot->idname= "ACTION_OT_handle_type";
1187         ot->description= "Set type of handle for selected keyframes";
1188
1189         /* api callbacks */
1190         ot->invoke= WM_menu_invoke;
1191         ot->exec= actkeys_handletype_exec;
1192         ot->poll= ED_operator_action_active;
1193
1194         /* flags */
1195         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1196
1197         /* id-props */
1198         ot->prop= RNA_def_enum(ot->srna, "type", actkeys_handle_type_items, 0, "Type", "");
1199 }
1200
1201 /* ******************** Set Keyframe-Type Operator *********************** */
1202
1203 /* this function is responsible for setting interpolation mode for keyframes */
1204 static void setkeytype_action_keys(bAnimContext *ac, short mode)
1205 {
1206         ListBase anim_data = {NULL, NULL};
1207         bAnimListElem *ale;
1208         int filter;
1209         KeyframeEditFunc set_cb= ANIM_editkeyframes_keytype(mode);
1210
1211         /* filter data */
1212         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
1213         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1214
1215         /* loop through setting BezTriple interpolation
1216          * Note: we do not supply KeyframeEditData to the looper yet. Currently that's not necessary here...
1217          */
1218         for (ale= anim_data.first; ale; ale= ale->next)
1219                 ANIM_fcurve_keyframes_loop(NULL, ale->key_data, NULL, set_cb, NULL);
1220
1221         /* cleanup */
1222         BLI_freelistN(&anim_data);
1223 }
1224
1225 /* ------------------- */
1226
1227 static int actkeys_keytype_exec(bContext *C, wmOperator *op)
1228 {
1229         bAnimContext ac;
1230         short mode;
1231
1232         /* get editor data */
1233         if (ANIM_animdata_get_context(C, &ac) == 0)
1234                 return OPERATOR_CANCELLED;
1235         if (ac.datatype == ANIMCONT_GPENCIL)
1236                 return OPERATOR_PASS_THROUGH;
1237
1238         /* get handle setting mode */
1239         mode= RNA_enum_get(op->ptr, "type");
1240
1241         /* set handle type */
1242         setkeytype_action_keys(&ac, mode);
1243
1244         /* validate keyframes after editing */
1245         ANIM_editkeyframes_refresh(&ac);
1246
1247         /* set notifier that keyframe properties have changed */
1248         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
1249
1250         return OPERATOR_FINISHED;
1251 }
1252
1253 void ACTION_OT_keyframe_type (wmOperatorType *ot)
1254 {
1255         /* identifiers */
1256         ot->name= "Set Keyframe Type";
1257         ot->idname= "ACTION_OT_keyframe_type";
1258         ot->description= "Set type of keyframe for the selected keyframes";
1259
1260         /* api callbacks */
1261         ot->invoke= WM_menu_invoke;
1262         ot->exec= actkeys_keytype_exec;
1263         ot->poll= ED_operator_action_active;
1264
1265         /* flags */
1266         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1267
1268         /* id-props */
1269         ot->prop= RNA_def_enum(ot->srna, "type", beztriple_keyframe_type_items, 0, "Type", "");
1270 }
1271
1272 /* ************************************************************************** */
1273 /* TRANSFORM STUFF */
1274
1275 /* ***************** Jump to Selected Frames Operator *********************** */
1276
1277 /* snap current-frame indicator to 'average time' of selected keyframe */
1278 static int actkeys_framejump_exec(bContext *C, wmOperator *UNUSED(op))
1279 {
1280         bAnimContext ac;
1281         ListBase anim_data= {NULL, NULL};
1282         bAnimListElem *ale;
1283         int filter;
1284         KeyframeEditData ked= {{NULL}};
1285
1286         /* get editor data */
1287         if (ANIM_animdata_get_context(C, &ac) == 0)
1288                 return OPERATOR_CANCELLED;
1289
1290         /* init edit data */
1291         /* loop over action data, averaging values */
1292         filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE /*| ANIMFILTER_CURVESONLY */ | ANIMFILTER_NODUPLIS);
1293         ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
1294
1295         for (ale= anim_data.first; ale; ale= ale->next) {
1296                 AnimData *adt= ANIM_nla_mapping_get(&ac, ale);
1297                 if (adt) {
1298                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1);
1299                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, bezt_calc_average, NULL);
1300                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);
1301                 }
1302                 else
1303                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, bezt_calc_average, NULL);
1304         }
1305
1306         BLI_freelistN(&anim_data);
1307
1308         /* set the new current frame value, based on the average time */
1309         if (ked.i1) {
1310                 Scene *scene= ac.scene;
1311                 CFRA= (int)floor((ked.f1 / ked.i1) + 0.5f);
1312                 SUBFRA= 0.f;
1313         }
1314
1315         /* set notifier that things have changed */
1316         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene);
1317
1318         return OPERATOR_FINISHED;
1319 }
1320
1321 void ACTION_OT_frame_jump (wmOperatorType *ot)
1322 {
1323         /* identifiers */
1324         ot->name= "Jump to Frame";
1325         ot->idname= "ACTION_OT_frame_jump";
1326         ot->description= "Set the current frame to the average frame of the selected keyframes";
1327
1328         /* api callbacks */
1329         ot->exec= actkeys_framejump_exec;
1330         ot->poll= ED_operator_action_active;
1331
1332         /* flags */
1333         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1334 }
1335
1336 /* ******************** Snap Keyframes Operator *********************** */
1337
1338 /* defines for snap keyframes tool */
1339 static EnumPropertyItem prop_actkeys_snap_types[] = {
1340         {ACTKEYS_SNAP_CFRA, "CFRA", 0, "Current frame", ""},
1341         {ACTKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", 0, "Nearest Frame", ""}, // XXX as single entry?
1342         {ACTKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", 0, "Nearest Second", ""}, // XXX as single entry?
1343         {ACTKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", 0, "Nearest Marker", ""},
1344         {0, NULL, 0, NULL, NULL}
1345 };
1346
1347 /* this function is responsible for snapping keyframes to frame-times */
1348 static void snap_action_keys(bAnimContext *ac, short mode)
1349 {
1350         ListBase anim_data = {NULL, NULL};
1351         bAnimListElem *ale;
1352         int filter;
1353
1354         KeyframeEditData ked= {{NULL}};
1355         KeyframeEditFunc edit_cb;
1356
1357         /* filter data */
1358         if (ac->datatype == ANIMCONT_GPENCIL)
1359                 filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT);
1360         else
1361                 filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
1362         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1363
1364         /* get beztriple editing callbacks */
1365         edit_cb= ANIM_editkeyframes_snap(mode);
1366
1367         ked.scene= ac->scene;
1368         if (mode == ACTKEYS_SNAP_NEAREST_MARKER) {
1369                 ked.list.first= (ac->markers) ? ac->markers->first : NULL;
1370                 ked.list.last= (ac->markers) ? ac->markers->last : NULL;
1371         }
1372
1373         /* snap keyframes */
1374         for (ale= anim_data.first; ale; ale= ale->next) {
1375                 AnimData *adt= ANIM_nla_mapping_get(ac, ale);
1376
1377                 if (adt) {
1378                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1);
1379                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1380                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);
1381                 }
1382                 //else if (ale->type == ACTTYPE_GPLAYER)
1383                 //      snap_gplayer_frames(ale->data, mode);
1384                 else
1385                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1386         }
1387
1388         BLI_freelistN(&anim_data);
1389 }
1390
1391 /* ------------------- */
1392
1393 static int actkeys_snap_exec(bContext *C, wmOperator *op)
1394 {
1395         bAnimContext ac;
1396         short mode;
1397
1398         /* get editor data */
1399         if (ANIM_animdata_get_context(C, &ac) == 0)
1400                 return OPERATOR_CANCELLED;
1401
1402         /* get snapping mode */
1403         mode= RNA_enum_get(op->ptr, "type");
1404
1405         /* snap keyframes */
1406         snap_action_keys(&ac, mode);
1407
1408         /* validate keyframes after editing */
1409         ANIM_editkeyframes_refresh(&ac);
1410
1411         /* set notifier that keyframes have changed */
1412         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
1413
1414         return OPERATOR_FINISHED;
1415 }
1416
1417 void ACTION_OT_snap (wmOperatorType *ot)
1418 {
1419         /* identifiers */
1420         ot->name= "Snap Keys";
1421         ot->idname= "ACTION_OT_snap";
1422         ot->description= "Snap selected keyframes to the times specified";
1423
1424         /* api callbacks */
1425         ot->invoke= WM_menu_invoke;
1426         ot->exec= actkeys_snap_exec;
1427         ot->poll= ED_operator_action_active;
1428
1429         /* flags */
1430         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1431
1432         /* id-props */
1433         ot->prop= RNA_def_enum(ot->srna, "type", prop_actkeys_snap_types, 0, "Type", "");
1434 }
1435
1436 /* ******************** Mirror Keyframes Operator *********************** */
1437
1438 /* defines for mirror keyframes tool */
1439 static EnumPropertyItem prop_actkeys_mirror_types[] = {
1440         {ACTKEYS_MIRROR_CFRA, "CFRA", 0, "By Times over Current frame", ""},
1441         {ACTKEYS_MIRROR_XAXIS, "XAXIS", 0, "By Values over Value=0", ""},
1442         {ACTKEYS_MIRROR_MARKER, "MARKER", 0, "By Times over First Selected Marker", ""},
1443         {0, NULL, 0, NULL, NULL}
1444 };
1445
1446 /* this function is responsible for mirroring keyframes */
1447 static void mirror_action_keys(bAnimContext *ac, short mode)
1448 {
1449         ListBase anim_data = {NULL, NULL};
1450         bAnimListElem *ale;
1451         int filter;
1452
1453         KeyframeEditData ked= {{NULL}};
1454         KeyframeEditFunc edit_cb;
1455
1456         /* get beztriple editing callbacks */
1457         edit_cb= ANIM_editkeyframes_mirror(mode);
1458
1459         ked.scene= ac->scene;
1460
1461         /* for 'first selected marker' mode, need to find first selected marker first! */
1462         // XXX should this be made into a helper func in the API?
1463         if (mode == ACTKEYS_MIRROR_MARKER) {
1464                 TimeMarker *marker= NULL;
1465
1466                 /* find first selected marker */
1467                 marker= ED_markers_get_first_selected(ac->markers);
1468
1469                 /* store marker's time (if available) */
1470                 if (marker)
1471                         ked.f1= (float)marker->frame;
1472                 else
1473                         return;
1474         }
1475
1476         /* filter data */
1477         if (ac->datatype == ANIMCONT_GPENCIL)
1478                 filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);
1479         else
1480                 filter= (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);
1481         ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
1482
1483         /* mirror keyframes */
1484         for (ale= anim_data.first; ale; ale= ale->next) {
1485                 AnimData *adt= ANIM_nla_mapping_get(ac, ale);
1486
1487                 if (adt) {
1488                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1);
1489                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1490                         ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);
1491                 }
1492                 //else if (ale->type == ACTTYPE_GPLAYER)
1493                 //      snap_gplayer_frames(ale->data, mode);
1494                 else
1495                         ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, edit_cb, calchandles_fcurve);
1496         }
1497
1498         BLI_freelistN(&anim_data);
1499 }
1500
1501 /* ------------------- */
1502
1503 static int actkeys_mirror_exec(bContext *C, wmOperator *op)
1504 {
1505         bAnimContext ac;
1506         short mode;
1507
1508         /* get editor data */
1509         if (ANIM_animdata_get_context(C, &ac) == 0)
1510                 return OPERATOR_CANCELLED;
1511
1512         /* get mirroring mode */
1513         mode= RNA_enum_get(op->ptr, "type");
1514
1515         /* mirror keyframes */
1516         mirror_action_keys(&ac, mode);
1517
1518         /* validate keyframes after editing */
1519         ANIM_editkeyframes_refresh(&ac);
1520
1521         /* set notifier that keyframes have changed */
1522         WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
1523
1524         return OPERATOR_FINISHED;
1525 }
1526
1527 void ACTION_OT_mirror (wmOperatorType *ot)
1528 {
1529         /* identifiers */
1530         ot->name= "Mirror Keys";
1531         ot->idname= "ACTION_OT_mirror";
1532         ot->description= "Flip selected keyframes over the selected mirror line";
1533
1534         /* api callbacks */
1535         ot->invoke= WM_menu_invoke;
1536         ot->exec= actkeys_mirror_exec;
1537         ot->poll= ED_operator_action_active;
1538
1539         /* flags */
1540         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1541
1542         /* id-props */
1543         ot->prop= RNA_def_enum(ot->srna, "type", prop_actkeys_mirror_types, 0, "Type", "");
1544 }
1545
1546 /* ************************************************************************** */