diff options
Diffstat (limited to 'Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence')
18 files changed, 1107 insertions, 0 deletions
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/EaseClip.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/EaseClip.cs new file mode 100644 index 0000000..7dddf3a --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/EaseClip.cs @@ -0,0 +1,146 @@ +using System; +using System.Text; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class EaseClip : Manipulator + { + bool m_IsCaptured; + bool m_UndoSaved; + TimelineClipHandle m_EaseClipHandler; + ManipulateEdges m_Edges; + TimelineClip m_Clip; + StringBuilder m_OverlayText = new StringBuilder(""); + double m_OriginalValue; + + public static readonly string EaseInClipText = L10n.Tr("Ease In Clip"); + public static readonly string EaseOutClipText = L10n.Tr("Ease Out Clip"); + public static readonly string EaseInText = L10n.Tr("Ease In"); + public static readonly string EaseOutText = L10n.Tr("Ease Out"); + public static readonly string DurationFrameText = L10n.Tr(" Duration {0:0.00;-0.00} frames "); + public static readonly string DurationSecText = L10n.Tr(" Duration {0:0.00;-0.00} s "); + public static readonly string DeltaFrameText = L10n.Tr("({0:+0.00;-0.00} frames)"); + public static readonly string DeltaSecText = L10n.Tr("({0:+0.00;-0.00} s)"); + + protected override bool MouseDown(Event evt, WindowState state) + { + if (evt.modifiers != ManipulatorsUtils.actionModifier) + return false; + return MouseDownInternal(evt, state, PickerUtils.PickedLayerableOfType<TimelineClipHandle>()); + } + + protected bool MouseDownInternal(Event evt, WindowState state, TimelineClipHandle handle) + { + if (handle == null) + return false; + + if (handle.clipGUI.clip != null && !handle.clipGUI.clip.clipCaps.HasAny(ClipCaps.Blending)) + return false; + + m_Edges = ManipulateEdges.Right; + if (handle.trimDirection == TrimEdge.Start) + m_Edges = ManipulateEdges.Left; + + if (m_Edges == ManipulateEdges.Left && handle.clipGUI.clip.hasBlendIn || m_Edges == ManipulateEdges.Right && handle.clipGUI.clip.hasBlendOut) + return false; + + m_IsCaptured = true; + m_UndoSaved = false; + + m_EaseClipHandler = handle; + m_Clip = handle.clipGUI.clip; + m_OriginalValue = m_Edges == ManipulateEdges.Left ? m_Clip.easeInDuration : m_Clip.easeOutDuration; + + + // Change cursor only when OnGUI Process (not in test) + if (GUIUtility.guiDepth > 0) + TimelineCursors.SetCursor(m_Edges == ManipulateEdges.Left ? TimelineCursors.CursorType.MixRight : TimelineCursors.CursorType.MixLeft); + + state.AddCaptured(this); + return true; + } + + protected override bool MouseUp(Event evt, WindowState state) + { + if (!m_IsCaptured) + return false; + m_IsCaptured = false; + m_UndoSaved = false; + state.captured.Clear(); + + // Clear cursor only when OnGUI Process (not in test) + if (GUIUtility.guiDepth > 0) + TimelineCursors.ClearCursor(); + + return true; + } + + protected override bool MouseDrag(Event evt, WindowState state) + { + if (!m_IsCaptured) + return false; + if (!m_UndoSaved) + { + var uiClip = m_EaseClipHandler.clipGUI; + string undoName = m_Edges == ManipulateEdges.Left ? EaseInClipText : EaseOutClipText; + TimelineUndo.PushUndo(uiClip.clip.parentTrack, undoName); + m_UndoSaved = true; + } + + double d = state.PixelDeltaToDeltaTime(evt.delta.x); + if (m_Edges == ManipulateEdges.Left) + { + m_Clip.easeInDuration = Math.Max(0, m_Clip.easeInDuration + d); + } + else if (m_Edges == ManipulateEdges.Right) + { + m_Clip.easeOutDuration = Math.Max(0, m_Clip.easeOutDuration - d); + } + RefreshOverlayStrings(m_EaseClipHandler, state); + return true; + } + + public override void Overlay(Event evt, WindowState state) + { + if (!m_IsCaptured) + return; + if (m_OverlayText.Length > 0) + { + int stringLength = m_OverlayText.Length; + var r = new Rect(evt.mousePosition.x - (stringLength / 2.0f), + m_EaseClipHandler.clipGUI.rect.yMax, + stringLength, 20); + GUI.Label(r, m_OverlayText.ToString(), TimelineWindow.styles.tinyFont); + } + } + + void RefreshOverlayStrings(TimelineClipHandle handle, WindowState state) + { + m_OverlayText.Length = 0; + m_OverlayText.Append(m_Edges == ManipulateEdges.Left ? EaseInText : EaseOutText); + double easeDuration = m_Edges == ManipulateEdges.Left ? m_Clip.easeInDuration : m_Clip.easeOutDuration; + double deltaDuration = easeDuration - m_OriginalValue; + bool hasDurationDelta = Math.Abs(deltaDuration) > double.Epsilon; + if (state.timeInFrames) + { + easeDuration *= state.editSequence.frameRate; + deltaDuration *= state.editSequence.frameRate; + m_OverlayText.AppendFormat(DurationFrameText, easeDuration); + if (hasDurationDelta) + { + m_OverlayText.AppendFormat(DeltaFrameText, deltaDuration); + } + } + else + { + m_OverlayText.AppendFormat(DurationSecText, easeDuration); + if (hasDurationDelta) + { + m_OverlayText.AppendFormat(DeltaSecText, deltaDuration); + } + } + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/EaseClip.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/EaseClip.cs.meta new file mode 100644 index 0000000..a161d2f --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/EaseClip.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b7cabea05434bb9479aee1e121b0d103 +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/Manipulators/Sequence/Jog.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/Jog.cs new file mode 100644 index 0000000..b470b58 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/Jog.cs @@ -0,0 +1,61 @@ +using UnityEditor.ShortcutManagement; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class Jog : Manipulator + { + Vector2 m_MouseDownOrigin = Vector2.zero; + + [ClutchShortcut("Timeline/Jog", typeof(TimelineWindow), KeyCode.J)] + static void JogShortcut(ShortcutArguments args) + { + if (args.stage == ShortcutStage.Begin) + { + (args.context as TimelineWindow).state.isJogging = true; + } + else if (args.stage == ShortcutStage.End) + { + (args.context as TimelineWindow).state.isJogging = false; + } + } + + protected override bool MouseDown(Event evt, WindowState state) + { + if (!state.isJogging) + return false; + + m_MouseDownOrigin = evt.mousePosition; + state.playbackSpeed = 0.0f; + state.Play(); + + return true; + } + + protected override bool MouseUp(Event evt, WindowState state) + { + if (!state.isJogging) + { + return false; + } + + m_MouseDownOrigin = evt.mousePosition; + state.playbackSpeed = 0.0f; + state.Play(); + return false; + } + + protected override bool MouseDrag(Event evt, WindowState state) + { + if (!state.isJogging) + return false; + + var distance = evt.mousePosition - m_MouseDownOrigin; + + state.playbackSpeed = distance.x * 0.002f; + state.Play(); + return true; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/Jog.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/Jog.cs.meta new file mode 100644 index 0000000..9f26650 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/Jog.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 949b7e126b3f27940885a6808a15458e +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/Manipulators/Sequence/MarkerHeaderContextMenu.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/MarkerHeaderContextMenu.cs new file mode 100644 index 0000000..a6b7c87 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/MarkerHeaderContextMenu.cs @@ -0,0 +1,24 @@ +using System; +using UnityEngine; +using UnityEngine.Playables; +using UnityEngine.Timeline; +using Object = UnityEngine.Object; + +namespace UnityEditor.Timeline +{ + class TimelineMarkerHeaderContextMenu : Manipulator + { + protected override bool ContextClick(Event evt, WindowState state) + { + if (!state.showMarkerHeader) + return false; + + if (!(state.GetWindow().markerHeaderRect.Contains(evt.mousePosition) + || state.GetWindow().markerContentRect.Contains(evt.mousePosition))) + return false; + + SequencerContextMenu.ShowMarkerHeaderContextMenu(evt.mousePosition, state); + return true; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/MarkerHeaderContextMenu.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/MarkerHeaderContextMenu.cs.meta new file mode 100644 index 0000000..6f6012a --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/MarkerHeaderContextMenu.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e74ddf4132f3401409c824bed60280ee +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/Manipulators/Sequence/RectangleSelect.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleSelect.cs new file mode 100644 index 0000000..17342ef --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleSelect.cs @@ -0,0 +1,36 @@ +using System.Linq; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + class RectangleSelect : RectangleTool + { + protected override bool enableAutoPan { get { return false; } } + + protected override bool CanStartRectangle(Event evt, Vector2 mousePosition, WindowState state) + { + if (evt.button != 0 || evt.alt) + return false; + + return PickerUtils.pickedElements.All(e => e is IRowGUI); + } + + protected override bool OnFinish(Event evt, WindowState state, Rect rect) + { + var selectables = state.spacePartitioner.GetItemsInArea<ISelectable>(rect).ToList(); + + if (!selectables.Any()) + return false; + + if (ItemSelection.CanClearSelection(evt)) + SelectionManager.Clear(); + + foreach (var selectable in selectables) + { + ItemSelection.HandleItemSelection(evt, selectable); + } + + return true; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleSelect.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleSelect.cs.meta new file mode 100644 index 0000000..ddff16e --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleSelect.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: edd4f4b395430604d935bcf0b14c7d42 +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/Manipulators/Sequence/RectangleTool.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleTool.cs new file mode 100644 index 0000000..5de1eb6 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleTool.cs @@ -0,0 +1,169 @@ +using System; +using UnityEngine; + +namespace UnityEditor.Timeline +{ + abstract class RectangleTool + { + struct TimelinePoint + { + readonly double m_Time; + readonly float m_YPos; + readonly float m_YScrollPos; + + readonly WindowState m_State; + readonly TimelineTreeViewGUI m_TreeViewGUI; + + public TimelinePoint(WindowState state, Vector2 mousePosition) + { + m_State = state; + m_TreeViewGUI = state.GetWindow().treeView; + + m_Time = m_State.PixelToTime(mousePosition.x); + m_YPos = mousePosition.y; + m_YScrollPos = m_TreeViewGUI.scrollPosition.y; + } + + public Vector2 ToPixel() + { + return new Vector2(m_State.TimeToPixel(m_Time), m_YPos - (m_TreeViewGUI.scrollPosition.y - m_YScrollPos)); + } + } + + TimeAreaAutoPanner m_TimeAreaAutoPanner; + + TimelinePoint m_StartPoint; + Vector2 m_EndPixel = Vector2.zero; + + Rect m_ActiveRect; + + protected abstract bool enableAutoPan { get; } + protected abstract bool CanStartRectangle(Event evt, Vector2 mousePosition, WindowState state); + protected abstract bool OnFinish(Event evt, WindowState state, Rect rect); + + int m_Id; + + public void OnGUI(WindowState state, EventType rawType, Vector2 mousePosition) + { + if (m_Id == 0) + m_Id = GUIUtility.GetPermanentControlID(); + + if (state == null || state.GetWindow().treeView == null) + return; + + var evt = Event.current; + + if (rawType == EventType.MouseDown || evt.type == EventType.MouseDown) + { + if (state.IsCurrentEditingASequencerTextField()) + return; + + m_ActiveRect = TimelineWindow.instance.sequenceContentRect; + + if (!m_ActiveRect.Contains(mousePosition)) + return; + + if (!CanStartRectangle(evt, mousePosition, state)) + return; + + if (enableAutoPan) + m_TimeAreaAutoPanner = new TimeAreaAutoPanner(state); + + m_StartPoint = new TimelinePoint(state, mousePosition); + m_EndPixel = mousePosition; + + GUIUtility.hotControl = m_Id; //HACK: Because the treeView eats all the events, steal the hotControl if necessary... + evt.Use(); + + return; + } + + switch (evt.GetTypeForControl(m_Id)) + { + case EventType.KeyDown: + { + if (GUIUtility.hotControl == m_Id) + { + if (evt.keyCode == KeyCode.Escape) + { + m_TimeAreaAutoPanner = null; + + GUIUtility.hotControl = 0; + evt.Use(); + } + } + + return; + } + + case EventType.MouseDrag: + { + if (GUIUtility.hotControl != m_Id) + return; + + m_EndPixel = mousePosition; + evt.Use(); + + return; + } + + case EventType.MouseUp: + { + if (GUIUtility.hotControl != m_Id) + return; + + m_TimeAreaAutoPanner = null; + + var rect = CurrentRectangle(); + + if (IsValidRect(rect)) + OnFinish(evt, state, rect); + + GUIUtility.hotControl = 0; + evt.Use(); + + return; + } + } + + if (GUIUtility.hotControl == m_Id) + { + if (evt.type == EventType.Repaint) + { + var r = CurrentRectangle(); + + if (IsValidRect(r)) + { + using (new GUIViewportScope(m_ActiveRect)) + { + DrawRectangle(r); + } + } + } + + if (m_TimeAreaAutoPanner != null) + m_TimeAreaAutoPanner.OnGUI(evt); + } + } + + protected virtual void DrawRectangle(Rect rect) + { + EditorStyles.selectionRect.Draw(rect, GUIContent.none, false, false, false, false); + } + + static bool IsValidRect(Rect rect) + { + return rect.width >= 1.0f && rect.height >= 1.0f; + } + + Rect CurrentRectangle() + { + var startPixel = m_StartPoint.ToPixel(); + return Rect.MinMaxRect( + Math.Min(startPixel.x, m_EndPixel.x), + Math.Min(startPixel.y, m_EndPixel.y), + Math.Max(startPixel.x, m_EndPixel.x), + Math.Max(startPixel.y, m_EndPixel.y)); + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleTool.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleTool.cs.meta new file mode 100644 index 0000000..3a0d71a --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleTool.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 24a7ce8b48db53747a4e8abbda77eac4 +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/Manipulators/Sequence/RectangleZoom.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleZoom.cs new file mode 100644 index 0000000..0a2d45f --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleZoom.cs @@ -0,0 +1,23 @@ +using UnityEngine; + +namespace UnityEditor.Timeline +{ + class RectangleZoom : RectangleTool + { + protected override bool enableAutoPan { get { return true; } } + + protected override bool CanStartRectangle(Event evt, Vector2 mousePosition, WindowState state) + { + return evt.button == 1 && evt.modifiers == (EventModifiers.Alt | EventModifiers.Shift); + } + + protected override bool OnFinish(Event evt, WindowState state, Rect rect) + { + var x = state.PixelToTime(rect.xMin); + var y = state.PixelToTime(rect.xMax); + state.SetTimeAreaShownRange(x, y); + + return true; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleZoom.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleZoom.cs.meta new file mode 100644 index 0000000..e32aad5 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/RectangleZoom.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5aa8f57287fc17149bcd798be813180b +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/Manipulators/Sequence/SelectAndMoveItem.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/SelectAndMoveItem.cs new file mode 100644 index 0000000..b8d9a77 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/SelectAndMoveItem.cs @@ -0,0 +1,297 @@ +using System; +using System.Linq; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class ClearSelection : Manipulator + { + protected override bool MouseDown(Event evt, WindowState state) + { + // If we hit this point this means no one used the mouse down events. We can safely clear the selection if needed + if (evt.button != 0) + return false; + + var window = state.GetWindow(); + + if (!window.sequenceRect.Contains(evt.mousePosition)) + return false; + + if (ItemSelection.CanClearSelection(evt)) + { + SelectionManager.Clear(); + return true; + } + + return false; + } + } + + static class ItemSelection + { + public static bool CanClearSelection(Event evt) + { + return !evt.control && !evt.command && !evt.shift; + } + + public static void RangeSelectItems(ITimelineItem lastItemToSelect) + { + var selectSorted = SelectionManager.SelectedItems().ToList(); + var firstSelect = selectSorted.FirstOrDefault(); + if (firstSelect == null) + { + SelectionManager.Add(lastItemToSelect); + return; + } + + var allTracks = TimelineEditor.inspectedAsset.flattenedTracks; + var allItems = allTracks.SelectMany(ItemsUtils.GetItems).ToList(); + TimelineHelpers.RangeSelect(allItems, selectSorted, lastItemToSelect, SelectionManager.Add, SelectionManager.Remove); + } + + public static ISelectable HandleSingleSelection(Event evt) + { + var item = PickerUtils.PickedLayerableOfType<ISelectable>(); + + if (item != null) + { + var selected = item.IsSelected(); + if (!selected && CanClearSelection(evt)) + SelectionManager.Clear(); + + if (evt.modifiers == EventModifiers.Shift) + { + if (!selected) + RangeSelectItems((item as TimelineItemGUI).item); + } + else + { + HandleItemSelection(evt, item); + } + } + + return item; + } + + public static void HandleItemSelection(Event evt, ISelectable item) + { + if (evt.modifiers == ManipulatorsUtils.actionModifier) + { + if (item.IsSelected()) + item.Deselect(); + else + item.Select(); + } + else + { + if (!item.IsSelected()) + item.Select(); + } + } + } + + class SelectAndMoveItem : Manipulator + { + bool m_Dragged; + SnapEngine m_SnapEngine; + TimeAreaAutoPanner m_TimeAreaAutoPanner; + Vector2 m_MouseDownPosition; + + bool m_HorizontalMovementDone; + bool m_VerticalMovementDone; + + MoveItemHandler m_MoveItemHandler; + bool m_CycleMarkersPending; + + protected override bool MouseDown(Event evt, WindowState state) + { + if (evt.alt || evt.button != 0) + return false; + + m_Dragged = false; + + // Cycling markers and selection are mutually exclusive operations + if (!HandleMarkerCycle() && !HandleSingleSelection(evt)) + return false; + + m_MouseDownPosition = evt.mousePosition; + m_VerticalMovementDone = false; + m_HorizontalMovementDone = false; + + return true; + } + + protected override bool MouseUp(Event evt, WindowState state) + { + if (!m_Dragged) + { + var item = PickerUtils.PickedLayerableOfType<ISelectable>(); + + if (item == null) + return false; + + if (!item.IsSelected()) + return false; + + // Re-selecting an item part of a multi-selection should only keep this item selected. + if (SelectionManager.Count() > 1 && ItemSelection.CanClearSelection(evt)) + { + SelectionManager.Clear(); + item.Select(); + return true; + } + + if (m_CycleMarkersPending) + { + m_CycleMarkersPending = false; + TimelineMarkerClusterGUI.CycleMarkers(); + return true; + } + + return false; + } + + m_TimeAreaAutoPanner = null; + + DropItems(); + + m_SnapEngine = null; + m_MoveItemHandler = null; + + state.Evaluate(); + state.RemoveCaptured(this); + m_Dragged = false; + TimelineCursors.ClearCursor(); + + return true; + } + + protected override bool DoubleClick(Event evt, WindowState state) + { + return MouseDown(evt, state) && MouseUp(evt, state); + } + + protected override bool MouseDrag(Event evt, WindowState state) + { + if (state.editSequence.isReadOnly) + return false; + + // case 1099285 - ctrl-click can cause no clips to be selected + var selectedItemsGUI = SelectionManager.SelectedItems(); + if (!selectedItemsGUI.Any()) + { + m_Dragged = false; + return false; + } + + const float hDeadZone = 5.0f; + const float vDeadZone = 5.0f; + + bool vDone = m_VerticalMovementDone || Math.Abs(evt.mousePosition.y - m_MouseDownPosition.y) > vDeadZone; + bool hDone = m_HorizontalMovementDone || Math.Abs(evt.mousePosition.x - m_MouseDownPosition.x) > hDeadZone; + + m_CycleMarkersPending = false; + + if (!m_Dragged) + { + var canStartMove = vDone || hDone; + + if (canStartMove) + { + state.AddCaptured(this); + m_Dragged = true; + + var referenceTrack = GetTrackDropTargetAt(state, m_MouseDownPosition); + + foreach (var item in selectedItemsGUI) + item.gui.StartDrag(); + + m_MoveItemHandler = new MoveItemHandler(state); + + m_MoveItemHandler.Grab(selectedItemsGUI, referenceTrack, m_MouseDownPosition); + + m_SnapEngine = new SnapEngine(m_MoveItemHandler, m_MoveItemHandler, ManipulateEdges.Both, + state, m_MouseDownPosition); + + m_TimeAreaAutoPanner = new TimeAreaAutoPanner(state); + } + } + + if (!m_VerticalMovementDone) + { + m_VerticalMovementDone = vDone; + + if (m_VerticalMovementDone) + m_MoveItemHandler.OnTrackDetach(); + } + + if (!m_HorizontalMovementDone) + { + m_HorizontalMovementDone = hDone; + } + + if (m_Dragged) + { + if (m_HorizontalMovementDone) + m_SnapEngine.Snap(evt.mousePosition, evt.modifiers); + + if (m_VerticalMovementDone) + { + var track = GetTrackDropTargetAt(state, evt.mousePosition); + m_MoveItemHandler.UpdateTrackTarget(track); + } + + state.Evaluate(); + } + + return true; + } + + public override void Overlay(Event evt, WindowState state) + { + if (!m_Dragged) + return; + + if (m_TimeAreaAutoPanner != null) + m_TimeAreaAutoPanner.OnGUI(evt); + + m_MoveItemHandler.OnGUI(evt); + + if (!m_MoveItemHandler.allowTrackSwitch || m_MoveItemHandler.targetTrack != null) + { + TimeIndicator.Draw(state, m_MoveItemHandler.start, m_MoveItemHandler.end); + m_SnapEngine.OnGUI(); + } + } + + bool HandleMarkerCycle() + { + m_CycleMarkersPending = TimelineMarkerClusterGUI.CanCycleMarkers(); + return m_CycleMarkersPending; + } + + bool HandleSingleSelection(Event evt) + { + return ItemSelection.HandleSingleSelection(evt) != null; + } + + void DropItems() + { + // Order matters here: m_MoveItemHandler.movingItems is destroyed during call to Drop() + foreach (var movingItem in m_MoveItemHandler.movingItems) + { + foreach (var item in movingItem.items) + item.gui.StopDrag(); + } + + m_MoveItemHandler.Drop(); + } + + static TrackAsset GetTrackDropTargetAt(WindowState state, Vector2 point) + { + var track = state.spacePartitioner.GetItemsAtPosition<IRowGUI>(point).FirstOrDefault(); + return track != null ? track.asset : null; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/SelectAndMoveItem.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/SelectAndMoveItem.cs.meta new file mode 100644 index 0000000..16f0152 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/SelectAndMoveItem.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f4f988528bbbb0846a4cb50efb4587a5 +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/Manipulators/Sequence/TrackZoom.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrackZoom.cs new file mode 100644 index 0000000..fc167f4 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrackZoom.cs @@ -0,0 +1,20 @@ +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class TrackZoom : Manipulator + { + // only handles 'vertical' zoom. horizontal is handled in timelineGUI + protected override bool MouseWheel(Event evt, WindowState state) + { + if (EditorGUI.actionKey) + { + state.trackScale = Mathf.Min(Mathf.Max(state.trackScale + (evt.delta.y * 0.1f), 1.0f), 100.0f); + return true; + } + + return false; + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrackZoom.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrackZoom.cs.meta new file mode 100644 index 0000000..a13fea6 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrackZoom.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 6e7c80eefe2def5459e0b486b3ab96e2 +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/Manipulators/Sequence/TrimClip.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrimClip.cs new file mode 100644 index 0000000..0918a17 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrimClip.cs @@ -0,0 +1,232 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using UnityEngine; +using UnityEngine.Timeline; + +namespace UnityEditor.Timeline +{ + class TrimClip : Manipulator + { + class TrimClipAttractionHandler : IAttractionHandler + { + public void OnAttractedEdge(IAttractable attractable, ManipulateEdges manipulateEdges, AttractedEdge edge, double time) + { + var clipGUI = attractable as TimelineClipGUI; + if (clipGUI == null) + return; + + var clipItem = ItemsUtils.ToItem(clipGUI.clip); + if (manipulateEdges == ManipulateEdges.Right) + { + bool affectTimeScale = Event.current.modifiers == EventModifiers.Shift; // TODO Do not use Event.current from here. + EditMode.TrimEnd(clipItem, time, affectTimeScale); + } + else if (manipulateEdges == ManipulateEdges.Left) + { + EditMode.TrimStart(clipItem, time); + } + } + } + + bool m_IsCaptured; + TimelineClipHandle m_TrimClipHandler; + + double m_OriginalDuration; + double m_OriginalTimeScale; + bool m_UndoSaved; + SnapEngine m_SnapEngine; + + readonly StringBuilder m_OverlayText = new StringBuilder(); + readonly List<string> m_OverlayStrings = new List<string>(); + + static readonly double kEpsilon = 0.0000001; + + protected override bool MouseDown(Event evt, WindowState state) + { + var handle = PickerUtils.PickedLayerableOfType<TimelineClipHandle>(); + if (handle == null) + return false; + + if (handle.clipGUI.clip.parentTrack != null && handle.clipGUI.clip.parentTrack.lockedInHierarchy) + return false; + + if (ItemSelection.CanClearSelection(evt)) + SelectionManager.Clear(); + + if (!SelectionManager.Contains(handle.clipGUI.clip)) + SelectionManager.Add(handle.clipGUI.clip); + + m_TrimClipHandler = handle; + + m_IsCaptured = true; + state.AddCaptured(this); + + m_UndoSaved = false; + + var clip = m_TrimClipHandler.clipGUI.clip; + + m_OriginalDuration = clip.duration; + m_OriginalTimeScale = clip.timeScale; + + RefreshOverlayStrings(m_TrimClipHandler, state); + + // in ripple trim, the right edge moves and needs to snap + var edges = ManipulateEdges.Right; + if (EditMode.editType != EditMode.EditType.Ripple && m_TrimClipHandler.trimDirection == TrimEdge.Start) + edges = ManipulateEdges.Left; + m_SnapEngine = new SnapEngine(m_TrimClipHandler.clipGUI, new TrimClipAttractionHandler(), edges, state, + evt.mousePosition); + + EditMode.BeginTrim(ItemsUtils.ToItem(clip), m_TrimClipHandler.trimDirection); + + return true; + } + + protected override bool MouseUp(Event evt, WindowState state) + { + if (!m_IsCaptured) + return false; + + m_IsCaptured = false; + m_TrimClipHandler = null; + m_UndoSaved = false; + m_SnapEngine = null; + EditMode.FinishTrim(); + + state.captured.Clear(); + + return true; + } + + protected override bool MouseDrag(Event evt, WindowState state) + { + if (state.editSequence.isReadOnly) + return false; + + if (!m_IsCaptured) + return false; + + if (!m_UndoSaved) + { + var uiClip = m_TrimClipHandler.clipGUI; + TimelineUndo.PushUndo(uiClip.clip.parentTrack, "Trim Clip"); + if (TimelineUtility.IsRecordableAnimationClip(uiClip.clip)) + { + TimelineUndo.PushUndo(uiClip.clip.animationClip, "Trim Clip"); + } + + m_UndoSaved = true; + } + + if (m_SnapEngine != null) + m_SnapEngine.Snap(evt.mousePosition, evt.modifiers); + + RefreshOverlayStrings(m_TrimClipHandler, state); + + if (Selection.activeObject != null) + EditorUtility.SetDirty(Selection.activeObject); + + // updates the duration of the graph without rebuilding + state.UpdateRootPlayableDuration(state.editSequence.duration); + + return true; + } + + public override void Overlay(Event evt, WindowState state) + { + if (!m_IsCaptured) + return; + + EditMode.DrawTrimGUI(state, m_TrimClipHandler.clipGUI, m_TrimClipHandler.trimDirection); + + bool trimStart = m_TrimClipHandler.trimDirection == TrimEdge.Start; + + TimeIndicator.Draw(state, trimStart ? m_TrimClipHandler.clipGUI.start : m_TrimClipHandler.clipGUI.end); + + if (m_SnapEngine != null) + m_SnapEngine.OnGUI(trimStart, !trimStart); + + if (m_OverlayStrings.Count > 0) + { + const float padding = 4.0f; + var labelStyle = TimelineWindow.styles.tinyFont; + var longestLine = labelStyle.CalcSize( + new GUIContent(m_OverlayStrings.Aggregate("", (max, cur) => max.Length > cur.Length ? max : cur))); + var stringLength = longestLine.x + padding; + var lineHeight = longestLine.y + padding; + + var r = new Rect(evt.mousePosition.x - (stringLength / 2.0f), + m_TrimClipHandler.clipGUI.rect.yMax, + stringLength, lineHeight); + + foreach (var s in m_OverlayStrings) + { + GUI.Label(r, s, labelStyle); + r.y += lineHeight; + } + } + } + + void RefreshOverlayStrings(TimelineClipHandle handle, WindowState state) + { + m_OverlayStrings.Clear(); + + m_OverlayText.Length = 0; + + var differenceDuration = handle.clipGUI.clip.duration - m_OriginalDuration; + bool hasDurationDelta = Math.Abs(differenceDuration) > kEpsilon; + + if (state.timeInFrames) + { + var durationInFrame = handle.clipGUI.clip.duration * state.referenceSequence.frameRate; + m_OverlayText.Append("duration: ").Append(durationInFrame.ToString("f2")).Append(" frames"); + + if (hasDurationDelta) + { + m_OverlayText.Append(" ("); + + if (differenceDuration > 0.0) + m_OverlayText.Append("+"); + + var valueInFrame = differenceDuration * state.referenceSequence.frameRate; + m_OverlayText.Append(valueInFrame.ToString("f2")).Append(" frames)"); + } + } + else + { + m_OverlayText.Append("duration: ").Append(handle.clipGUI.clip.duration.ToString("f2")).Append("s"); + + if (hasDurationDelta) + { + m_OverlayText.Append(" ("); + + if (differenceDuration > 0.0) + m_OverlayText.Append("+"); + + m_OverlayText.Append(differenceDuration.ToString("f2")).Append("s)"); + } + } + + m_OverlayStrings.Add(m_OverlayText.ToString()); + + m_OverlayText.Length = 0; + + var differenceSpeed = m_OriginalTimeScale - handle.clipGUI.clip.timeScale; + if (Math.Abs(differenceSpeed) > kEpsilon) + { + m_OverlayText.Append("speed: ").Append(handle.clipGUI.clip.timeScale.ToString("p2")); + + m_OverlayText.Append(" ("); + + if (differenceSpeed > 0.0) + m_OverlayText.Append("+"); + + m_OverlayText.Append(differenceSpeed.ToString("p2")).Append(")"); + + m_OverlayStrings.Add(m_OverlayText.ToString()); + } + } + } +} diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrimClip.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrimClip.cs.meta new file mode 100644 index 0000000..063a1c6 --- /dev/null +++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Manipulators/Sequence/TrimClip.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 511aa760b8728a940a41c29837945292 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: |