Esempio n. 1
0
        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);
                }
            }
        }
Esempio n. 2
0
        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;
            m_OriginalEaseInDuration  = clip.easeInDuration;
            m_OriginalEaseOutDuration = clip.easeOutDuration;

            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);
        }
 private static void ManipulateBlending(TimelineClipHandle handle, Event evt, float scale)
 {
     if (handle.direction == TimelineClipHandle.DragDirection.Right)
     {
         float num = evt.get_delta().x / scale;
         handle.clip.clip.easeOutDuration -= (double)num;
     }
     else
     {
         float num2 = evt.get_delta().x / scale;
         handle.clip.clip.easeInDuration += (double)num2;
     }
 }
        protected void RefreshOverlayStrings(TimelineClipHandle handle, TimelineWindow.TimelineState state)
        {
            double num  = (this.m_OriginalTimeScale - handle.clip.clip.timeScale) * 100.0;
            double num2 = handle.clip.clip.duration - this.m_OriginalDuration;

            this.m_OverlayText = "";
            if (Math.Abs(num) > DragClipHandle.kEpsilon)
            {
                this.m_OverlayText  = "speed: " + (handle.clip.clip.timeScale * 100.0).ToString("f2") + "%";
                this.m_OverlayText += " (";
                if (num > 0.0)
                {
                    this.m_OverlayText += "+";
                }
                this.m_OverlayText  = this.m_OverlayText + num.ToString("f2") + "%";
                this.m_OverlayText += ")";
                this.m_OverlayStrings.Add(this.m_OverlayText);
            }
            this.m_OverlayText = "";
            if (Math.Abs(num2) > DragClipHandle.kEpsilon)
            {
                if (!state.timeInFrames)
                {
                    this.m_OverlayText  = this.m_OverlayText + " duration: " + handle.clip.clip.duration.ToString("f2") + "s";
                    this.m_OverlayText += " (";
                    if (num2 > 0.0)
                    {
                        this.m_OverlayText += "+";
                    }
                    this.m_OverlayText  = this.m_OverlayText + num2.ToString("f2") + "s";
                    this.m_OverlayText += ")";
                    this.m_OverlayStrings.Add(this.m_OverlayText);
                }
                else
                {
                    double num3 = handle.clip.clip.duration * (double)state.frameRate;
                    this.m_OverlayText  = this.m_OverlayText + " duration: " + num3.ToString("f2") + "frames";
                    this.m_OverlayText += " (";
                    if (num2 > 0.0)
                    {
                        this.m_OverlayText += "+";
                    }
                    double num4 = num2 * (double)state.frameRate;
                    this.m_OverlayText  = this.m_OverlayText + num4.ToString("f2") + "frames";
                    this.m_OverlayText += ")";
                    this.m_OverlayStrings.Add(this.m_OverlayText);
                }
            }
        }
        public TimelineClipGUI(TimelineClip clip, IRowGUI parent, IZOrderProvider provider) : base(parent)
        {
            zOrderProvider = provider;
            zOrder         = provider.Next();

            m_EditorItem = EditorClipFactory.GetEditorClip(clip);
            m_ClipEditor = CustomTimelineEditorCache.GetClipEditor(clip);

            supportResize = true;

            leftHandle  = new TimelineClipHandle(this, TrimEdge.Start);
            rightHandle = new TimelineClipHandle(this, TrimEdge.End);

            ItemToItemGui.Add(clip, this);
        }
        public TimelineClipGUI(TimelineClip clip, IRowGUI parent, IZOrderProvider provider) : base(parent)
        {
            zOrderProvider = provider;
            zOrder         = provider.Next();

            m_EditorItem = EditorClipFactory.GetEditorClip(clip);

            clip.dirtyHash = 0;

            supportResize = true;

            m_LeftHandle  = new TimelineClipHandle(this, TrimEdge.Start);
            m_RightHandle = new TimelineClipHandle(this, TrimEdge.End);

            ItemToItemGui.Add(clip, this);
        }
        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);
        }
Esempio n. 8
0
        void RefreshOverlayStrings(TimelineClipHandle handle, WindowState state)
        {
            m_OverlayText.Length = 0;
            m_OverlayText.Append(m_Edges == ManipulateEdges.Left ? EaseInText : EaseOutText);

            var easeDuration  = m_Edges == ManipulateEdges.Left ? m_Clip.easeInDuration : m_Clip.easeOutDuration;
            var deltaDuration = easeDuration - m_OriginalValue;

            // round to frame so we don't show partial time codes due to no frame snapping
            if (state.timeFormat == TimeFormat.Timecode)
            {
                easeDuration  = TimeUtility.RoundToFrame(easeDuration, state.referenceSequence.frameRate);
                deltaDuration = TimeUtility.RoundToFrame(deltaDuration, state.referenceSequence.frameRate);
            }

            m_OverlayText.Append(DurationText);
            m_OverlayText.Append(state.timeFormat.ToTimeStringWithDelta(easeDuration, state.referenceSequence.frameRate, deltaDuration));
        }
        void RefreshOverlayStrings(TimelineClipHandle handle, WindowState state)
        {
            m_OverlayStrings.Clear();

            var differenceDuration = handle.clipGUI.clip.duration - m_OriginalDuration;

            m_OverlayStrings.Add($"{kDurationText} {state.timeFormat.ToTimeStringWithDelta(handle.clipGUI.clip.duration, state.referenceSequence.frameRate, differenceDuration)}");

            var differenceSpeed = m_OriginalTimeScale - handle.clipGUI.clip.timeScale;

            if (Math.Abs(differenceSpeed) > kEpsilon)
            {
                var sign       = differenceSpeed > 0 ? "+" : "";
                var timeScale  = handle.clipGUI.clip.timeScale.ToString("f2");
                var deltaSpeed = differenceSpeed.ToString("p2");
                m_OverlayStrings.Add($"{kSpeedText} {timeScale} ({sign}{deltaSpeed}) ");
            }
        }
 protected virtual void OnOverlay(Event evt, TimelineClipHandle handle)
 {
     if (this.m_OverlayStrings.Count > 0)
     {
         Vector2 vector = TimelineWindow.styles.tinyFont.CalcSize(new GUIContent(this.m_OverlayStrings[0]));
         Rect    rect   = new Rect(evt.get_mousePosition().x - vector.x / 2f, handle.clip.parentTrackGUI.boundingRect.get_y() + handle.clip.parentTrackGUI.boundingRect.get_height() + 42f, vector.x, 40f);
         GUILayout.BeginArea(rect);
         GUILayout.BeginVertical(new GUILayoutOption[0]);
         GUI.Label(rect, GUIContent.none, TimelineWindow.styles.displayBackground);
         foreach (string current in this.m_OverlayStrings)
         {
             GUILayout.Label(current, TimelineWindow.styles.tinyFont, new GUILayoutOption[0]);
         }
         GUILayout.EndVertical();
         GUILayout.EndArea();
     }
     if (this.m_MagnetEngine != null)
     {
         this.m_MagnetEngine.OnGUI();
     }
 }
Esempio n. 11
0
        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);
        }
        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());
            }
        }
 protected virtual void OnMouseDown(Event evt, TimelineWindow.TimelineState state, TimelineClipHandle handle)
 {
     if (!state.captured.Contains(handle))
     {
         state.captured.Add(handle);
     }
     this.m_IsCaptured = true;
     this.m_UndoSaved  = false;
     SelectionManager.Add(handle.clip.clip);
     if (state.edgeSnaps)
     {
         this.m_MagnetEngine = new MagnetEngine(handle.clip, new DragClipHandle.DragClipAttractionHandler(this.m_FrameSnap), state);
     }
     this.m_OriginalDuration  = handle.clip.clip.duration;
     this.m_OriginalTimeScale = handle.clip.clip.timeScale;
     this.m_FrameSnap.Reset();
 }
 protected virtual void OnMouseDrag(Event evt, TimelineWindow.TimelineState state, TimelineClipHandle handle)
 {
     if (evt.get_modifiers() == 2)
     {
         DragClipHandle.ManipulateBlending(handle, evt, state.timeAreaScale.x);
     }
     else
     {
         if (!this.m_UndoSaved)
         {
             TimelineUndo.PushUndo(handle.clip.parentTrackGUI.track, "Trim Clip");
             this.m_UndoSaved = true;
         }
         float num = evt.get_delta().x / state.timeAreaScale.x;
         if (this.m_Ripple != null)
         {
             this.m_Ripple.Run(num, state);
         }
         ManipulateEdges edges;
         if (handle.direction == TimelineClipHandle.DragDirection.Right)
         {
             double val = this.m_FrameSnap.ApplyOffset(handle.clip.clip.duration, num, state);
             handle.clip.clip.duration = Math.Max(val, TimelineClip.kMinDuration);
             if (handle.clip.clip.SupportsSpeedMultiplier() && evt.get_modifiers() == 1)
             {
                 double num2 = this.m_OriginalDuration / handle.clip.clip.duration;
                 handle.clip.clip.timeScale = this.m_OriginalTimeScale * num2;
             }
             edges = ManipulateEdges.Right;
         }
         else
         {
             double num3 = handle.clip.clip.clipIn / handle.clip.clip.timeScale;
             if (num3 > 0.0 && num3 + (double)num < 0.0)
             {
                 num = (float)(-(float)num3);
             }
             if (this.m_MagnetEngine == null || !this.m_MagnetEngine.isSnapped)
             {
                 double newValue = this.m_FrameSnap.ApplyOffset(num3, num, state) * handle.clip.clip.timeScale;
                 DragClipHandle.SetClipIn(handle.clip.clip, newValue, this.m_FrameSnap.lastOffsetApplied);
             }
             edges = ManipulateEdges.Left;
         }
         if (this.m_MagnetEngine != null && evt.get_modifiers() != 1)
         {
             this.m_MagnetEngine.Snap(evt.get_delta().x, edges);
         }
         handle.clip.clip.duration = Math.Max(handle.clip.clip.duration, TimelineClip.kMinDuration);
     }
 }
Esempio n. 15
0
        protected override void OnMouseDrag(Event evt, TimelineWindow.TimelineState state, TimelineClipHandle handle)
        {
            ManipulateEdges edges = ManipulateEdges.Both;
            float           delta = evt.get_delta().x / state.timeAreaScale.x;

            TimelineUndo.PushUndo(handle.clip.clip.parentTrack, "Trim Clip");
            TimelineClipHandle.DragDirection direction = handle.direction;
            if (direction != TimelineClipHandle.DragDirection.Right)
            {
                if (direction == TimelineClipHandle.DragDirection.Left)
                {
                    double num = this.m_FrameSnap.ApplyOffset(handle.clip.clip.start, delta, state);
                    if (num > 0.0)
                    {
                        double num2 = num - handle.clip.clip.start;
                        handle.clip.clip.start = num;
                        if (handle.clip.clip.duration - num2 > TimelineClip.kMinDuration)
                        {
                            handle.clip.clip.duration -= num2;
                        }
                    }
                    edges = ManipulateEdges.Left;
                }
            }
            else
            {
                double val = this.m_FrameSnap.ApplyOffset(handle.clip.clip.duration, delta, state);
                handle.clip.clip.duration = Math.Max(val, TimelineClip.kMinDuration);
                edges = ManipulateEdges.Right;
            }
            if (this.m_MagnetEngine != null && evt.get_modifiers() != 1)
            {
                this.m_MagnetEngine.Snap(evt.get_delta().x, edges);
            }
        }
 public override void Init(IControl parent)
 {
     this.m_IsCaptured        = false;
     this.m_Ripple            = null;
     this.m_OriginalDuration  = 0.0;
     this.m_OriginalTimeScale = 0.0;
     this.m_UndoSaved         = false;
     this.m_MagnetEngine      = null;
     this.m_FrameSnap         = new FrameSnap();
     parent.MouseDown        += delegate(object target, Event evt, TimelineWindow.TimelineState state)
     {
         TimelineClipHandle timelineClipHandle = target as TimelineClipHandle;
         bool result;
         if (timelineClipHandle == null)
         {
             result = base.IgnoreEvent();
         }
         else
         {
             this.OnMouseDown(evt, state, timelineClipHandle);
             result = base.ConsumeEvent();
         }
         return(result);
     };
     parent.MouseUp += delegate(object target, Event evt, TimelineWindow.TimelineState state)
     {
         TimelineClipHandle timelineClipHandle = target as TimelineClipHandle;
         bool result;
         if (!this.m_IsCaptured || timelineClipHandle == null)
         {
             result = base.IgnoreEvent();
         }
         else
         {
             this.OnMouseUp(evt, state, timelineClipHandle);
             result = base.ConsumeEvent();
         }
         return(result);
     };
     parent.MouseDrag += delegate(object target, Event evt, TimelineWindow.TimelineState state)
     {
         this.m_OverlayText = "";
         this.m_OverlayStrings.Clear();
         TimelineClipHandle timelineClipHandle = target as TimelineClipHandle;
         bool result;
         if (!this.m_IsCaptured || timelineClipHandle == null)
         {
             result = base.IgnoreEvent();
         }
         else
         {
             this.OnMouseDrag(evt, state, timelineClipHandle);
             this.RefreshOverlayStrings(timelineClipHandle, state);
             if (Selection.get_activeObject() != null)
             {
                 EditorUtility.SetDirty(Selection.get_activeObject());
             }
             state.UpdateRootPlayableDuration(state.duration);
             result = base.ConsumeEvent();
         }
         return(result);
     };
     parent.Overlay += delegate(object target, Event evt, TimelineWindow.TimelineState state)
     {
         TimelineClipHandle timelineClipHandle = target as TimelineClipHandle;
         bool result;
         if (timelineClipHandle == null)
         {
             result = base.IgnoreEvent();
         }
         else
         {
             this.OnOverlay(evt, timelineClipHandle);
             result = base.ConsumeEvent();
         }
         return(result);
     };
 }
 protected virtual void OnMouseUp(Event evt, TimelineWindow.TimelineState state, TimelineClipHandle handle)
 {
     this.m_UndoSaved    = false;
     this.m_MagnetEngine = null;
     state.captured.Clear();
     this.m_Ripple = null;
 }