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