Merge branch 'blender2.7'
[blender.git] / source / blender / editors / space_action / action_data.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2015 Blender Foundation
17  * This is a new part of Blender
18  */
19
20 /** \file
21  * \ingroup spaction
22  */
23
24 #include <math.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <float.h>
28
29 #include "BLI_utildefines.h"
30
31 #include "BLT_translation.h"
32
33 #include "DNA_anim_types.h"
34 #include "DNA_gpencil_types.h"
35 #include "DNA_key_types.h"
36 #include "DNA_object_types.h"
37 #include "DNA_scene_types.h"
38 #include "DNA_mask_types.h"
39
40 #include "RNA_access.h"
41 #include "RNA_define.h"
42 #include "RNA_enum_types.h"
43
44 #include "BKE_animsys.h"
45 #include "BKE_action.h"
46 #include "BKE_context.h"
47 #include "BKE_fcurve.h"
48 #include "BKE_key.h"
49 #include "BKE_library.h"
50 #include "BKE_nla.h"
51 #include "BKE_scene.h"
52 #include "BKE_report.h"
53
54 #include "UI_view2d.h"
55
56 #include "ED_anim_api.h"
57 #include "ED_gpencil.h"
58 #include "ED_keyframing.h"
59 #include "ED_keyframes_edit.h"
60 #include "ED_screen.h"
61 #include "ED_markers.h"
62 #include "ED_mask.h"
63
64 #include "WM_api.h"
65 #include "WM_types.h"
66
67 #include "UI_interface.h"
68
69 #include "action_intern.h"
70
71 /* ************************************************************************** */
72 /* ACTION CREATION */
73
74 /* Helper function to find the active AnimData block from the Action Editor context */
75 AnimData *ED_actedit_animdata_from_context(bContext *C)
76 {
77   SpaceAction *saction = (SpaceAction *)CTX_wm_space_data(C);
78   Object *ob = CTX_data_active_object(C);
79   AnimData *adt = NULL;
80
81   /* Get AnimData block to use */
82   if (saction->mode == SACTCONT_ACTION) {
83     /* Currently, "Action Editor" means object-level only... */
84     if (ob) {
85       adt = ob->adt;
86     }
87   }
88   else if (saction->mode == SACTCONT_SHAPEKEY) {
89     Key *key = BKE_key_from_object(ob);
90     if (key) {
91       adt = key->adt;
92     }
93   }
94
95   return adt;
96 }
97
98 /* -------------------------------------------------------------------- */
99
100 /* Create new action */
101 static bAction *action_create_new(bContext *C, bAction *oldact)
102 {
103   ScrArea *sa = CTX_wm_area(C);
104   bAction *action;
105
106   /* create action - the way to do this depends on whether we've got an
107    * existing one there already, in which case we make a copy of it
108    * (which is useful for "versioning" actions within the same file)
109    */
110   if (oldact && GS(oldact->id.name) == ID_AC) {
111     /* make a copy of the existing action */
112     action = BKE_action_copy(CTX_data_main(C), oldact);
113   }
114   else {
115     /* just make a new (empty) action */
116     action = BKE_action_add(CTX_data_main(C), "Action");
117   }
118
119   /* when creating new ID blocks, there is already 1 user (as for all new datablocks),
120    * but the RNA pointer code will assign all the proper users instead, so we compensate
121    * for that here
122    */
123   BLI_assert(action->id.us == 1);
124   id_us_min(&action->id);
125
126   /* set ID-Root type */
127   if (sa->spacetype == SPACE_ACTION) {
128     SpaceAction *saction = (SpaceAction *)sa->spacedata.first;
129
130     if (saction->mode == SACTCONT_SHAPEKEY)
131       action->idroot = ID_KE;
132     else
133       action->idroot = ID_OB;
134   }
135
136   return action;
137 }
138
139 /* Change the active action used by the action editor */
140 static void actedit_change_action(bContext *C, bAction *act)
141 {
142   bScreen *screen = CTX_wm_screen(C);
143   SpaceAction *saction = (SpaceAction *)CTX_wm_space_data(C);
144
145   PointerRNA ptr, idptr;
146   PropertyRNA *prop;
147
148   /* create RNA pointers and get the property */
149   RNA_pointer_create(&screen->id, &RNA_SpaceDopeSheetEditor, saction, &ptr);
150   prop = RNA_struct_find_property(&ptr, "action");
151
152   /* NOTE: act may be NULL here, so better to just use a cast here */
153   RNA_id_pointer_create((ID *)act, &idptr);
154
155   /* set the new pointer, and force a refresh */
156   RNA_property_pointer_set(&ptr, prop, idptr);
157   RNA_property_update(C, &ptr, prop);
158 }
159
160 /* ******************** New Action Operator *********************** */
161
162 /* Criteria:
163  *  1) There must be an dopesheet/action editor, and it must be in a mode which uses actions...
164  *        OR
165  *     The NLA Editor is active (i.e. Animation Data panel -> new action)
166  *  2) The associated AnimData block must not be in tweakmode
167  */
168 static bool action_new_poll(bContext *C)
169 {
170   Scene *scene = CTX_data_scene(C);
171
172   /* Check tweakmode is off (as you don't want to be tampering with the action in that case) */
173   /* NOTE: unlike for pushdown, this operator needs to be run when creating an action from nothing... */
174   if (ED_operator_action_active(C)) {
175     SpaceAction *saction = (SpaceAction *)CTX_wm_space_data(C);
176     Object *ob = CTX_data_active_object(C);
177
178     /* For now, actions are only for the active object, and on object and shapekey levels... */
179     if (saction->mode == SACTCONT_ACTION) {
180       /* XXX: This assumes that actions are assigned to the active object in this mode */
181       if (ob) {
182         if ((ob->adt == NULL) || (ob->adt->flag & ADT_NLA_EDIT_ON) == 0)
183           return true;
184       }
185     }
186     else if (saction->mode == SACTCONT_SHAPEKEY) {
187       Key *key = BKE_key_from_object(ob);
188       if (key) {
189         if ((key->adt == NULL) || (key->adt->flag & ADT_NLA_EDIT_ON) == 0)
190           return true;
191       }
192     }
193   }
194   else if (ED_operator_nla_active(C)) {
195     if (!(scene->flag & SCE_NLA_EDIT_ON)) {
196       return true;
197     }
198   }
199
200   /* something failed... */
201   return false;
202 }
203
204 static int action_new_exec(bContext *C, wmOperator *UNUSED(op))
205 {
206   PointerRNA ptr, idptr;
207   PropertyRNA *prop;
208
209   /* hook into UI */
210   UI_context_active_but_prop_get_templateID(C, &ptr, &prop);
211
212   if (prop) {
213     bAction *action = NULL, *oldact = NULL;
214     AnimData *adt = NULL;
215     PointerRNA oldptr;
216
217     oldptr = RNA_property_pointer_get(&ptr, prop);
218     oldact = (bAction *)oldptr.id.data;
219
220     /* stash the old action to prevent it from being lost */
221     if (ptr.type == &RNA_AnimData) {
222       adt = ptr.data;
223     }
224     else if (ptr.type == &RNA_SpaceDopeSheetEditor) {
225       adt = ED_actedit_animdata_from_context(C);
226     }
227
228     /* Perform stashing operation - But only if there is an action */
229     if (adt && oldact) {
230       /* stash the action */
231       if (BKE_nla_action_stash(adt)) {
232         /* The stash operation will remove the user already
233          * (and unlink the action from the AnimData action slot).
234          * Hence, we must unset the ref to the action in the
235          * action editor too (if this is where we're being called from)
236          * first before setting the new action once it is created,
237          * or else the user gets decremented twice!
238          */
239         if (ptr.type == &RNA_SpaceDopeSheetEditor) {
240           SpaceAction *saction = (SpaceAction *)ptr.data;
241           saction->action = NULL;
242         }
243       }
244       else {
245         //printf("WARNING: Failed to stash %s. It may already exist in the NLA stack though\n", oldact->id.name);
246       }
247     }
248
249     /* create action */
250     action = action_create_new(C, oldact);
251
252     /* set this new action
253      * NOTE: we can't use actedit_change_action, as this function is also called from the NLA
254      */
255     RNA_id_pointer_create(&action->id, &idptr);
256     RNA_property_pointer_set(&ptr, prop, idptr);
257     RNA_property_update(C, &ptr, prop);
258   }
259
260   /* set notifier that keyframes have changed */
261   WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_ADDED, NULL);
262
263   return OPERATOR_FINISHED;
264 }
265
266 void ACTION_OT_new(wmOperatorType *ot)
267 {
268   /* identifiers */
269   ot->name = "New Action";
270   ot->idname = "ACTION_OT_new";
271   ot->description = "Create new action";
272
273   /* api callbacks */
274   ot->exec = action_new_exec;
275   ot->poll = action_new_poll;
276
277   /* flags */
278   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
279 }
280
281 /* ******************* Action Push-Down Operator ******************** */
282
283 /* Criteria:
284  *  1) There must be an dopesheet/action editor, and it must be in a mode which uses actions
285  *  2) There must be an action active
286  *  3) The associated AnimData block must not be in tweakmode
287  */
288 static bool action_pushdown_poll(bContext *C)
289 {
290   if (ED_operator_action_active(C)) {
291     SpaceAction *saction = (SpaceAction *)CTX_wm_space_data(C);
292     AnimData *adt = ED_actedit_animdata_from_context(C);
293
294     /* Check for AnimData, Actions, and that tweakmode is off */
295     if (adt && saction->action) {
296       /* NOTE: We check this for the AnimData block in question and not the global flag,
297        *       as the global flag may be left dirty by some of the browsing ops here.
298        */
299       if (!(adt->flag & ADT_NLA_EDIT_ON))
300         return true;
301     }
302   }
303
304   /* something failed... */
305   return false;
306 }
307
308 static int action_pushdown_exec(bContext *C, wmOperator *op)
309 {
310   SpaceAction *saction = (SpaceAction *)CTX_wm_space_data(C);
311   AnimData *adt = ED_actedit_animdata_from_context(C);
312
313   /* Do the deed... */
314   if (adt) {
315     /* Perform the pushdown operation
316      * - This will deal with all the AnimData-side usercounts
317      */
318     if (action_has_motion(adt->action) == 0) {
319       /* action may not be suitable... */
320       BKE_report(op->reports, RPT_WARNING, "Action must have at least one keyframe or F-Modifier");
321       return OPERATOR_CANCELLED;
322     }
323     else {
324       /* action can be safely added */
325       BKE_nla_action_pushdown(adt);
326     }
327
328     /* Stop displaying this action in this editor
329      * NOTE: The editor itself doesn't set a user...
330      */
331     saction->action = NULL;
332   }
333
334   /* Send notifiers that stuff has changed */
335   WM_event_add_notifier(C, NC_ANIMATION | ND_NLA_ACTCHANGE, NULL);
336   return OPERATOR_FINISHED;
337 }
338
339 void ACTION_OT_push_down(wmOperatorType *ot)
340 {
341   /* identifiers */
342   ot->name = "Push Down Action";
343   ot->idname = "ACTION_OT_push_down";
344   ot->description = "Push action down on to the NLA stack as a new strip";
345
346   /* callbacks */
347   ot->exec = action_pushdown_exec;
348   ot->poll = action_pushdown_poll;
349
350   /* flags */
351   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
352 }
353
354 /* ******************* Action Stash Operator ******************** */
355
356 static int action_stash_exec(bContext *C, wmOperator *op)
357 {
358   SpaceAction *saction = (SpaceAction *)CTX_wm_space_data(C);
359   AnimData *adt = ED_actedit_animdata_from_context(C);
360
361   /* Perform stashing operation */
362   if (adt) {
363     /* don't do anything if this action is empty... */
364     if (action_has_motion(adt->action) == 0) {
365       /* action may not be suitable... */
366       BKE_report(op->reports, RPT_WARNING, "Action must have at least one keyframe or F-Modifier");
367       return OPERATOR_CANCELLED;
368     }
369     else {
370       /* stash the action */
371       if (BKE_nla_action_stash(adt)) {
372         /* The stash operation will remove the user already,
373          * so the flushing step later shouldn't double up
374          * the usercount fixes. Hence, we must unset this ref
375          * first before setting the new action.
376          */
377         saction->action = NULL;
378       }
379       else {
380         /* action has already been added - simply warn about this, and clear */
381         BKE_report(op->reports, RPT_ERROR, "Action has already been stashed");
382       }
383
384       /* clear action refs from editor, and then also the backing data (not necessary) */
385       actedit_change_action(C, NULL);
386     }
387   }
388
389   /* Send notifiers that stuff has changed */
390   WM_event_add_notifier(C, NC_ANIMATION | ND_NLA_ACTCHANGE, NULL);
391   return OPERATOR_FINISHED;
392 }
393
394 void ACTION_OT_stash(wmOperatorType *ot)
395 {
396   /* identifiers */
397   ot->name = "Stash Action";
398   ot->idname = "ACTION_OT_stash";
399   ot->description = "Store this action in the NLA stack as a non-contributing strip for later use";
400
401   /* callbacks */
402   ot->exec = action_stash_exec;
403   ot->poll = action_pushdown_poll;
404
405   /* flags */
406   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
407
408   /* properties */
409   ot->prop = RNA_def_boolean(ot->srna,
410                              "create_new",
411                              true,
412                              "Create New Action",
413                              "Create a new action once the existing one has been safely stored");
414 }
415
416 /* ----------------- */
417
418 /* Criteria:
419  *  1) There must be an dopesheet/action editor, and it must be in a mode which uses actions
420  *  2) The associated AnimData block must not be in tweakmode
421  */
422 static bool action_stash_create_poll(bContext *C)
423 {
424   if (ED_operator_action_active(C)) {
425     AnimData *adt = ED_actedit_animdata_from_context(C);
426
427     /* Check tweakmode is off (as you don't want to be tampering with the action in that case) */
428     /* NOTE: unlike for pushdown, this operator needs to be run when creating an action from nothing... */
429     if (adt) {
430       if (!(adt->flag & ADT_NLA_EDIT_ON))
431         return true;
432     }
433     else {
434       /* There may not be any action/animdata yet, so, just fallback to the global setting
435        * (which may not be totally valid yet if the action editor was used and things are
436        * now in an inconsistent state)
437        */
438       SpaceAction *saction = (SpaceAction *)CTX_wm_space_data(C);
439       Scene *scene = CTX_data_scene(C);
440
441       if (!(scene->flag & SCE_NLA_EDIT_ON)) {
442         /* For now, actions are only for the active object, and on object and shapekey levels... */
443         return ELEM(saction->mode, SACTCONT_ACTION, SACTCONT_SHAPEKEY);
444       }
445     }
446   }
447
448   /* something failed... */
449   return false;
450 }
451
452 static int action_stash_create_exec(bContext *C, wmOperator *op)
453 {
454   SpaceAction *saction = (SpaceAction *)CTX_wm_space_data(C);
455   AnimData *adt = ED_actedit_animdata_from_context(C);
456
457   /* Check for no action... */
458   if (saction->action == NULL) {
459     /* just create a new action */
460     bAction *action = action_create_new(C, NULL);
461     actedit_change_action(C, action);
462   }
463   else if (adt) {
464     /* Perform stashing operation */
465     if (action_has_motion(adt->action) == 0) {
466       /* don't do anything if this action is empty... */
467       BKE_report(op->reports, RPT_WARNING, "Action must have at least one keyframe or F-Modifier");
468       return OPERATOR_CANCELLED;
469     }
470     else {
471       /* stash the action */
472       if (BKE_nla_action_stash(adt)) {
473         bAction *new_action = NULL;
474
475         /* create new action not based on the old one (since the "new" operator already does that) */
476         new_action = action_create_new(C, NULL);
477
478         /* The stash operation will remove the user already,
479          * so the flushing step later shouldn't double up
480          * the usercount fixes. Hence, we must unset this ref
481          * first before setting the new action.
482          */
483         saction->action = NULL;
484         actedit_change_action(C, new_action);
485       }
486       else {
487         /* action has already been added - simply warn about this, and clear */
488         BKE_report(op->reports, RPT_ERROR, "Action has already been stashed");
489         actedit_change_action(C, NULL);
490       }
491     }
492   }
493
494   /* Send notifiers that stuff has changed */
495   WM_event_add_notifier(C, NC_ANIMATION | ND_NLA_ACTCHANGE, NULL);
496   return OPERATOR_FINISHED;
497 }
498
499 void ACTION_OT_stash_and_create(wmOperatorType *ot)
500 {
501   /* identifiers */
502   ot->name = "Stash Action";
503   ot->idname = "ACTION_OT_stash_and_create";
504   ot->description =
505       "Store this action in the NLA stack as a non-contributing strip for later use, and create a "
506       "new action";
507
508   /* callbacks */
509   ot->exec = action_stash_create_exec;
510   ot->poll = action_stash_create_poll;
511
512   /* flags */
513   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
514 }
515
516 /* ************************************************************************** */
517 /* ACTION UNLINK */
518
519 /* ******************* Action Unlink Operator ******************** */
520 /* We use a custom unlink operator here, as there are some technicalities which need special care:
521  * 1) When in Tweak Mode, it shouldn't be possible to unlink the active action,
522  *    or else, everything turns to custard.
523  * 2) If the Action doesn't have any other users, the user should at least get
524  *    a warning that it is going to get lost.
525  * 3) We need a convenient way to exit Tweak Mode from the Action Editor
526  */
527
528 void ED_animedit_unlink_action(
529     bContext *C, ID *id, AnimData *adt, bAction *act, ReportList *reports, bool force_delete)
530 {
531   ScrArea *sa = CTX_wm_area(C);
532
533   /* If the old action only has a single user (that it's about to lose),
534    * warn user about it
535    *
536    * TODO: Maybe we should just save it for them? But then, there's the problem of
537    *       trying to get rid of stuff that's actually unwanted!
538    */
539   if (act->id.us == 1) {
540     BKE_reportf(reports,
541                 RPT_WARNING,
542                 "Action '%s' will not be saved, create Fake User or Stash in NLA Stack to retain",
543                 act->id.name + 2);
544   }
545
546   /* Clear Fake User and remove action stashing strip (if present) */
547   if (force_delete) {
548     /* Remove stashed strip binding this action to this datablock */
549     /* XXX: we cannot unlink it from *OTHER* datablocks that may also be stashing it,
550      * but GE users only seem to use/care about single-object binding for now so this
551      * should be fine
552      */
553     if (adt) {
554       NlaTrack *nlt, *nlt_next;
555       NlaStrip *strip, *nstrip;
556
557       for (nlt = adt->nla_tracks.first; nlt; nlt = nlt_next) {
558         nlt_next = nlt->next;
559
560         if (strstr(nlt->name, DATA_("[Action Stash]"))) {
561           for (strip = nlt->strips.first; strip; strip = nstrip) {
562             nstrip = strip->next;
563
564             if (strip->act == act) {
565               /* Remove this strip, and the track too if it doesn't have anything else */
566               BKE_nlastrip_free(&nlt->strips, strip, true);
567
568               if (nlt->strips.first == NULL) {
569                 BLI_assert(nstrip == NULL);
570                 BKE_nlatrack_free(&adt->nla_tracks, nlt, true);
571               }
572             }
573           }
574         }
575       }
576     }
577
578     /* Clear Fake User */
579     id_fake_user_clear(&act->id);
580   }
581
582   /* If in Tweak Mode, don't unlink. Instead, this
583    * becomes a shortcut to exit Tweak Mode instead
584    */
585   if ((adt) && (adt->flag & ADT_NLA_EDIT_ON)) {
586     /* Exit Tweak Mode */
587     BKE_nla_tweakmode_exit(adt);
588
589     /* Flush this to the Action Editor (if that's where this change was initiated) */
590     if (sa->spacetype == SPACE_ACTION) {
591       actedit_change_action(C, NULL);
592     }
593   }
594   else {
595     /* Unlink normally - Setting it to NULL should be enough to get the old one unlinked */
596     if (sa->spacetype == SPACE_ACTION) {
597       /* clear action editor -> action */
598       actedit_change_action(C, NULL);
599     }
600     else {
601       /* clear AnimData -> action */
602       PointerRNA ptr;
603       PropertyRNA *prop;
604
605       /* create AnimData RNA pointers */
606       RNA_pointer_create(id, &RNA_AnimData, adt, &ptr);
607       prop = RNA_struct_find_property(&ptr, "action");
608
609       /* clear... */
610       RNA_property_pointer_set(&ptr, prop, PointerRNA_NULL);
611       RNA_property_update(C, &ptr, prop);
612     }
613   }
614 }
615
616 /* -------------------------- */
617
618 static bool action_unlink_poll(bContext *C)
619 {
620   if (ED_operator_action_active(C)) {
621     SpaceAction *saction = (SpaceAction *)CTX_wm_space_data(C);
622     AnimData *adt = ED_actedit_animdata_from_context(C);
623
624     /* Only when there's an active action, in the right modes... */
625     if (saction->action && adt)
626       return true;
627   }
628
629   /* something failed... */
630   return false;
631 }
632
633 static int action_unlink_exec(bContext *C, wmOperator *op)
634 {
635   AnimData *adt = ED_actedit_animdata_from_context(C);
636   bool force_delete = RNA_boolean_get(op->ptr, "force_delete");
637
638   if (adt && adt->action) {
639     ED_animedit_unlink_action(C, NULL, adt, adt->action, op->reports, force_delete);
640   }
641
642   return OPERATOR_FINISHED;
643 }
644
645 static int action_unlink_invoke(bContext *C, wmOperator *op, const wmEvent *evt)
646 {
647   /* NOTE: this is hardcoded to match the behavior for the unlink button (in interface_templates.c) */
648   RNA_boolean_set(op->ptr, "force_delete", evt->shift != 0);
649   return action_unlink_exec(C, op);
650 }
651
652 void ACTION_OT_unlink(wmOperatorType *ot)
653 {
654   PropertyRNA *prop;
655
656   /* identifiers */
657   ot->name = "Unlink Action";
658   ot->idname = "ACTION_OT_unlink";
659   ot->description = "Unlink this action from the active action slot (and/or exit Tweak Mode)";
660
661   /* callbacks */
662   ot->invoke = action_unlink_invoke;
663   ot->exec = action_unlink_exec;
664   ot->poll = action_unlink_poll;
665
666   /* properties */
667   prop = RNA_def_boolean(ot->srna,
668                          "force_delete",
669                          false,
670                          "Force Delete",
671                          "Clear Fake User and remove "
672                          "copy stashed in this data-block's NLA stack");
673   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
674 }
675
676 /* ************************************************************************** */
677 /* ACTION BROWSING */
678
679 /* Try to find NLA Strip to use for action layer up/down tool */
680 static NlaStrip *action_layer_get_nlastrip(ListBase *strips, float ctime)
681 {
682   NlaStrip *strip;
683
684   for (strip = strips->first; strip; strip = strip->next) {
685     /* Can we use this? */
686     if (IN_RANGE_INCL(ctime, strip->start, strip->end)) {
687       /* in range - use this one */
688       return strip;
689     }
690     else if ((ctime < strip->start) && (strip->prev == NULL)) {
691       /* before first - use this one */
692       return strip;
693     }
694     else if ((ctime > strip->end) && (strip->next == NULL)) {
695       /* after last - use this one */
696       return strip;
697     }
698   }
699
700   /* nothing suitable found... */
701   return NULL;
702 }
703
704 /* Switch NLA Strips/Actions  */
705 static void action_layer_switch_strip(
706     AnimData *adt, NlaTrack *old_track, NlaStrip *old_strip, NlaTrack *nlt, NlaStrip *strip)
707 {
708   /* Exit tweakmode on old strip
709    * NOTE: We need to manually clear this stuff ourselves, as tweakmode exit doesn't do it
710    */
711   BKE_nla_tweakmode_exit(adt);
712
713   if (old_strip) {
714     old_strip->flag &= ~(NLASTRIP_FLAG_ACTIVE | NLASTRIP_FLAG_SELECT);
715   }
716   if (old_track) {
717     old_track->flag &= ~(NLATRACK_ACTIVE | NLATRACK_SELECTED);
718   }
719
720   /* Make this one the active one instead */
721   strip->flag |= (NLASTRIP_FLAG_ACTIVE | NLASTRIP_FLAG_SELECT);
722   nlt->flag |= NLATRACK_ACTIVE;
723
724   /* Copy over "solo" flag - This is useful for stashed actions... */
725   if (old_track) {
726     if (old_track->flag & NLATRACK_SOLO) {
727       old_track->flag &= ~NLATRACK_SOLO;
728       nlt->flag |= NLATRACK_SOLO;
729     }
730   }
731   else {
732     /* NLA muting <==> Solo Tracks */
733     if (adt->flag & ADT_NLA_EVAL_OFF) {
734       /* disable NLA muting */
735       adt->flag &= ~ADT_NLA_EVAL_OFF;
736
737       /* mark this track as being solo */
738       adt->flag |= ADT_NLA_SOLO_TRACK;
739       nlt->flag |= NLATRACK_SOLO;
740
741       // TODO: Needs restpose flushing (when we get reference track)
742     }
743   }
744
745   /* Enter tweakmode again - hopefully we're now "it" */
746   BKE_nla_tweakmode_enter(adt);
747   BLI_assert(adt->actstrip == strip);
748 }
749
750 /* ********************** One Layer Up Operator ************************** */
751
752 static bool action_layer_next_poll(bContext *C)
753 {
754   /* Action Editor's action editing modes only */
755   if (ED_operator_action_active(C)) {
756     AnimData *adt = ED_actedit_animdata_from_context(C);
757     if (adt) {
758       /* only allow if we're in tweakmode, and there's something above us... */
759       if (adt->flag & ADT_NLA_EDIT_ON) {
760         /* We need to check if there are any tracks above the active one
761          * since the track the action comes from is not stored in AnimData
762          */
763         if (adt->nla_tracks.last) {
764           NlaTrack *nlt = (NlaTrack *)adt->nla_tracks.last;
765
766           if (nlt->flag & NLATRACK_DISABLED) {
767             /* A disabled track will either be the track itself,
768              * or one of the ones above it.
769              *
770              * If this is the top-most one, there is the possibility
771              * that there is no active action. For now, we let this
772              * case return true too, so that there is a natural way
773              * to "move to an empty layer", even though this means
774              * that we won't actually have an action.
775              */
776             // return (adt->tmpact != NULL);
777             return true;
778           }
779         }
780       }
781     }
782   }
783
784   /* something failed... */
785   return false;
786 }
787
788 static int action_layer_next_exec(bContext *C, wmOperator *op)
789 {
790   AnimData *adt = ED_actedit_animdata_from_context(C);
791   NlaTrack *act_track;
792
793   Scene *scene = CTX_data_scene(C);
794   float ctime = BKE_scene_frame_get(scene);
795
796   /* Get active track */
797   act_track = BKE_nlatrack_find_tweaked(adt);
798
799   if (act_track == NULL) {
800     BKE_report(op->reports, RPT_ERROR, "Could not find current NLA Track");
801     return OPERATOR_CANCELLED;
802   }
803
804   /* Find next action, and hook it up */
805   if (act_track->next) {
806     NlaTrack *nlt;
807
808     /* Find next action to use */
809     for (nlt = act_track->next; nlt; nlt = nlt->next) {
810       NlaStrip *strip = action_layer_get_nlastrip(&nlt->strips, ctime);
811
812       if (strip) {
813         action_layer_switch_strip(adt, act_track, adt->actstrip, nlt, strip);
814         break;
815       }
816     }
817   }
818   else {
819     /* No more actions (strips) - Go back to editing the original active action
820      * NOTE: This will mean exiting tweakmode...
821      */
822     BKE_nla_tweakmode_exit(adt);
823
824     /* Deal with solo flags...
825      * Assume: Solo Track == NLA Muting
826      */
827     if (adt->flag & ADT_NLA_SOLO_TRACK) {
828       /* turn off solo flags on tracks */
829       act_track->flag &= ~NLATRACK_SOLO;
830       adt->flag &= ~ADT_NLA_SOLO_TRACK;
831
832       /* turn on NLA muting (to keep same effect) */
833       adt->flag |= ADT_NLA_EVAL_OFF;
834
835       // TODO: Needs restpose flushing (when we get reference track)
836     }
837   }
838
839   /* Update the action that this editor now uses
840    * NOTE: The calls above have already handled the usercount/animdata side of things
841    */
842   actedit_change_action(C, adt->action);
843   return OPERATOR_FINISHED;
844 }
845
846 void ACTION_OT_layer_next(wmOperatorType *ot)
847 {
848   /* identifiers */
849   ot->name = "Next Layer";
850   ot->idname = "ACTION_OT_layer_next";
851   ot->description =
852       "Switch to editing action in animation layer above the current action in the NLA Stack";
853
854   /* callbacks */
855   ot->exec = action_layer_next_exec;
856   ot->poll = action_layer_next_poll;
857
858   /* flags */
859   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
860 }
861
862 /* ********************* One Layer Down Operator ************************* */
863
864 static bool action_layer_prev_poll(bContext *C)
865 {
866   /* Action Editor's action editing modes only */
867   if (ED_operator_action_active(C)) {
868     AnimData *adt = ED_actedit_animdata_from_context(C);
869     if (adt) {
870       if (adt->flag & ADT_NLA_EDIT_ON) {
871         /* Tweak Mode: We need to check if there are any tracks below the active one
872          * that we can move to */
873         if (adt->nla_tracks.first) {
874           NlaTrack *nlt = (NlaTrack *)adt->nla_tracks.first;
875
876           /* Since the first disabled track is the track being tweaked/edited,
877            * we can simplify things by only checking the first track:
878            *    - If it is disabled, this is the track being tweaked,
879            *      so there can't be anything below it
880            *    - Otherwise, there is at least 1 track below the tweaking
881            *      track that we can descend to
882            */
883           if ((nlt->flag & NLATRACK_DISABLED) == 0) {
884             /* not disabled = there are actions below the one being tweaked */
885             return true;
886           }
887         }
888       }
889       else {
890         /* Normal Mode: If there are any tracks, we can try moving to those */
891         return (adt->nla_tracks.first != NULL);
892       }
893     }
894   }
895
896   /* something failed... */
897   return false;
898 }
899
900 static int action_layer_prev_exec(bContext *C, wmOperator *op)
901 {
902   AnimData *adt = ED_actedit_animdata_from_context(C);
903   NlaTrack *act_track;
904   NlaTrack *nlt;
905
906   Scene *scene = CTX_data_scene(C);
907   float ctime = BKE_scene_frame_get(scene);
908
909   /* Sanity Check */
910   if (adt == NULL) {
911     BKE_report(
912         op->reports, RPT_ERROR, "Internal Error: Could not find Animation Data/NLA Stack to use");
913     return OPERATOR_CANCELLED;
914   }
915
916   /* Get active track */
917   act_track = BKE_nlatrack_find_tweaked(adt);
918
919   /* If there is no active track, that means we are using the active action... */
920   if (act_track) {
921     /* Active Track - Start from the one below it */
922     nlt = act_track->prev;
923   }
924   else {
925     /* Active Action - Use the top-most track */
926     nlt = adt->nla_tracks.last;
927   }
928
929   /* Find previous action and hook it up */
930   for (; nlt; nlt = nlt->prev) {
931     NlaStrip *strip = action_layer_get_nlastrip(&nlt->strips, ctime);
932
933     if (strip) {
934       action_layer_switch_strip(adt, act_track, adt->actstrip, nlt, strip);
935       break;
936     }
937   }
938
939   /* Update the action that this editor now uses
940    * NOTE: The calls above have already handled the usercount/animdata side of things
941    */
942   actedit_change_action(C, adt->action);
943   return OPERATOR_FINISHED;
944 }
945
946 void ACTION_OT_layer_prev(wmOperatorType *ot)
947 {
948   /* identifiers */
949   ot->name = "Previous Layer";
950   ot->idname = "ACTION_OT_layer_prev";
951   ot->description =
952       "Switch to editing action in animation layer below the current action in the NLA Stack";
953
954   /* callbacks */
955   ot->exec = action_layer_prev_exec;
956   ot->poll = action_layer_prev_poll;
957
958   /* flags */
959   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
960 }
961
962 /* ************************************************************************** */