Inital commit

1 files changed, 521 insertions, 0 deletions

diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Actions/TrackActions.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Actions/TrackActions.cs
new file mode 100644
index 0000000..d379bd0
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Actions/TrackActions.cs
@@ -0,0 +1,521 @@
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using JetBrains.Annotations;
+using UnityEngine;
+using UnityEngine.Timeline;
+
+namespace UnityEditor.Timeline
+{
+    [ActiveInMode(TimelineModes.Default)]
+    abstract class TrackAction : MenuItemActionBase
+    {
+        public abstract bool Execute(WindowState state, TrackAsset[] tracks);
+
+        protected virtual MenuActionDisplayState GetDisplayState(WindowState state, TrackAsset[] tracks)
+        {
+            return tracks.Length > 0 ? MenuActionDisplayState.Visible : MenuActionDisplayState.Disabled;
+        }
+
+        protected virtual bool IsChecked(WindowState state, TrackAsset[] tracks)
+        {
+            return false;
+        }
+
+        protected virtual string GetDisplayName(TrackAsset[] tracks)
+        {
+            return menuName;
+        }
+
+        public static void Invoke<T>(WindowState state, TrackAsset[] tracks) where T : TrackAction
+        {
+            actions.First(x => x.GetType() == typeof(T)).Execute(state, tracks);
+        }
+
+        static List<TrackAction> s_ActionClasses;
+
+        static List<TrackAction> actions
+        {
+            get
+            {
+                if (s_ActionClasses == null)
+                    s_ActionClasses =
+                        GetActionsOfType(typeof(TrackAction))
+                            .Select(x => (TrackAction)x.GetConstructors()[0].Invoke(null))
+                            .OrderBy(x => x.priority).ThenBy(x => x.category)
+                            .ToList();
+
+                return s_ActionClasses;
+            }
+        }
+
+        public static void GetMenuEntries(WindowState state, Vector2? mousePos, TrackAsset[] tracks, List<MenuActionItem> items)
+        {
+            var mode = TimelineWindow.instance.currentMode.mode;
+            foreach (var action in actions)
+            {
+                if (!action.showInMenu)
+                    continue;
+
+                var actionItem = action;
+                items.Add(
+                    new MenuActionItem()
+                    {
+                        category =  action.category,
+                        entryName = action.GetDisplayName(tracks),
+                        shortCut = action.shortCut,
+                        isChecked = action.IsChecked(state, tracks),
+                        isActiveInMode = IsActionActiveInMode(action, mode),
+                        priority = action.priority,
+                        state = action.GetDisplayState(state, tracks),
+                        callback = () =>
+                        {
+                            actionItem.mousePosition = mousePos;
+                            actionItem.Execute(state, tracks);
+                            actionItem.mousePosition = null;
+                        }
+                    }
+                );
+            }
+        }
+
+        public static bool HandleShortcut(WindowState state, Event evt, TrackAsset[] tracks)
+        {
+            foreach (var action in actions)
+            {
+                var attr = action.GetType().GetCustomAttributes(typeof(ShortcutAttribute), true);
+
+                foreach (ShortcutAttribute shortcut in attr)
+                {
+                    if (shortcut.MatchesEvent(evt))
+                    {
+                        if (s_ShowActionTriggeredByShortcut)
+                            Debug.Log(action.GetType().Name);
+
+                        if (!IsActionActiveInMode(action, TimelineWindow.instance.currentMode.mode))
+                            return false;
+
+                        return action.Execute(state, tracks);
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        // For testing
+        internal MenuActionDisplayState InternalGetDisplayState(WindowState state, TrackAsset[] tracks)
+        {
+            return GetDisplayState(state, tracks);
+        }
+    }
+
+    [MenuEntry("Edit in Animation Window", MenuOrder.TrackAction.EditInAnimationWindow)]
+    class EditTrackInAnimationWindow : TrackAction
+    {
+        public static bool Do(WindowState state, TrackAsset track)
+        {
+            AnimationClip clipToEdit = null;
+
+            AnimationTrack animationTrack = track as AnimationTrack;
+            if (animationTrack != null)
+            {
+                if (!animationTrack.CanConvertToClipMode())
+                    return false;
+
+                clipToEdit = animationTrack.infiniteClip;
+            }
+            else if (track.hasCurves)
+            {
+                clipToEdit = track.curves;
+            }
+
+            if (clipToEdit == null)
+                return false;
+
+            var gameObject = state.GetSceneReference(track);
+            var timeController = TimelineAnimationUtilities.CreateTimeController(state, CreateTimeControlClipData(track));
+            TimelineAnimationUtilities.EditAnimationClipWithTimeController(clipToEdit, timeController, gameObject);
+
+            return true;
+        }
+
+        protected override MenuActionDisplayState GetDisplayState(WindowState state, TrackAsset[] tracks)
+        {
+            if (tracks.Length == 0)
+                return MenuActionDisplayState.Hidden;
+
+            if (tracks[0] is AnimationTrack)
+            {
+                var animTrack = tracks[0] as AnimationTrack;
+                if (animTrack.CanConvertToClipMode())
+                    return MenuActionDisplayState.Visible;
+            }
+            else if (tracks[0].hasCurves)
+            {
+                return MenuActionDisplayState.Visible;
+            }
+
+            return MenuActionDisplayState.Hidden;
+        }
+
+        public override bool Execute(WindowState state, TrackAsset[] tracks)
+        {
+            return Do(state, tracks[0]);
+        }
+
+        static TimelineWindowTimeControl.ClipData CreateTimeControlClipData(TrackAsset track)
+        {
+            var data = new TimelineWindowTimeControl.ClipData();
+            data.track = track;
+            data.start = track.start;
+            data.duration = track.duration;
+            return data;
+        }
+    }
+
+    [MenuEntry("Lock selected track only", MenuOrder.TrackAction.LockSelected)]
+    class LockSelectedTrack : TrackAction
+    {
+        public static readonly string LockSelectedTrackOnlyText = L10n.Tr("Lock selected track only");
+        public static readonly string UnlockSelectedTrackOnlyText = L10n.Tr("Unlock selected track only");
+
+        protected override MenuActionDisplayState GetDisplayState(WindowState state, TrackAsset[] tracks)
+        {
+            if (tracks.Any(track => TimelineUtility.IsLockedFromGroup(track) || track is GroupTrack ||
+                !track.subTracksObjects.Any()))
+                return MenuActionDisplayState.Hidden;
+            return MenuActionDisplayState.Visible;
+        }
+
+        public override bool Execute(WindowState state, TrackAsset[] tracks)
+        {
+            if (!tracks.Any()) return false;
+
+            var hasUnlockedTracks = tracks.Any(x => !x.locked);
+            Lock(state, tracks.Where(p => !(p is GroupTrack)).ToArray(), hasUnlockedTracks);
+            return true;
+        }
+
+        protected override string GetDisplayName(TrackAsset[] tracks)
+        {
+            return tracks.All(t => t.locked) ? UnlockSelectedTrackOnlyText : LockSelectedTrackOnlyText;
+        }
+
+        public static void Lock(WindowState state, TrackAsset[] tracks, bool shouldlock)
+        {
+            if (tracks.Length == 0)
+                return;
+
+            foreach (var track in tracks.Where(t => !TimelineUtility.IsLockedFromGroup(t)))
+            {
+                TimelineUndo.PushUndo(track, "Lock Tracks");
+                track.locked = shouldlock;
+            }
+            TimelineEditor.Refresh(RefreshReason.WindowNeedsRedraw);
+        }
+    }
+
+    [MenuEntry("Lock", MenuOrder.TrackAction.LockTrack)]
+    [Shortcut(Shortcuts.Timeline.toggleLock)]
+    class LockTrack : TrackAction
+    {
+        public static readonly string UnlockText = L10n.Tr("Unlock");
+
+        protected override MenuActionDisplayState GetDisplayState(WindowState state, TrackAsset[] tracks)
+        {
+            bool hasUnlockableTracks = tracks.Any(x => TimelineUtility.IsLockedFromGroup(x));
+            if (hasUnlockableTracks)
+                return MenuActionDisplayState.Disabled;
+            return MenuActionDisplayState.Visible;
+        }
+
+        protected override string GetDisplayName(TrackAsset[] tracks)
+        {
+            return tracks.Any(x => !x.locked) ? base.GetDisplayName(tracks) : UnlockText;
+        }
+
+        public override bool Execute(WindowState state, TrackAsset[] tracks)
+        {
+            if (!tracks.Any()) return false;
+
+            var hasUnlockedTracks = tracks.Any(x => !x.locked);
+            SetLockState(tracks, hasUnlockedTracks, state);
+            return true;
+        }
+
+        public static void SetLockState(TrackAsset[] tracks, bool shouldLock, WindowState state = null)
+        {
+            if (tracks.Length == 0)
+                return;
+
+            foreach (var track in tracks)
+            {
+                if (TimelineUtility.IsLockedFromGroup(track))
+                    continue;
+
+                if (track as GroupTrack == null)
+                    SetLockState(track.GetChildTracks().ToArray(), shouldLock, state);
+
+                TimelineUndo.PushUndo(track, "Lock Tracks");
+                track.locked = shouldLock;
+            }
+
+            if (state != null)
+            {
+                // find the tracks we've locked. unselect anything locked and remove recording.
+                foreach (var track in tracks)
+                {
+                    if (TimelineUtility.IsLockedFromGroup(track) || !track.locked)
+                        continue;
+
+                    var flattenedChildTracks = track.GetFlattenedChildTracks();
+                    foreach (var i in track.clips)
+                        SelectionManager.Remove(i);
+                    state.UnarmForRecord(track);
+                    foreach (var child in flattenedChildTracks)
+                    {
+                        SelectionManager.Remove(child);
+                        state.UnarmForRecord(child);
+                        foreach (var clip in child.GetClips())
+                            SelectionManager.Remove(clip);
+                    }
+                }
+
+                // no need to rebuild, just repaint (including inspectors)
+                InspectorWindow.RepaintAllInspectors();
+                state.editorWindow.Repaint();
+            }
+        }
+    }
+
+    [UsedImplicitly]
+    [MenuEntry("Show Markers", MenuOrder.TrackAction.ShowHideMarkers)]
+    [ActiveInMode(TimelineModes.Default | TimelineModes.ReadOnly)]
+    class ShowHideMarkers : TrackAction
+    {
+        protected override bool IsChecked(WindowState state, TrackAsset[] tracks)
+        {
+            return tracks.All(x => x.GetShowMarkers());
+        }
+
+        protected override MenuActionDisplayState GetDisplayState(WindowState state, TrackAsset[] tracks)
+        {
+            if (tracks.Any(x => x is GroupTrack) || tracks.Any(t => t.GetMarkerCount() == 0))
+                return MenuActionDisplayState.Hidden;
+
+            if (tracks.Any(t => t.lockedInHierarchy))
+                return MenuActionDisplayState.Disabled;
+
+            return MenuActionDisplayState.Visible;
+        }
+
+        public override bool Execute(WindowState state, TrackAsset[] tracks)
+        {
+            if (!tracks.Any()) return false;
+
+            var hasUnlockedTracks = tracks.Any(x => !x.GetShowMarkers());
+            ShowHide(state, tracks, hasUnlockedTracks);
+            return true;
+        }
+
+        static void ShowHide(WindowState state, TrackAsset[] tracks, bool shouldLock)
+        {
+            if (tracks.Length == 0)
+                return;
+
+            var window = state.GetWindow();
+            foreach (var track in tracks)
+            {
+                window.SetShowTrackMarkers(track, shouldLock);
+            }
+
+            TimelineEditor.Refresh(RefreshReason.WindowNeedsRedraw);
+        }
+    }
+
+    [MenuEntry("Mute selected track only", MenuOrder.TrackAction.MuteSelected), UsedImplicitly]
+    class MuteSelectedTrack : TrackAction
+    {
+        public static readonly string UnmuteSelectedText = L10n.Tr("Unmute selected track only");
+        protected override MenuActionDisplayState GetDisplayState(WindowState state, TrackAsset[] tracks)
+        {
+            if (tracks.Any(track => TimelineUtility.IsParentMuted(track) || track is GroupTrack ||
+                !track.subTracksObjects.Any()))
+                return MenuActionDisplayState.Hidden;
+            return MenuActionDisplayState.Visible;
+        }
+
+        public override bool Execute(WindowState state, TrackAsset[] tracks)
+        {
+            if (!tracks.Any())
+                return false;
+
+            var hasUnmutedTracks = tracks.Any(x => !x.muted);
+            Mute(state, tracks.Where(p => !(p is GroupTrack)).ToArray(), hasUnmutedTracks);
+            return true;
+        }
+
+        protected override string GetDisplayName(TrackAsset[] tracks)
+        {
+            return tracks.All(t => t.muted) ?  UnmuteSelectedText : base.GetDisplayName(tracks);
+        }
+
+        public static void Mute(WindowState state, TrackAsset[] tracks, bool shouldMute)
+        {
+            if (tracks.Length == 0)
+                return;
+
+            foreach (var track in tracks.Where(t => !TimelineUtility.IsParentMuted(t)))
+            {
+                TimelineUndo.PushUndo(track, "Mute Tracks");
+                track.muted = shouldMute;
+            }
+
+            state.Refresh();
+        }
+    }
+
+    [MenuEntry("Mute", MenuOrder.TrackAction.MuteTrack)]
+    [Shortcut(Shortcuts.Timeline.toggleMute)]
+    class MuteTrack : TrackAction
+    {
+        public static readonly string UnMuteText = L10n.Tr("Unmute");
+
+        protected override MenuActionDisplayState GetDisplayState(WindowState state, TrackAsset[] tracks)
+        {
+            if (tracks.Any(track => TimelineUtility.IsParentMuted(track)))
+                return MenuActionDisplayState.Disabled;
+            return MenuActionDisplayState.Visible;
+        }
+
+        protected override string GetDisplayName(TrackAsset[] tracks)
+        {
+            return tracks.Any(x => !x.muted) ? base.GetDisplayName(tracks) : UnMuteText;
+        }
+
+        public override bool Execute(WindowState state, TrackAsset[] tracks)
+        {
+            if (!tracks.Any() || tracks.Any(track => TimelineUtility.IsParentMuted(track)))
+                return false;
+
+            var hasUnmutedTracks = tracks.Any(x => !x.muted);
+            Mute(state, tracks, hasUnmutedTracks);
+            return true;
+        }
+
+        public static void Mute(WindowState state, TrackAsset[] tracks, bool shouldMute)
+        {
+            if (tracks.Length == 0)
+                return;
+
+            foreach (var track in tracks)
+            {
+                if (track as GroupTrack == null)
+                    Mute(state, track.GetChildTracks().ToArray(), shouldMute);
+                TimelineUndo.PushUndo(track, "Mute Tracks");
+                track.muted = shouldMute;
+            }
+
+            state.Refresh();
+        }
+    }
+
+    class DeleteTracks : TrackAction
+    {
+        public static void Do(TimelineAsset timeline, TrackAsset track)
+        {
+            SelectionManager.Remove(track);
+            TrackModifier.DeleteTrack(timeline, track);
+        }
+
+        public override bool Execute(WindowState state, TrackAsset[] tracks)
+        {
+            // disable preview mode so deleted tracks revert to default state
+            // Case 956129: Disable preview mode _before_ deleting the tracks, since clip data is still needed
+            state.previewMode = false;
+
+            TimelineAnimationUtilities.UnlinkAnimationWindowFromTracks(tracks);
+
+            foreach (var track in tracks)
+                Do(state.editSequence.asset, track);
+
+            state.Refresh();
+
+            return true;
+        }
+    }
+
+    class CopyTracksToClipboard : TrackAction
+    {
+        public static bool Do(WindowState state, TrackAsset[] tracks)
+        {
+            var action = new CopyTracksToClipboard();
+
+            return action.Execute(state, tracks);
+        }
+
+        public override bool Execute(WindowState state, TrackAsset[] tracks)
+        {
+            TimelineEditor.clipboard.CopyTracks(tracks);
+
+            return true;
+        }
+    }
+
+    class DuplicateTracks : TrackAction
+    {
+        public override bool Execute(WindowState state, TrackAsset[] tracks)
+        {
+            if (tracks.Any())
+            {
+                SelectionManager.RemoveTimelineSelection();
+            }
+
+            foreach (var track in TrackExtensions.FilterTracks(tracks))
+            {
+                var newTrack = track.Duplicate(TimelineEditor.inspectedDirector, TimelineEditor.inspectedDirector);
+                SelectionManager.Add(newTrack);
+                foreach (var childTrack in newTrack.GetFlattenedChildTracks())
+                {
+                    SelectionManager.Add(childTrack);
+                }
+            }
+
+            state.Refresh();
+
+            return true;
+        }
+    }
+
+    [MenuEntry("Remove Invalid Markers", MenuOrder.TrackAction.RemoveInvalidMarkers), UsedImplicitly]
+    class RemoveInvalidMarkersAction : TrackAction
+    {
+        protected override MenuActionDisplayState GetDisplayState(WindowState state, TrackAsset[] tracks)
+        {
+            if (tracks.Any(target => target != null && target.GetMarkerCount() != target.GetMarkersRaw().Count()))
+                return MenuActionDisplayState.Visible;
+
+            return MenuActionDisplayState.Hidden;
+        }
+
+        public override bool Execute(WindowState state, TrackAsset[] tracks)
+        {
+            bool anyRemoved = false;
+            foreach (var target in tracks)
+            {
+                var invalids = target.GetMarkersRaw().Where(x => !(x is IMarker)).ToList();
+                foreach (var m in invalids)
+                {
+                    anyRemoved = true;
+                    target.DeleteMarkerRaw(m);
+                }
+            }
+
+            if (anyRemoved)
+                TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved);
+
+            return anyRemoved;
+        }
+    }
+}