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