Inital commit

25 files changed, 1355 insertions, 0 deletions

diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalAssetInspector.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalAssetInspector.cs
new file mode 100644
index 0000000..1c8c6f9
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalAssetInspector.cs
@@ -0,0 +1,28 @@
+using JetBrains.Annotations;
+using UnityEngine;
+using UnityEngine.Timeline;
+
+namespace UnityEditor.Timeline.Signals
+{
+    [CustomEditor(typeof(SignalAsset))]
+    class SignalAssetInspector : Editor
+    {
+        [MenuItem("Assets/Create/Signal", false, 451)]
+        [UsedImplicitly]
+        public static void CreateNewSignal()
+        {
+            var icon = EditorGUIUtility.IconContent("SignalAsset Icon").image as Texture2D;
+            ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, CreateInstance<DoCreateSignalAsset>(), "New Signal.signal", icon, null);
+        }
+
+        class DoCreateSignalAsset : ProjectWindowCallback.EndNameEditAction
+        {
+            public override void Action(int instanceId, string pathName, string resourceFile)
+            {
+                var signalAsset = CreateInstance<SignalAsset>();
+                AssetDatabase.CreateAsset(signalAsset, pathName);
+                ProjectWindowUtil.ShowCreatedAsset(signalAsset);
+            }
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalAssetInspector.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalAssetInspector.cs.meta
new file mode 100644
index 0000000..a135f38
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalAssetInspector.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 58004290eb3aab44e9823d1f25c4ed73
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalEmitterEditor.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalEmitterEditor.cs
new file mode 100644
index 0000000..48c5690
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalEmitterEditor.cs
@@ -0,0 +1,23 @@
+using UnityEngine;
+using UnityEngine.Timeline;
+
+namespace UnityEditor.Timeline.Signals
+{
+    [CustomTimelineEditor(typeof(SignalEmitter))]
+    class SignalEmitterEditor : MarkerEditor
+    {
+        static readonly string MissingAssetError = LocalizationDatabase.GetLocalizedString("No signal assigned");
+
+        public override MarkerDrawOptions GetMarkerOptions(IMarker marker)
+        {
+            var options = base.GetMarkerOptions(marker);
+            SignalEmitter emitter = (SignalEmitter)marker;
+            if (emitter.asset != null)
+                options.tooltip = emitter.asset.name;
+            else
+                options.errorText = MissingAssetError;
+
+            return options;
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalEmitterEditor.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalEmitterEditor.cs.meta
new file mode 100644
index 0000000..4f40bf0
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalEmitterEditor.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 51a7878f6c989394782db73339e90e46
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalEmitterInspector.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalEmitterInspector.cs
new file mode 100644
index 0000000..bea45ad
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalEmitterInspector.cs
@@ -0,0 +1,377 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Playables;
+using UnityEngine.Timeline;
+using UnityObject = UnityEngine.Object;
+
+namespace UnityEditor.Timeline.Signals
+{
+    [CustomEditor(typeof(SignalEmitter), true)]
+    [CanEditMultipleObjects]
+    class SignalEmitterInspector : MarkerInspector, ISignalAssetProvider
+    {
+        SerializedProperty m_RetroactiveProperty;
+        SerializedProperty m_EmitOnceProperty;
+
+        SignalEmitter m_Signal;
+        GameObject m_BoundGameObject;
+        PlayableDirector m_AssociatedDirector;
+        bool m_TargetsHaveTheSameBinding;
+
+        readonly Dictionary<Component, Editor> m_Editors = new Dictionary<Component, Editor>();
+        readonly Dictionary<Component, bool> m_Foldouts = new Dictionary<Component, bool>();
+        List<Component> m_Receivers = new List<Component>();
+
+        static GUIStyle s_FoldoutStyle;
+        internal static GUIStyle foldoutStyle
+        {
+            get
+            {
+                if (s_FoldoutStyle == null)
+                {
+                    s_FoldoutStyle = new GUIStyle(EditorStyles.foldout) {fontStyle = FontStyle.Bold};
+                }
+
+                return s_FoldoutStyle;
+            }
+        }
+
+        public SignalAsset signalAsset
+        {
+            get
+            {
+                var emitter = target as SignalEmitter;
+                return signalAssetSameValue ? emitter.asset : null;
+            }
+            set
+            {
+                AssignSignalAsset(value);
+            }
+        }
+
+        bool signalAssetSameValue
+        {
+            get
+            {
+                var emitters = targets.Cast<SignalEmitter>().ToList();
+                return emitters.Select(x => x.asset).Distinct().Count() == 1;
+            }
+        }
+
+        void OnEnable()
+        {
+            Undo.undoRedoPerformed += OnUndoRedo; // subscribe to the event
+            m_Signal = target as SignalEmitter;
+            m_RetroactiveProperty = serializedObject.FindProperty("m_Retroactive");
+            m_EmitOnceProperty = serializedObject.FindProperty("m_EmitOnce");
+            // In a vast majority of the cases, when this becomes enabled,
+            // the timeline window will be focused on the correct timeline
+            // in which case TimelineEditor.inspectedDirector is safe to use
+            m_AssociatedDirector = TimelineEditor.inspectedDirector;
+            UpdateState();
+        }
+
+        internal override bool IsEnabled()
+        {
+            return TimelineUtility.IsCurrentSequenceValid() && !IsCurrentSequenceReadOnly() && base.IsEnabled();
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+
+            using (var changeScope = new EditorGUI.ChangeCheckScope())
+            {
+                var property = serializedObject.GetIterator();
+                var expanded = true;
+                while (property.NextVisible(expanded))
+                {
+                    expanded = false;
+                    if (SkipField(property.propertyPath))
+                        continue;
+                    EditorGUILayout.PropertyField(property, true);
+                }
+
+                DrawSignalFlags();
+                UpdateState();
+                DrawNameSelectorAndSignalList();
+
+                if (changeScope.changed)
+                {
+                    serializedObject.ApplyModifiedProperties();
+                    TimelineEditor.Refresh(RefreshReason.ContentsModified | RefreshReason.WindowNeedsRedraw);
+                }
+            }
+        }
+
+        internal override void OnHeaderIconGUI(Rect iconRect)
+        {
+            using (new EditorGUI.DisabledScope(!TimelineUtility.IsCurrentSequenceValid() || IsCurrentSequenceReadOnly()))
+            {
+                GUI.Label(iconRect, Styles.SignalEmitterIcon);
+            }
+        }
+
+        internal override Rect DrawHeaderHelpAndSettingsGUI(Rect r)
+        {
+            using (new EditorGUI.DisabledScope(!TimelineUtility.IsCurrentSequenceValid() || IsCurrentSequenceReadOnly()))
+            {
+                var helpSize = EditorStyles.iconButton.CalcSize(EditorGUI.GUIContents.helpIcon);
+                const int kTopMargin = 5;
+                return EditorGUIUtility.DrawEditorHeaderItems(new Rect(r.xMax - helpSize.x, r.y + kTopMargin, helpSize.x, helpSize.y), targets);
+            }
+        }
+
+        IEnumerable<SignalAsset> ISignalAssetProvider.AvailableSignalAssets()
+        {
+            return SignalManager.assets;
+        }
+
+        void ISignalAssetProvider.CreateNewSignalAsset(string path)
+        {
+            var newSignalAsset = SignalManager.CreateSignalAssetInstance(path);
+            AssignSignalAsset(newSignalAsset);
+            var receivers = m_Receivers.OfType<SignalReceiver>().ToList();
+            if (signalAsset != null && receivers.Count == 1 && !receivers.Any(r => r.IsSignalAssetHandled(newSignalAsset))) // Only when one receiver is present
+            {
+                receivers[0].AddNewReaction(newSignalAsset); // Add reaction on the first receiver from the list
+                ApplyChangesAndRefreshReceivers();
+            }
+        }
+
+        void UpdateState()
+        {
+            m_BoundGameObject = GetBoundGameObject(m_Signal.parent, m_AssociatedDirector);
+            m_Receivers = m_BoundGameObject == null || m_BoundGameObject.Equals(null)
+                ? new List<Component>()
+                : m_BoundGameObject.GetComponents<Component>().Where(t => t is INotificationReceiver).ToList();
+
+            m_TargetsHaveTheSameBinding = targets.Cast<SignalEmitter>()
+                .Select(x => GetBoundGameObject(x.parent, m_AssociatedDirector))
+                .Distinct().Count() == 1;
+        }
+
+        Editor GetOrCreateReceiverEditor(Component c)
+        {
+            Editor ret;
+            if (m_Editors.TryGetValue(c, out ret))
+            {
+                return ret;
+            }
+
+            ret = CreateEditorWithContext(new Object[] {c}, target);
+            m_Editors[c] = ret;
+            if (!m_Foldouts.ContainsKey(c))
+            {
+                m_Foldouts[c] = true;
+            }
+
+            return ret;
+        }
+
+        void OnDisable()
+        {
+            Undo.undoRedoPerformed -= OnUndoRedo;
+        }
+
+        void OnDestroy()
+        {
+            foreach (var editor in m_Editors)
+            {
+                DestroyImmediate(editor.Value);
+            }
+            m_Editors.Clear();
+        }
+
+        void OnUndoRedo()
+        {
+            ApplyChangesAndRefreshReceivers();
+        }
+
+        void ApplyChangesAndRefreshReceivers()
+        {
+            foreach (var receiverInspector in m_Editors.Values.OfType<SignalReceiverInspector>())
+            {
+                receiverInspector.SetAssetContext(signalAsset);
+            }
+        }
+
+        void DrawNameSelectorAndSignalList()
+        {
+            using (var change = new EditorGUI.ChangeCheckScope())
+            {
+                DrawSignal();
+                DrawReceivers();
+
+                if (change.changed)
+                {
+                    ApplyChangesAndRefreshReceivers();
+                }
+            }
+        }
+
+        void DrawReceivers()
+        {
+            if (!m_TargetsHaveTheSameBinding)
+            {
+                EditorGUILayout.HelpBox(Styles.MultiEditNotSupportedOnDifferentBindings, MessageType.None);
+                return;
+            }
+
+            if (targets.OfType<SignalEmitter>().Select(x => x.asset).Distinct().Count() > 1)
+            {
+                EditorGUILayout.HelpBox(Styles.MultiEditNotSupportedOnDifferentSignals, MessageType.None);
+                return;
+            }
+
+            //do not display the receiver if the current timeline is not the same as the emitter's timeline
+            //can happen if the inspector is locked
+            if (m_Signal.parent != null && m_Signal.parent.timelineAsset != TimelineEditor.inspectedAsset)
+                return;
+
+            if (m_BoundGameObject != null)
+            {
+                if (!m_Receivers.Any(x => x is SignalReceiver))
+                {
+                    EditorGUILayout.Separator();
+                    var message = string.Format(Styles.NoSignalReceiverComponent, m_BoundGameObject.name);
+                    SignalUtility.DrawCenteredMessage(message);
+                    if (SignalUtility.DrawCenteredButton(Styles.AddSignalReceiverComponent))
+                        AddReceiverComponent();
+                }
+
+                foreach (var receiver in m_Receivers)
+                {
+                    var editor = GetOrCreateReceiverEditor(receiver);
+                    if (DrawReceiverHeader(receiver))
+                    {
+                        editor.OnInspectorGUI();
+                    }
+                }
+            }
+            else if (m_AssociatedDirector != null) //not in asset mode
+            {
+                EditorGUILayout.HelpBox(Styles.NoBoundGO, MessageType.None);
+            }
+        }
+
+        void DrawSignalFlags()
+        {
+            EditorGUILayout.PropertyField(m_RetroactiveProperty, Styles.RetroactiveLabel);
+            EditorGUILayout.PropertyField(m_EmitOnceProperty, Styles.EmitOnceLabel);
+        }
+
+        void DrawSignal()
+        {
+            //should show button to create new signal if there are no signals asset in the project
+            if (!SignalManager.assets.Any())
+            {
+                using (new EditorGUI.DisabledScope(true))
+                {
+                    DrawNameSelector();
+                }
+
+                EditorGUILayout.Separator();
+                SignalUtility.DrawCenteredMessage(Styles.ProjectHasNoSignalAsset);
+                if (SignalUtility.DrawCenteredButton(Styles.CreateNewSignal))
+                    CreateNewSignalAsset(SignalUtility.GetNewSignalPath());
+                EditorGUILayout.Separator();
+            }
+            else
+            {
+                DrawNameSelector();
+            }
+        }
+
+        internal void CreateNewSignalAsset(string path)
+        {
+            if (!string.IsNullOrEmpty(path))
+                ((ISignalAssetProvider)this).CreateNewSignalAsset(path);
+            GUIUtility.ExitGUI();
+        }
+
+        void AssignSignalAsset(SignalAsset newAsset)
+        {
+            foreach (var o in targets)
+            {
+                var signalEmitter = (SignalEmitter)o;
+                TimelineUndo.PushUndo(signalEmitter, Styles.UndoCreateSignalAsset);
+                signalEmitter.asset = newAsset;
+            }
+        }
+
+        void DrawNameSelector()
+        {
+            SignalUtility.DrawSignalNames(this, EditorGUILayout.GetControlRect(), Styles.EmitSignalLabel, !signalAssetSameValue);
+        }
+
+        bool DrawReceiverHeader(Component receiver)
+        {
+            EditorGUILayout.Space();
+            var lineRect = GUILayoutUtility.GetRect(10, 4, EditorStyles.inspectorTitlebar);
+            DrawSplitLine(lineRect.y);
+
+            var style = EditorGUIUtility.TrTextContentWithIcon(
+                ObjectNames.NicifyVariableName(receiver.GetType().Name),
+                AssetPreview.GetMiniThumbnail(receiver));
+
+            m_Foldouts[receiver] =
+                EditorGUILayout.Foldout(m_Foldouts[receiver], style, true, foldoutStyle);
+            if (m_Foldouts[receiver])
+            {
+                DrawReceiverObjectField();
+            }
+
+            return m_Foldouts[receiver];
+        }
+
+        void DrawReceiverObjectField()
+        {
+            EditorGUI.BeginDisabledGroup(true);
+            EditorGUILayout.ObjectField(Styles.ObjectLabel, m_BoundGameObject, typeof(GameObject), false);
+            EditorGUI.EndDisabledGroup();
+        }
+
+        void AddReceiverComponent()
+        {
+            var receiver = Undo.AddComponent<SignalReceiver>(m_BoundGameObject);
+            receiver.AddNewReaction(signalAsset);
+        }
+
+        static bool SkipField(string fieldName)
+        {
+            return fieldName == "m_Script" || fieldName == "m_Asset" || fieldName == "m_Retroactive" || fieldName == "m_EmitOnce";
+        }
+
+        static void DrawSplitLine(float y)
+        {
+            if (Event.current.type != EventType.Repaint) return;
+
+            var width = EditorGUIUtility.currentViewWidth;
+            var position = new Rect(0, y, width + 1, 1);
+
+            if (EditorStyles.inspectorTitlebar != null)
+                EditorStyles.inspectorTitlebar.Draw(position, false, false, false, false);
+        }
+
+        static GameObject GetBoundGameObject(TrackAsset track, PlayableDirector associatedDirector)
+        {
+            if (associatedDirector == null || track == null) //if in asset mode, no bound object for you
+                return null;
+
+            var boundObj = TimelineUtility.GetSceneGameObject(associatedDirector, track);
+
+            //if the signal is on the timeline marker track and user did not set a binding, assume it's bound to PlayableDirector
+            if (boundObj == null && track.timelineAsset.markerTrack == track)
+                boundObj = associatedDirector.gameObject;
+
+            return boundObj;
+        }
+
+        static bool IsCurrentSequenceReadOnly()
+        {
+            return TimelineWindow.instance.state.editSequence.isReadOnly;
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalEmitterInspector.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalEmitterInspector.cs.meta
new file mode 100644
index 0000000..d89a36c
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalEmitterInspector.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 970e7735a0864fd40842a36d053d08fe
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalEventDrawer.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalEventDrawer.cs
new file mode 100644
index 0000000..021c6c7
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalEventDrawer.cs
@@ -0,0 +1,39 @@
+using System;
+using JetBrains.Annotations;
+using UnityEditorInternal;
+using UnityEngine;
+using UnityEngine.Timeline;
+
+namespace UnityEditor.Timeline.Signals
+{
+    [CustomPropertyDrawer(typeof(CustomSignalEventDrawer))]
+    [UsedImplicitly]
+    class SignalEventDrawer : UnityEventDrawer
+    {
+        static GameObject FindBoundObject(SerializedProperty property)
+        {
+            var component = property.serializedObject.targetObject as Component;
+            return component != null ? component.gameObject : null;
+        }
+
+        protected override void OnAddEvent(ReorderableList list)
+        {
+            base.OnAddEvent(list);
+            var listProperty = list.serializedProperty;
+            if (listProperty.arraySize > 0)
+            {
+                var lastCall = list.serializedProperty.GetArrayElementAtIndex(listProperty.arraySize - 1);
+                var targetProperty = lastCall.FindPropertyRelative(kInstancePath);
+                targetProperty.objectReferenceValue = FindBoundObject(listProperty);
+            }
+        }
+
+        protected override void DrawEventHeader(Rect headerRect) {}
+
+        protected override void SetupReorderableList(ReorderableList list)
+        {
+            base.SetupReorderableList(list);
+            list.headerHeight = 4;
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalEventDrawer.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalEventDrawer.cs.meta
new file mode 100644
index 0000000..26afa8d
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalEventDrawer.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6ba7805325c426c43b8e85b5be4eae36
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalManager.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalManager.cs
new file mode 100644
index 0000000..4beec0c
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalManager.cs
@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using UnityEngine;
+using UnityEngine.Timeline;
+using Object = UnityEngine.Object;
+
+namespace UnityEditor.Timeline.Signals
+{
+    class SignalManager : IDisposable
+    {
+        static SignalManager m_Instance;
+        readonly List<SignalAsset> m_assets = new List<SignalAsset>();
+
+        internal static SignalManager instance
+        {
+            get
+            {
+                if (m_Instance == null)
+                {
+                    m_Instance = new SignalManager();
+                    m_Instance.Refresh();
+                }
+
+                return m_Instance;
+            }
+
+            set { m_Instance = value; }
+        }
+
+        internal SignalManager()
+        {
+            SignalAsset.OnEnableCallback += Register;
+        }
+
+        public static IEnumerable<SignalAsset> assets
+        {
+            get
+            {
+                foreach (var asset in instance.m_assets)
+                {
+                    if (asset != null)
+                        yield return asset;
+                }
+            }
+        }
+
+        public static SignalAsset CreateSignalAssetInstance(string path)
+        {
+            var newSignal = ScriptableObject.CreateInstance<SignalAsset>();
+            newSignal.name = Path.GetFileNameWithoutExtension(path);
+
+            var asset = AssetDatabase.LoadMainAssetAtPath(path) as SignalAsset;
+            if (asset != null)
+            {
+                TimelineUndo.PushUndo(asset, Styles.UndoCreateSignalAsset);
+                EditorUtility.CopySerialized(newSignal, asset);
+                Object.DestroyImmediate(newSignal);
+                return asset;
+            }
+
+            AssetDatabase.CreateAsset(newSignal, path);
+            return newSignal;
+        }
+
+        public void Dispose()
+        {
+            SignalAsset.OnEnableCallback -= Register;
+        }
+
+        void Register(SignalAsset a)
+        {
+            m_assets.Add(a);
+        }
+
+        void Refresh()
+        {
+            var guids = AssetDatabase.FindAssets("t:SignalAsset");
+            foreach (var g in guids)
+            {
+                var path = AssetDatabase.GUIDToAssetPath(g);
+                var asset = AssetDatabase.LoadAssetAtPath<SignalAsset>(path);
+                m_assets.Add(asset);
+            }
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalManager.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalManager.cs.meta
new file mode 100644
index 0000000..528ec1d
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalManager.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 255b0c6d400fd964dab3029c8abc53f4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalReceiverHeader.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalReceiverHeader.cs
new file mode 100644
index 0000000..55e8d27
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalReceiverHeader.cs
@@ -0,0 +1,15 @@
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+
+namespace UnityEditor.Timeline.Signals
+{
+    class SignalReceiverHeader : MultiColumnHeader
+    {
+        public SignalReceiverHeader(MultiColumnHeaderState state) : base(state) {}
+
+        protected override void AddColumnHeaderContextMenuItems(GenericMenu menu)
+        {
+            menu.AddItem(EditorGUIUtility.TrTextContent("Resize to Fit"), false, ResizeToFit);
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalReceiverHeader.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalReceiverHeader.cs.meta
new file mode 100644
index 0000000..211c810
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalReceiverHeader.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 423cd382a7804414d9bfdb2e7fb7bb62
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalReceiverInspector.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalReceiverInspector.cs
new file mode 100644
index 0000000..52211e1
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalReceiverInspector.cs
@@ -0,0 +1,116 @@
+using UnityEngine;
+using UnityObject = UnityEngine.Object;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine.Events;
+using UnityEngine.Timeline;
+
+namespace UnityEditor.Timeline.Signals
+{
+    [CustomEditor(typeof(SignalReceiver))]
+    class SignalReceiverInspector : Editor
+    {
+        SignalReceiver m_Target;
+
+        [SerializeField] TreeViewState m_TreeState;
+        [SerializeField] MultiColumnHeaderState m_MultiColumnHeaderState;
+        internal SignalReceiverTreeView m_TreeView;
+
+        SignalEmitter signalEmitterContext
+        {
+            get { return m_Context as SignalEmitter;}
+        }
+
+        void OnEnable()
+        {
+            m_Target = target as SignalReceiver;
+            InitTreeView(serializedObject);
+
+            Undo.undoRedoPerformed += OnUndoRedo;
+        }
+
+        void OnDisable()
+        {
+            Undo.undoRedoPerformed -= OnUndoRedo;
+        }
+
+        void OnUndoRedo()
+        {
+            m_TreeView.dirty = true;
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+
+            using (var changeCheck = new EditorGUI.ChangeCheckScope())
+            {
+                m_TreeView.RefreshIfDirty();
+                DrawEmitterControls(); // Draws buttons coming from the Context (SignalEmitter)
+
+                EditorGUILayout.Space();
+                m_TreeView.Draw();
+
+                if (signalEmitterContext == null)
+                    DrawAddRemoveButtons();
+
+                if (changeCheck.changed)
+                {
+                    serializedObject.ApplyModifiedProperties();
+                    m_TreeView.dirty = true;
+                }
+            }
+        }
+
+        void DrawEmitterControls()
+        {
+            var context = signalEmitterContext;
+            if (context != null)
+            {
+                var currentSignal = context.asset;
+                if (currentSignal != null && !m_Target.IsSignalAssetHandled(currentSignal))
+                {
+                    EditorGUILayout.Separator();
+                    var message = string.Format(Styles.NoReaction, currentSignal.name);
+                    SignalUtility.DrawCenteredMessage(message);
+                    if (SignalUtility.DrawCenteredButton(Styles.AddReactionButton))
+                        m_Target.AddNewReaction(currentSignal); // Add reaction on the first
+                    EditorGUILayout.Separator();
+                }
+            }
+        }
+
+        internal void SetAssetContext(SignalAsset asset)
+        {
+            m_TreeView.SetSignalContext(asset);
+        }
+
+        void DrawAddRemoveButtons()
+        {
+            using (new GUILayout.HorizontalScope())
+            {
+                GUILayout.FlexibleSpace();
+                if (GUILayout.Button(Styles.AddReactionButton))
+                {
+                    Undo.RecordObject(m_Target, Styles.UndoAddReaction);
+                    m_Target.AddEmptyReaction(new UnityEvent());
+                    PrefabUtility.RecordPrefabInstancePropertyModifications(m_Target);
+                }
+                GUILayout.Space(18.0f);
+            }
+        }
+
+        void InitTreeView(SerializedObject so)
+        {
+            m_TreeState = SignalListFactory.CreateViewState();
+            m_MultiColumnHeaderState = SignalListFactory.CreateHeaderState();
+            var header = SignalListFactory.CreateHeader(m_MultiColumnHeaderState, SignalReceiverUtility.headerHeight);
+
+            var context = signalEmitterContext;
+            m_TreeView = SignalListFactory.CreateSignalInspectorList(m_TreeState, header, m_Target, so);
+            m_TreeView.readonlySignals = context != null;
+
+            if (context != null)
+                m_TreeView.SetSignalContext(context.asset);
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalReceiverInspector.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalReceiverInspector.cs.meta
new file mode 100644
index 0000000..a764c95
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalReceiverInspector.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 70b265ed18dc14041bedc0263d4578ef
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalUtility.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalUtility.cs
new file mode 100644
index 0000000..663e341
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalUtility.cs
@@ -0,0 +1,125 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.Timeline;
+
+namespace UnityEditor.Timeline.Signals
+{
+    interface ISignalAssetProvider
+    {
+        SignalAsset signalAsset { get; set; }
+        IEnumerable<SignalAsset> AvailableSignalAssets();
+        void CreateNewSignalAsset(string path);
+    }
+
+    static class SignalUtility
+    {
+        const string k_SignalExtension = "signal";
+
+        public static void DrawSignalNames(ISignalAssetProvider assetProvider, Rect position, GUIContent label, bool multipleValues)
+        {
+            var assets = assetProvider.AvailableSignalAssets().ToList();
+            var index = assets.IndexOf(assetProvider.signalAsset);
+
+            var availableNames = new List<string>();
+            using (new GUIMixedValueScope(multipleValues))
+            {
+                availableNames.Add(Styles.EmptySignalList.text);
+
+                availableNames.AddRange(assets.Select(x => x.name));
+                availableNames.Add(Styles.CreateNewSignal.text);
+
+                var curValue = index + 1;
+                var selected = EditorGUI.Popup(position, label, curValue, availableNames.ToArray());
+
+                if (selected != curValue)
+                {
+                    var noneEntryIdx = 0;
+                    if (selected == noneEntryIdx) // None
+                        assetProvider.signalAsset = null;
+                    else if (selected == availableNames.Count - 1) // "Create New Asset"
+                    {
+                        var path = GetNewSignalPath();
+                        if (!string.IsNullOrEmpty(path))
+                            assetProvider.CreateNewSignalAsset(path);
+                        GUIUtility.ExitGUI();
+                    }
+                    else
+                        assetProvider.signalAsset = assets[selected - 1];
+                }
+            }
+        }
+
+        public static string GetNewSignalPath()
+        {
+            return EditorUtility.SaveFilePanelInProject(
+                Styles.NewSignalWindowTitle.text,
+                Styles.NewSignalDefaultName.text,
+                k_SignalExtension,
+                Styles.NewSignalWindowMessage.text);
+        }
+
+        public static bool IsSignalAssetHandled(this SignalReceiver receiver, SignalAsset asset)
+        {
+            return receiver != null && asset != null && receiver.GetRegisteredSignals().Contains(asset);
+        }
+
+        public static void AddNewReaction(this SignalReceiver receiver, SignalAsset signalAsset)
+        {
+            if (signalAsset != null && receiver != null)
+            {
+                Undo.RecordObject(receiver, Styles.UndoAddReaction);
+                var newEvent = new UnityEvent();
+                newEvent.AddPersistentListener();
+                var evtIndex = newEvent.GetPersistentEventCount() - 1;
+                newEvent.RegisterVoidPersistentListenerWithoutValidation(evtIndex, receiver.gameObject, string.Empty);
+                receiver.AddReaction(signalAsset, newEvent);
+                PrefabUtility.RecordPrefabInstancePropertyModifications(receiver);
+            }
+        }
+
+        public static void DrawCenteredMessage(string message)
+        {
+            using (new GUILayout.HorizontalScope())
+            {
+                GUILayout.FlexibleSpace();
+                GUILayout.Label(message);
+                GUILayout.FlexibleSpace();
+            }
+        }
+
+        public static bool DrawCenteredButton(GUIContent buttonLabel)
+        {
+            bool buttonClicked;
+            using (new GUILayout.HorizontalScope())
+            {
+                GUILayout.FlexibleSpace();
+                buttonClicked = GUILayout.Button(buttonLabel);
+                GUILayout.FlexibleSpace();
+            }
+            return buttonClicked;
+        }
+    }
+
+    static class SignalReceiverUtility
+    {
+        const int k_DefaultTreeviewHeaderHeight = 20;
+
+        public static int headerHeight
+        {
+            get { return k_DefaultTreeviewHeaderHeight; }
+        }
+
+        public static SerializedProperty FindSignalsProperty(SerializedObject obj)
+        {
+            return obj.FindProperty("m_Events.m_Signals");
+        }
+
+        public static SerializedProperty FindEventsProperty(SerializedObject obj)
+        {
+            return obj.FindProperty("m_Events.m_Events");
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalUtility.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalUtility.cs.meta
new file mode 100644
index 0000000..f29c92c
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/SignalUtility.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b33687803b08daf418e5315de17658b8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/Styles.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/Styles.cs
new file mode 100644
index 0000000..6842081
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/Styles.cs
@@ -0,0 +1,39 @@
+using UnityEngine;
+
+namespace UnityEditor.Timeline.Signals
+{
+    static class Styles
+    {
+        public static readonly GUIContent RetroactiveLabel = EditorGUIUtility.TrTextContent("Retroactive", "Use retroactive to emit this signal even if playback starts afterwards.");
+        public static readonly GUIContent EmitOnceLabel = EditorGUIUtility.TrTextContent("Emit Once", "Emit the signal once during loops.");
+        public static readonly GUIContent EmitSignalLabel = EditorGUIUtility.TrTextContent("Emit Signal", "Select which Signal Asset to emit.");
+        public static readonly GUIContent ObjectLabel = EditorGUIUtility.TrTextContent("Receiver Component on", "The Signal Receiver Component on the bound GameObject.");
+
+        public static readonly GUIContent CreateNewSignal = EditorGUIUtility.TrTextContent("Create Signal…");
+        public static readonly GUIContent AddSignalReceiverComponent = EditorGUIUtility.TrTextContent("Add Signal Receiver", "Creates a Signal Receiver component on the track binding and the reaction for the current signal.");
+        public static readonly GUIContent EmptySignalList = EditorGUIUtility.TrTextContent("None");
+        public static readonly GUIContent AddReactionButton = EditorGUIUtility.TrTextContent("Add Reaction");
+
+        public static readonly GUIContent NewSignalWindowTitle = EditorGUIUtility.TrTextContent("Create Signal Key");
+        public static readonly GUIContent NewSignalDefaultName = EditorGUIUtility.TrTextContent("New Signal");
+        public static readonly GUIContent NewSignalWindowMessage = EditorGUIUtility.TrTextContent("Create Signal Key");
+
+        public static readonly string SignalListDuplicateOption = L10n.Tr("Duplicate");
+        public static readonly string SignalListDeleteOption = L10n.Tr("Delete");
+        public static readonly string NoBoundGO = L10n.Tr("Track has no bound GameObject.");
+        public static readonly string MultiEditNotSupportedOnDifferentBindings = L10n.Tr("Multi-edit not supported for SignalReceivers on tracks bound to different GameObjects.");
+        public static readonly string MultiEditNotSupportedOnDifferentSignals = L10n.Tr("Multi-edit not supported for SignalReceivers when SignalEmitters use different Signals.");
+
+        public static readonly string UndoCreateSignalAsset = L10n.Tr("Create New Signal Asset");
+        public static readonly string UndoDuplicateRow = L10n.Tr("Duplicate Row");
+        public static readonly string UndoDeleteRow = L10n.Tr("Delete Row");
+        public static readonly string UndoAddReaction = L10n.Tr("Add Signal Receiver Reaction");
+        public static readonly string NoReaction = L10n.Tr("No reaction for {0} has been defined in this receiver");
+        public static readonly string NoSignalReceiverComponent = L10n.Tr("There is no Signal Receiver component on {0}");
+        public static readonly string ProjectHasNoSignalAsset = L10n.Tr("Your project contains no Signal assets");
+
+        //Icons
+        public static readonly GUIStyle OptionsStyle = DirectorStyles.GetGUIStyle("Icon.Options");
+        public static readonly GUIContent SignalEmitterIcon = EditorGUIUtility.IconContent("SignalEmitter Icon");
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/Styles.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/Styles.cs.meta
new file mode 100644
index 0000000..da7c028
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/Styles.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 685f63932bebd0c4db02ee14845191e2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView.meta
new file mode 100644
index 0000000..d8cac35
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5ba130fc1db953547a50bcf5c162a3e8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView/SignalListFactory.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView/SignalListFactory.cs
new file mode 100644
index 0000000..1b59ec6
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView/SignalListFactory.cs
@@ -0,0 +1,31 @@
+using System;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine.Timeline;
+
+namespace UnityEditor.Timeline.Signals
+{
+    static class SignalListFactory
+    {
+        public static SignalReceiverTreeView CreateSignalInspectorList(TreeViewState state, SignalReceiverHeader header, SignalReceiver target, SerializedObject so)
+        {
+            return new SignalReceiverTreeView(state, header, target, so);
+        }
+
+        public static  SignalReceiverHeader CreateHeader(MultiColumnHeaderState state, int columnHeight)
+        {
+            var header = new SignalReceiverHeader(state) { height = columnHeight };
+            header.ResizeToFit();
+            return header;
+        }
+
+        public static MultiColumnHeaderState CreateHeaderState()
+        {
+            return new MultiColumnHeaderState(SignalReceiverTreeView.GetColumns());
+        }
+
+        public static TreeViewState CreateViewState()
+        {
+            return new TreeViewState();
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView/SignalListFactory.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView/SignalListFactory.cs.meta
new file mode 100644
index 0000000..fcc2a87
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView/SignalListFactory.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 01cd96d8687272f4898cfd1562079dd7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView/SignalReceiverItem.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView/SignalReceiverItem.cs
new file mode 100644
index 0000000..a58b2fe
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView/SignalReceiverItem.cs
@@ -0,0 +1,180 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.Timeline;
+using Object = UnityEngine.Object;
+
+namespace UnityEditor.Timeline.Signals
+{
+    class SignalReceiverItem : TreeViewItem, ISignalAssetProvider
+    {
+        static readonly SignalEventDrawer k_EvtDrawer = new SignalEventDrawer();
+
+        readonly SerializedProperty m_Asset;
+        readonly SerializedProperty m_Evt;
+        readonly SignalReceiverTreeView m_TreeView;
+
+        int m_CurrentRowIdx;
+        SignalReceiver m_CurrentReceiver;
+
+        internal readonly bool enabled;
+        internal readonly bool readonlySignal;
+
+        internal const string SignalName = "SignalName";
+        internal const string SignalNameReadOnly = "SignalNameReadOnly";
+        internal const string SignalOptions = "SignalOptions";
+
+        public SignalReceiverItem(SerializedProperty signalAsset, SerializedProperty eventListEntry, int id, bool readonlySignal, bool enabled, SignalReceiverTreeView treeView)
+            : base(id, 0)
+        {
+            m_Asset = signalAsset;
+            m_Evt = eventListEntry;
+            this.enabled = enabled;
+            this.readonlySignal = readonlySignal;
+            m_TreeView = treeView;
+        }
+
+        public SignalAsset signalAsset
+        {
+            get { return m_CurrentReceiver.GetSignalAssetAtIndex(m_CurrentRowIdx); }
+            set
+            {
+                Undo.RecordObject(m_CurrentReceiver, Styles.UndoCreateSignalAsset);
+                m_CurrentReceiver.ChangeSignalAtIndex(m_CurrentRowIdx, value);
+                PrefabUtility.RecordPrefabInstancePropertyModifications(m_CurrentReceiver);
+            }
+        }
+
+        public float GetHeight()
+        {
+            return k_EvtDrawer.GetPropertyHeight(m_Evt, GUIContent.none);
+        }
+
+        public void Draw(Rect rect, int colIdx, int rowIdx, float padding, SignalReceiver target)
+        {
+            switch (colIdx)
+            {
+                case 0:
+                    DrawSignalNameColumn(rect, padding, target, rowIdx);
+                    break;
+                case 1:
+                    DrawReactionColumn(rect, rowIdx);
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        void DrawSignalNameColumn(Rect rect, float padding, SignalReceiver target, int rowIdx)
+        {
+            using (new EditorGUI.DisabledScope(!enabled))
+            {
+                if (!readonlySignal)
+                {
+                    m_CurrentRowIdx = rowIdx;
+                    m_CurrentReceiver = target;
+
+                    rect.x += padding;
+                    rect.width -= padding;
+                    rect.height = EditorGUIUtility.singleLineHeight;
+                    GUI.SetNextControlName(SignalName);
+                    SignalUtility.DrawSignalNames(this, rect, GUIContent.none, false);
+                }
+                else
+                {
+                    GUI.SetNextControlName(SignalNameReadOnly);
+                    var signalAsset = m_Asset.objectReferenceValue;
+                    GUI.Label(rect,
+                        signalAsset != null
+                        ? EditorGUIUtility.TempContent(signalAsset.name)
+                        : Styles.EmptySignalList);
+                }
+            }
+        }
+
+        void DrawReactionColumn(Rect rect, int rowIdx)
+        {
+            if (!readonlySignal)
+            {
+                var optionButtonSize = GetOptionButtonSize();
+                rect.width -= optionButtonSize.x;
+
+                var optionButtonRect = new Rect
+                {
+                    x = rect.xMax,
+                    y = rect.y,
+                    width = optionButtonSize.x,
+                    height = optionButtonSize.y
+                };
+                DrawOptionsButton(optionButtonRect, rowIdx, m_CurrentReceiver);
+            }
+
+            using (new EditorGUI.DisabledScope(!enabled))
+            {
+                var nameAsString = m_Asset.objectReferenceValue == null ? "Null" : m_Asset.objectReferenceValue.name;
+                using (var change = new EditorGUI.ChangeCheckScope())
+                {
+                    EditorGUI.PropertyField(rect, m_Evt, EditorGUIUtility.TempContent(nameAsString));
+                    if (change.changed)
+                        m_TreeView.dirty = true;
+                }
+            }
+        }
+
+        static Vector2 GetOptionButtonSize()
+        {
+            EditorGUIUtility.SetIconSize(Vector2.zero);
+            return EditorStyles.iconButton.CalcSize(EditorGUI.GUIContents.titleSettingsIcon);
+        }
+
+        void DrawOptionsButton(Rect rect, int rowIdx, SignalReceiver target)
+        {
+            GUI.SetNextControlName(SignalOptions);
+            if (EditorGUI.DropdownButton(rect, EditorGUI.GUIContents.titleSettingsIcon, FocusType.Passive, EditorStyles.iconButton))
+            {
+                var menu = new GenericMenu();
+                menu.AddItem(new GUIContent(Styles.SignalListDuplicateOption), false, () =>
+                {
+                    Undo.RecordObject(target, Styles.UndoDuplicateRow);
+                    var evtCloner = ScriptableObject.CreateInstance<UnityEventCloner>();
+                    evtCloner.evt = target.GetReactionAtIndex(rowIdx);
+                    var clone = Object.Instantiate(evtCloner);
+                    target.AddEmptyReaction(clone.evt);
+                    m_TreeView.dirty = true;
+                    PrefabUtility.RecordPrefabInstancePropertyModifications(target);
+
+                });
+                menu.AddItem(new GUIContent(Styles.SignalListDeleteOption), false, () =>
+                {
+                    Undo.RecordObject(target, Styles.UndoDeleteRow);
+                    target.RemoveAtIndex(rowIdx);
+                    m_TreeView.dirty = true;
+                    PrefabUtility.RecordPrefabInstancePropertyModifications(target);
+                });
+                menu.ShowAsContext();
+            }
+        }
+
+        IEnumerable<SignalAsset> ISignalAssetProvider.AvailableSignalAssets()
+        {
+            var ret = SignalManager.assets.Except(m_CurrentReceiver.GetRegisteredSignals());
+            return signalAsset == null ? ret : ret.Union(new List<SignalAsset> {signalAsset}).ToList();
+        }
+
+        void ISignalAssetProvider.CreateNewSignalAsset(string path)
+        {
+            var newSignalAsset = SignalManager.CreateSignalAssetInstance(path);
+            Undo.RecordObject(m_CurrentReceiver, Styles.UndoCreateSignalAsset);
+            m_CurrentReceiver.ChangeSignalAtIndex(m_CurrentRowIdx, newSignalAsset);
+            PrefabUtility.RecordPrefabInstancePropertyModifications(m_CurrentReceiver);
+        }
+
+        class UnityEventCloner : ScriptableObject
+        {
+            public UnityEvent evt;
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView/SignalReceiverItem.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView/SignalReceiverItem.cs.meta
new file mode 100644
index 0000000..826e615
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView/SignalReceiverItem.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9bc2b69915879416f8df18971dc98e2e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView/SignalReceiverTreeView.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView/SignalReceiverTreeView.cs
new file mode 100644
index 0000000..abacd72
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView/SignalReceiverTreeView.cs
@@ -0,0 +1,155 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+using UnityEngine.Timeline;
+
+namespace UnityEditor.Timeline.Signals
+{
+    class SignalReceiverTreeView : TreeView
+    {
+        public bool dirty { private get; set; }
+
+        SerializedProperty signals { get; set; }
+        SerializedProperty events { get; set; }
+
+        readonly SignalReceiver m_Target;
+
+        const float k_VerticalPadding = 5;
+        const float k_HorizontalPadding = 5;
+
+        public SignalReceiverTreeView(TreeViewState state, MultiColumnHeader multiColumnHeader, SignalReceiver receiver, SerializedObject serializedObject)
+            : base(state, multiColumnHeader)
+        {
+            m_Target = receiver;
+            useScrollView = true;
+            SetSerializedProperties(serializedObject);
+            getNewSelectionOverride = (item, selection, shift) => new List<int>(); // Disable Selection
+        }
+
+        SignalAsset signalAssetContext { get; set; }
+        public bool readonlySignals { get; set; }
+
+        public void SetSignalContext(SignalAsset assetContext = null)
+        {
+            signalAssetContext = assetContext;
+            dirty = true;
+        }
+
+        void SetSerializedProperties(SerializedObject serializedObject)
+        {
+            signals = SignalReceiverUtility.FindSignalsProperty(serializedObject);
+            events = SignalReceiverUtility.FindEventsProperty(serializedObject);
+            Reload();
+        }
+
+        public void Draw()
+        {
+            var rect = EditorGUILayout.GetControlRect(true, GetTotalHeight());
+            OnGUI(rect);
+        }
+
+        public void RefreshIfDirty()
+        {
+            var signalsListSizeHasChanged = signals.arraySize != GetRows().Count;
+            if (dirty || signalsListSizeHasChanged)
+                Reload();
+            dirty = false;
+        }
+
+        public static MultiColumnHeaderState.Column[] GetColumns()
+        {
+            return new[]
+            {
+                new MultiColumnHeaderState.Column
+                {
+                    headerContent = EditorGUIUtility.TrTextContent("Signal"),
+                    contextMenuText = "",
+                    headerTextAlignment = TextAlignment.Center,
+                    width = 50, minWidth = 50,
+                    autoResize = true,
+                    allowToggleVisibility = false,
+                    canSort = false
+                },
+                new MultiColumnHeaderState.Column
+                {
+                    headerContent = EditorGUIUtility.TrTextContent("Reaction"),
+                    contextMenuText = "",
+                    headerTextAlignment = TextAlignment.Center,
+                    width = 120, minWidth = 120,
+                    autoResize = true,
+                    allowToggleVisibility = false,
+                    canSort = false
+                }
+            };
+        }
+
+        protected override TreeViewItem BuildRoot()
+        {
+            var root = new TreeViewItem(-1, -1) { children = new List<TreeViewItem>() };
+
+            var matchingId = signalAssetContext != null && readonlySignals ? FindIdForSignal(signals, signalAssetContext) : -1;
+            if (matchingId >= 0)
+                AddItem(root, matchingId);
+
+            for (var i = 0; i < signals.arraySize; ++i)
+            {
+                if (i == matchingId) continue;
+                AddItem(root, i, !readonlySignals);
+            }
+
+            return root;
+        }
+
+        protected override void RowGUI(RowGUIArgs args)
+        {
+            var item = (SignalReceiverItem)args.item;
+            for (var i = 0; i < args.GetNumVisibleColumns(); ++i)
+            {
+                var rect = args.GetCellRect(i);
+                rect.y += k_VerticalPadding;
+                item.Draw(rect, args.GetColumn(i), args.row, k_HorizontalPadding, m_Target);
+            }
+        }
+
+        protected override float GetCustomRowHeight(int row, TreeViewItem treeItem)
+        {
+            var item = treeItem as SignalReceiverItem;
+            return item.GetHeight() + k_VerticalPadding;
+        }
+
+        void AddItem(TreeViewItem root, int id, bool enabled = true)
+        {
+            var signal = signals.GetArrayElementAtIndex(id);
+            var evt = events.GetArrayElementAtIndex(id);
+            root.children.Add(new SignalReceiverItem(signal, evt, id, readonlySignals, enabled, this));
+        }
+
+        float GetTotalHeight()
+        {
+            var height = 0.0f;
+            foreach (var item in GetRows())
+            {
+                var signalListItem = item as SignalReceiverItem;
+                height += signalListItem.GetHeight() + k_VerticalPadding;
+            }
+
+            var scrollbarPadding = showingHorizontalScrollBar ? GUI.skin.horizontalScrollbar.fixedHeight : k_VerticalPadding;
+            return height + multiColumnHeader.height + scrollbarPadding;
+        }
+
+        static int FindIdForSignal(SerializedProperty signals, SignalAsset signalToFind)
+        {
+            for (var i = 0; i < signals.arraySize; ++i)
+            {
+                //signal in the receiver that matches the current signal asset will be displayed first
+                var serializedProperty = signals.GetArrayElementAtIndex(i);
+                var signalReferenceValue = serializedProperty.objectReferenceValue;
+                var signalToFindRefValue = signalToFind;
+                if (signalReferenceValue != null && signalReferenceValue == signalToFindRefValue)
+                    return i;
+            }
+            return -1;
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView/SignalReceiverTreeView.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView/SignalReceiverTreeView.cs.meta
new file mode 100644
index 0000000..7c121bf
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Signals/TreeView/SignalReceiverTreeView.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 698b660e9477f4f16abad03ec00ce38c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: