first commit

Library/PackageCache/com.unity.timeline@1.7.6/Editor/treeview/ItemGui/ISelectable.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace UnityEditor.Timeline
+{
+    interface ISelectable : ILayerable
+    {
+        void Select();
+        bool IsSelected();
+        void Deselect();
+        bool CanSelect(UnityEngine.Event evt);
+    }
+}

Library/PackageCache/com.unity.timeline@1.7.6/Editor/treeview/ItemGui/ISelectable.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4acbfc0398bab674f922f693e58f4afc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.timeline@1.7.6/Editor/treeview/ItemGui/TimelineClipGUI.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3c01b61b3a6887c49a15276fd38be918
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.timeline@1.7.6/Editor/treeview/ItemGui/TimelineItemGUI.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine.Timeline;
+using UnityEngine;
+
+namespace UnityEditor.Timeline
+{
+    static class ItemToItemGui
+    {
+        static Dictionary<object, TimelineItemGUI> s_ItemToItemGUI =
+            new Dictionary<object, TimelineItemGUI>();
+
+        public static void Add(TimelineClip clip, TimelineItemGUI gui)
+        {
+            s_ItemToItemGUI[clip] = gui;
+        }
+
+        public static void Add(IMarker marker, TimelineItemGUI gui)
+        {
+            s_ItemToItemGUI[marker] = gui;
+        }
+
+        public static TimelineClipGUI GetGuiForClip(TimelineClip clip)
+        {
+            return GetGuiForItem(clip) as TimelineClipGUI;
+        }
+
+        public static TimelineMarkerGUI GetGuiForMarker(IMarker marker)
+        {
+            return GetGuiForItem(marker) as TimelineMarkerGUI;
+        }
+
+        static TimelineItemGUI GetGuiForItem(object item)
+        {
+            if (item == null)
+                return null;
+
+            TimelineItemGUI gui;
+            s_ItemToItemGUI.TryGetValue(item, out gui);
+            return gui;
+        }
+    }
+
+    abstract class TimelineItemGUI : ISelectable
+    {
+        protected readonly DirectorStyles m_Styles;
+
+        public abstract ITimelineItem item { get; }
+        public abstract double start { get; }
+        public abstract double end { get; }
+        public abstract void Draw(Rect rect, bool rectChanged, WindowState state);
+        public abstract Rect RectToTimeline(Rect trackRect, WindowState state);
+
+        public virtual void Select() { }
+        public virtual bool IsSelected() { return false; }
+        public virtual void Deselect() { }
+        public virtual bool CanSelect(Event evt) { return true; }
+
+        public virtual void StartDrag() { }
+        public virtual void StopDrag() { }
+
+        public LayerZOrder zOrder { get; set; }
+
+        public bool visible { get; set; }
+        public bool isInvalid { get; set; }
+
+        public IRowGUI parent { get; }
+
+        public Rect rect
+        {
+            get { return parent.ToWindowSpace(treeViewRect); }
+        }
+
+        public Rect treeViewRect
+        {
+            get { return m_TreeViewRect; }
+            protected set
+            {
+                m_TreeViewRect = value;
+                if (value.width < 0.0f)
+                    m_TreeViewRect.width = 1.0f;
+            }
+        }
+
+        Rect m_TreeViewRect;
+
+        protected TimelineItemGUI(IRowGUI parent)
+        {
+            this.parent = parent;
+            m_Styles = DirectorStyles.Instance;
+        }
+    }
+}

Library/PackageCache/com.unity.timeline@1.7.6/Editor/treeview/ItemGui/TimelineItemGUI.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6f515f8ecd3b6a546b90abaae2553f99
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.timeline@1.7.6/Editor/treeview/ItemGui/TimelineMarkerClusterGUI.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+using UnityObject = UnityEngine.Object;
+
+namespace UnityEditor.Timeline
+{
+    class TimelineMarkerClusterGUI : TimelineItemGUI
+    {
+        readonly List<TimelineMarkerGUI> m_MarkerGUIs;
+        readonly IZOrderProvider m_ZOrderProvider;
+
+        public TimelineMarkerGUI topMarker
+        {
+            get { return m_MarkerGUIs.LastOrDefault(); }
+        }
+
+        TimelineMarkerGUI m_ManipulatedMarker;
+
+        public TimelineMarkerClusterGUI(List<TimelineMarkerGUI> guis, IRowGUI parent,
+                                        IZOrderProvider zOrderProvider, LayerZOrder layerZOrder)
+            : base(parent)
+        {
+            m_MarkerGUIs = guis;
+            m_ZOrderProvider = zOrderProvider;
+            zOrder = layerZOrder;
+            SortMarkers();
+            topMarker.onStartDrag += OnDragTopMarker;
+        }
+
+        public override double start
+        {
+            get { return topMarker.start; }
+        }
+
+        public override double end
+        {
+            get { return topMarker.end; }
+        }
+
+        public override ITimelineItem item
+        {
+            get { return topMarker.item; }
+        }
+
+        public override void Select()
+        {
+            foreach (var marker in m_MarkerGUIs)
+            {
+                if (!marker.IsSelected())
+                    marker.Select();
+            }
+        }
+
+        public override void Deselect()
+        {
+            foreach (var marker in m_MarkerGUIs)
+            {
+                if (marker.IsSelected())
+                    marker.Deselect();
+            }
+        }
+
+        public override void Draw(Rect trackRect, bool trackRectChanged, WindowState state)
+        {
+            RegisterRect(state);
+
+            topMarker.Draw(trackRect, trackRectChanged, state);
+
+            if (m_MarkerGUIs.Count > 1)
+                GUI.Box(treeViewRect, String.Empty, DirectorStyles.Instance.markerMultiOverlay);
+
+            if (m_ManipulatedMarker != null)
+                m_ManipulatedMarker.Draw(trackRect, trackRectChanged, state);
+        }
+
+        public override Rect RectToTimeline(Rect trackRect, WindowState state)
+        {
+            return topMarker.RectToTimeline(trackRect, state);
+        }
+
+        public void CycleTop()
+        {
+            if (m_MarkerGUIs.Count < 2)
+                return;
+
+            topMarker.onStartDrag -= OnDragTopMarker;
+
+            var last = topMarker;
+            for (int i = 0; i < m_MarkerGUIs.Count; ++i)
+            {
+                var next = m_MarkerGUIs[i];
+                m_MarkerGUIs[i] = last;
+                last = next;
+            }
+
+            topMarker.zOrder = m_ZOrderProvider.Next();
+
+            topMarker.onStartDrag += OnDragTopMarker;
+        }
+
+        void OnDragTopMarker()
+        {
+            m_ManipulatedMarker = topMarker;
+            m_ManipulatedMarker.onStartDrag -= OnDragTopMarker;
+            m_MarkerGUIs.RemoveAt(m_MarkerGUIs.Count - 1);
+        }
+
+        void SortMarkers()
+        {
+            m_MarkerGUIs.Sort((lhs, rhs) => lhs.zOrder.CompareTo(rhs.zOrder));
+        }
+
+        void RegisterRect(WindowState state)
+        {
+            treeViewRect = topMarker.treeViewRect;
+
+            if (Event.current.type == EventType.Repaint && !parent.locked)
+                state.spacePartitioner.AddBounds(this, rect);
+        }
+
+        public static bool CanCycleMarkers()
+        {
+            if (!SelectionManager.SelectedMarkers().Any())
+                return false;
+
+            var cluster = PickerUtils.TopmostPickedItemOfType<TimelineMarkerClusterGUI>();
+
+            if (cluster == null)
+                return false;
+
+            // Only cycle if the marker is selected and nothing else is selected
+            return cluster.topMarker.IsSelected() && SelectionManager.Count() == 1;
+        }
+
+        public static void CycleMarkers()
+        {
+            var cluster = PickerUtils.TopmostPickedItemOfType<TimelineMarkerClusterGUI>();
+
+            if (cluster == null)
+                return;
+
+            cluster.topMarker.Deselect();
+            cluster.CycleTop();
+            cluster.topMarker.Select();
+        }
+    }
+}

Library/PackageCache/com.unity.timeline@1.7.6/Editor/treeview/ItemGui/TimelineMarkerClusterGUI.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2c03ae9aa36a4fd44a983831f44654be
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.timeline@1.7.6/Editor/treeview/ItemGui/TimelineMarkerGUI.cs

@@ -0,0 +1,193 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Timeline;
+using UnityObject = UnityEngine.Object;
+
+namespace UnityEditor.Timeline
+{
+    class TimelineMarkerGUI : TimelineItemGUI, ISnappable, IAttractable
+    {
+        public event System.Action onStartDrag;
+
+        int m_ProjectedClipHash = -1;
+        int m_MarkerHash;
+        bool m_Selectable;
+
+        MarkerDrawOptions m_MarkerDrawOptions;
+        MarkerEditor m_Editor;
+
+        IMarker marker { get; }
+
+        bool selectable
+        {
+            get { return m_Selectable; }
+        }
+
+        public double time
+        {
+            get { return marker.time; }
+        }
+
+        public override double start
+        {
+            get { return time; }
+        }
+
+        public override double end
+        {
+            get { return time; }
+        }
+
+        public override void Select()
+        {
+            zOrder = zOrderProvider.Next();
+            SelectionManager.Add(marker);
+            TimelineWindowViewPrefs.GetTrackViewModelData(parent.asset).markerTimeStamps[m_MarkerHash] = DateTime.UtcNow.Ticks;
+        }
+
+        public override bool IsSelected()
+        {
+            return SelectionManager.Contains(marker);
+        }
+
+        public override void Deselect()
+        {
+            SelectionManager.Remove(marker);
+        }
+
+        public override ITimelineItem item
+        {
+            get { return ItemsUtils.ToItem(marker); }
+        }
+
+        IZOrderProvider zOrderProvider { get; }
+
+        public TimelineMarkerGUI(IMarker theMarker, IRowGUI parent, IZOrderProvider provider) : base(parent)
+        {
+            marker = theMarker;
+            m_Selectable = marker.GetType().IsSubclassOf(typeof(UnityObject));
+
+            m_MarkerHash = 0;
+            var o = marker as object;
+            if (!o.Equals(null))
+                m_MarkerHash = o.GetHashCode();
+
+            zOrderProvider = provider;
+            zOrder = zOrderProvider.Next();
+            ItemToItemGui.Add(marker, this);
+            m_Editor = CustomTimelineEditorCache.GetMarkerEditor(theMarker);
+        }
+
+        int ComputeDirtyHash()
+        {
+            return time.GetHashCode();
+        }
+
+        static void DrawMarker(Rect drawRect, Type type, bool isSelected, bool isCollapsed, MarkerDrawOptions options)
+        {
+            if (Event.current.type == EventType.Repaint)
+            {
+                bool hasError = !string.IsNullOrEmpty(options.errorText);
+
+                var style = StyleManager.UssStyleForType(type);
+                style.Draw(drawRect, GUIContent.none, false, false, !isCollapsed, isSelected);
+
+                // case1141836: Use of GUI.Box instead of GUI.Label causes desync in UI controlID
+                if (hasError)
+                    GUI.Label(drawRect, String.Empty, DirectorStyles.Instance.markerWarning);
+
+                var tooltip = hasError ? options.errorText : options.tooltip;
+                if (!string.IsNullOrEmpty(tooltip) && drawRect.Contains(Event.current.mousePosition))
+                {
+                    GUIStyle.SetMouseTooltip(tooltip, drawRect);
+                }
+            }
+        }
+
+        void UpdateDrawData()
+        {
+            if (Event.current.type == EventType.Layout)
+            {
+                try
+                {
+                    m_MarkerDrawOptions = m_Editor.GetMarkerOptions(marker);
+                }
+                catch (Exception e)
+                {
+                    Debug.LogException(e);
+                    m_MarkerDrawOptions = CustomTimelineEditorCache.GetDefaultMarkerEditor().GetMarkerOptions(marker);
+                }
+            }
+        }
+
+        public override void Draw(Rect trackRect, bool trackRectChanged, WindowState state)
+        {
+            UpdateDrawData();
+
+            // compute marker hash
+            var currentMarkerHash = ComputeDirtyHash();
+
+            // update the clip projected rectangle on the timeline
+            CalculateClipRectangle(trackRect, state, currentMarkerHash, trackRectChanged);
+
+            var isSelected = selectable && SelectionManager.Contains(marker);
+            var showMarkers = parent.showMarkers;
+
+            QueueOverlay(treeViewRect, isSelected, !showMarkers);
+            DrawMarker(treeViewRect, marker.GetType(), isSelected, !showMarkers, m_MarkerDrawOptions);
+
+            if (Event.current.type == EventType.Repaint && showMarkers && !parent.locked)
+                state.spacePartitioner.AddBounds(this, rect);
+        }
+
+        public void QueueOverlay(Rect rect, bool isSelected, bool isCollapsed)
+        {
+            if (Event.current.type == EventType.Repaint && m_Editor.supportsDrawOverlay)
+            {
+                rect = GUIClip.Unclip(rect);
+                TimelineWindow.instance.AddUserOverlay(marker, rect, m_Editor, isCollapsed, isSelected);
+            }
+        }
+
+        public override void StartDrag()
+        {
+            if (onStartDrag != null)
+                onStartDrag.Invoke();
+        }
+
+        void CalculateClipRectangle(Rect trackRect, WindowState state, int projectedClipHash, bool trackRectChanged)
+        {
+            if (m_ProjectedClipHash == projectedClipHash && !trackRectChanged)
+                return;
+
+            m_ProjectedClipHash = projectedClipHash;
+            treeViewRect = RectToTimeline(trackRect, state);
+        }
+
+        public override Rect RectToTimeline(Rect trackRect, WindowState state)
+        {
+            var style = StyleManager.UssStyleForType(marker.GetType());
+            var width = style.fixedWidth;
+            var height = style.fixedHeight;
+            var x = ((float)marker.time * state.timeAreaScale.x) + state.timeAreaTranslation.x + trackRect.xMin;
+            x -= 0.5f * width;
+            return new Rect(x, trackRect.y, width, height);
+        }
+
+        public IEnumerable<Edge> SnappableEdgesFor(IAttractable attractable, ManipulateEdges manipulateEdges)
+        {
+            var edges = new List<Edge>();
+            var attractableGUI = attractable as TimelineMarkerGUI;
+            var canAddEdges = !(attractableGUI != null && attractableGUI.parent == parent);
+            if (canAddEdges)
+                edges.Add(new Edge(time));
+            return edges;
+        }
+
+        public bool ShouldSnapTo(ISnappable snappable)
+        {
+            return snappable != this;
+        }
+    }
+}

Library/PackageCache/com.unity.timeline@1.7.6/Editor/treeview/ItemGui/TimelineMarkerGUI.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8d34348f8b97a334291f5cf31adc5d67
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: