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