Inital commit

1 files changed, 222 insertions, 0 deletions

diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/treeview/TimelineDataSource.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/treeview/TimelineDataSource.cs
new file mode 100644
index 0000000..2337392
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/treeview/TimelineDataSource.cs
@@ -0,0 +1,222 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+using UnityEngine.Playables;
+using UnityEngine.Timeline;
+
+namespace UnityEditor.Timeline
+{
+    class TimelineDataSource : TreeViewDataSource
+    {
+        readonly TimelineWindow m_TimelineWindow;
+        readonly TimelineTreeViewGUI m_ParentGUI;
+
+        public List<TimelineTrackBaseGUI> allTrackGuis { get; private set; }
+
+        TreeViewItem treeroot
+        {
+            get { return m_RootItem; }
+        }
+
+        public TimelineDataSource(TimelineTreeViewGUI parentGUI, TreeViewController treeView, TimelineWindow sequencerWindow)
+            : base(treeView)
+        {
+            m_TreeView.useExpansionAnimation = false;
+            m_TimelineWindow = sequencerWindow;
+            m_ParentGUI = parentGUI;
+            FetchData();
+        }
+
+        public override bool IsExpanded(TreeViewItem item)
+        {
+            if (!IsExpandable(item))
+                return true;
+
+            return IsExpanded(item.id);
+        }
+
+        public override bool IsExpandable(TreeViewItem item)
+        {
+            var expandable = false;
+
+            var track = item as TimelineTrackBaseGUI;
+
+            if (track != null)
+                expandable =  track.expandable;
+
+            return expandable && item.hasChildren;
+        }
+
+        public sealed override void FetchData()
+        {
+            // create root item
+            m_RootItem = new TimelineGroupGUI(m_TreeView, m_ParentGUI, 1, 0, null, "root", null, true);
+
+            var tree = new Dictionary<TrackAsset, TimelineTrackBaseGUI>();
+
+            var filteredView = m_TimelineWindow.state.editSequence.asset.trackObjects;
+            allTrackGuis = new List<TimelineTrackBaseGUI>(filteredView.Count());
+
+            foreach (var t in filteredView)
+            {
+                CreateItem(t, ref tree, filteredView.OfType<TrackAsset>(), m_RootItem);
+            }
+
+            m_NeedRefreshRows = true;
+
+            SetExpanded(m_RootItem, true);
+        }
+
+        TimelineTrackBaseGUI CreateItem(ScriptableObject scriptableObject, ref Dictionary<TrackAsset, TimelineTrackBaseGUI> tree, IEnumerable<TrackAsset> selectedRows, TreeViewItem parentTreeViewItem)
+        {
+            // if a script doesn't load correctly, the trackAsset will be NULL, but the scriptableObject __should_ be intact (but == null will be true)
+            var trackAsset = scriptableObject as TrackAsset;
+
+            if (tree == null)
+                throw new ArgumentNullException("tree");
+
+            if (selectedRows == null)
+                throw new ArgumentNullException("selectedRows");
+
+            if (trackAsset != null && tree.ContainsKey(trackAsset))
+                return tree[trackAsset];
+
+            TimelineTrackBaseGUI parentItem = parentTreeViewItem as TimelineTrackBaseGUI;
+
+            // should we create the parent?
+            TrackAsset parentTrack = trackAsset != null ? (trackAsset.parent as TrackAsset) : null;
+            if (trackAsset != null && parentTrack != null && selectedRows.Contains(parentTrack))
+            {
+                parentItem = CreateItem(parentTrack, ref tree, selectedRows, parentTreeViewItem);
+            }
+
+            int theDepth = -1;
+            if (parentItem != null)
+                theDepth = parentItem.depth;
+            theDepth++;
+
+            TimelineTrackBaseGUI newItem;
+            if (trackAsset == null)
+            {
+                PlayableAsset parent = m_TimelineWindow.state.editSequence.asset;
+                if (parentItem != null && parentItem.track != null)
+                    parent = parentItem.track;
+
+                newItem = new TimelineTrackErrorGUI(m_TreeView, m_ParentGUI, 0, theDepth, parentItem, "ERROR", scriptableObject, parent);
+            }
+            else if (trackAsset.GetType() != typeof(GroupTrack))
+            {
+                newItem = new TimelineTrackGUI(m_TreeView, m_ParentGUI, trackAsset.GetInstanceID(), theDepth, parentItem, trackAsset.name, trackAsset);
+            }
+            else
+            {
+                newItem = new TimelineGroupGUI(m_TreeView, m_ParentGUI, trackAsset.GetInstanceID(), theDepth, parentItem, trackAsset.name, trackAsset, false);
+            }
+
+            allTrackGuis.Add(newItem);
+
+            if (parentItem != null)
+            {
+                if (parentItem.children == null)
+                    parentItem.children = new List<TreeViewItem>();
+                parentItem.children.Add(newItem);
+            }
+            else
+            {
+                m_RootItem = newItem;
+                SetExpanded(m_RootItem, true);
+            }
+
+            if (trackAsset != null)
+                tree[trackAsset] = newItem;
+
+            var actorAsAnimTrack = newItem.track as AnimationTrack;
+            bool isEditableInfiniteClip = actorAsAnimTrack != null && actorAsAnimTrack.ShouldShowInfiniteClipEditor();
+            if (isEditableInfiniteClip)
+            {
+                if (newItem.children == null)
+                    newItem.children = new List<TreeViewItem>();
+            }
+            else if (trackAsset != null)
+            {
+                // check if clips on this track have animation, if so we inline a animationEditorTrack
+                bool clipHasAnimatableAnimationCurves = false;
+
+                for (var i = 0; i != newItem.track.clips.Length; ++i)
+                {
+                    var curveClip = newItem.track.clips[i].curves;
+                    var animationClip = newItem.track.clips[i].animationClip;
+
+                    // prune out clip with zero curves
+                    if (curveClip != null && curveClip.empty)
+                        curveClip = null;
+
+                    if (animationClip != null && animationClip.empty)
+                        animationClip = null;
+
+                    // prune out clips coming from FBX
+                    if (animationClip != null && ((animationClip.hideFlags & HideFlags.NotEditable) != 0))
+                        animationClip = null;
+
+                    if (!newItem.track.clips[i].recordable)
+                        animationClip = null;
+
+                    clipHasAnimatableAnimationCurves = (curveClip != null) || (animationClip != null);
+                    if (clipHasAnimatableAnimationCurves)
+                        break;
+                }
+
+                if (clipHasAnimatableAnimationCurves)
+                {
+                    if (newItem.children == null)
+                        newItem.children = new List<TreeViewItem>();
+                }
+            }
+
+            if (trackAsset != null)
+            {
+                // Here we are using the internal subTrackObject so we can properly handle tracks whose script
+                //  can't load (via ScriptableObject)
+                foreach (var subTrack in trackAsset.subTracksObjects)
+                {
+                    CreateItem(subTrack, ref tree, selectedRows, newItem);
+                }
+            }
+            return newItem;
+        }
+
+        public override bool CanBeParent(TreeViewItem item)
+        {
+            // will prevent track becoming subtracks via dragging
+            TimelineTrackGUI track = item as TimelineTrackGUI;
+            if (track != null)
+                return false;
+
+            return true;
+        }
+
+        public void ExpandItems(TreeViewItem item)
+        {
+            if (treeroot == item)
+            {
+                SetExpanded(treeroot, true);
+            }
+
+            TimelineGroupGUI gui = item as TimelineGroupGUI;
+            if (gui != null && gui.track != null)
+            {
+                SetExpanded(item, !gui.track.GetCollapsed());
+            }
+
+            if (item.children != null)
+            {
+                for (int c = 0; c < item.children.Count; c++)
+                {
+                    ExpandItems(item.children[c]);
+                }
+            }
+        }
+    }
+}