private void DrawFrameBar(TimeLineParameters parameters, Rect timeLineRect)
        {
            var frameLength = parameters.MaxFrame - parameters.MinFrame;
            var start       = timeLineRect.height - 30f;

            Handles.color = Color.white;
            Handles.DrawSolidRectangleWithOutline(new Rect(0, start, timeLineRect.width - 10f, 30f), new Color(Color.gray.r, Color.gray.g, Color.gray.b, 0.2f), Color.gray);
            Handles.color = Color.black;
            var i          = 0;
            var linesCount = frameLength / _koef;

            while (i <= linesCount)
            {
                var evenFrame = i == 0 || i % 5 == 0;
                var width     = evenFrame ? 10f : 5f;

                if (evenFrame && i != linesCount)
                {
                    var rate = (parameters.MinFrame + (i * _koef)) / parameters.FrameRate;
                    var time = string.Format("{0}:{1}", Mathf.Ceil(rate), (parameters.MinFrame + (i * _koef)) % parameters.FrameRate);
                    Handles.Label(new Vector3(i * x_dif + 6f, start + 3f), time);
                }

                Handles.DrawLine(new Vector3(i * x_dif + 5, start), new Vector3(i * x_dif + 5, start + width));
                i++;
            }

            if (!parameters.IsPlaying && EditorHelper.GetMouseOverRect(new Rect(5f, start, timeLineRect.width - 9f, 30f)))
            {
                Vector2 mousePosition = Event.current.mousePosition;
                var     dif           = x_dif / _koef;
                var     frame         = (mousePosition.x - 5f) / dif;
                ChangeCurrentFrame(Mathf.RoundToInt(frame), parameters);
            }
        }
        private void ChangeCurrentFrame(int i, TimeLineParameters parameters)
        {
            var frame = Mathf.Clamp(parameters.MinFrame + i, parameters.MinFrame, parameters.MaxFrame);

            if (OnChangeCurrentFrame != null)
            {
                OnChangeCurrentFrame(frame);
            }
        }
        public static void OnDraw(TimeLineParameters parameters, AnimatedGameObject animatedGameObject, Rect controlRect)
        {
            Handles.color = new Color(153f / 256f, 153f / 256f, 153f / 256, 1f);
            var ctrRect1 = new Rect(0, 0, controlRect.width - 10f, RowHeight);
            var ctrRect2 = new Rect(0, 0, 10f, controlRect.height);

            Handles.DrawSolidRectangleWithOutline(ctrRect1, Color.white, new Color(0, 0, 0, 0));
            Handles.DrawSolidRectangleWithOutline(ctrRect2, Color.white, new Color(0, 0, 0, 0));
            Handles.color = Color.black;
            Handles.DrawLine(new Vector3(0, 0), new Vector3(controlRect.width - 10f, 0));
            Handles.DrawLine(new Vector3(10f, RowHeight), new Vector3(controlRect.width - 10f, RowHeight));


            EditorGUILayout.BeginHorizontal(GUILayout.Width(190), GUILayout.Height(RowHeight));
            EditorGUI.BeginChangeCheck();
            animatedGameObject.Toggled = EditorGUILayout.Foldout(animatedGameObject.Toggled, animatedGameObject.GameObject.name);
            if (EditorGUI.EndChangeCheck())
            {
                //ToggleChanged(animatedGameObject.Toggled);
            }
            if (GUILayout.Button("Add", EditorStyles.toolbarDropDown, GUILayout.Width(40), GUILayout.Height(RowHeight)))
            {
                var         mPos      = Event.current.mousePosition;
                GenericMenu toolsMenu = new GenericMenu();
                toolsMenu.AddItem(new GUIContent("Add animation track"), false, OnAddAnimationTrack, animatedGameObject);
                toolsMenu.DropDown(new Rect(mPos.x, mPos.y, 0, 0));
            }
            var rect = new Rect(0, 0, 190, RowHeight);

            if (EditorHelper.GetMouseDownRect(rect, 1))
            {
                var         mousePos  = Event.current.mousePosition;
                GenericMenu toolsMenu = new GenericMenu();
                toolsMenu.AddItem(new GUIContent("Remove GameObject"), false, RemoveGameObject, animatedGameObject);
                toolsMenu.DropDown(new Rect(mousePos.x, mousePos.y, 0, 0));
                GUIUtility.ExitGUI();
            }
            EditorGUILayout.EndHorizontal();

            if (animatedGameObject.Toggled)
            {
                var lastTrackPosition = RowHeight;
                foreach (var track in animatedGameObject.Tracks)
                {
                    var trackRect = new Rect(10f, lastTrackPosition, controlRect.width, RowHeight);
                    GUILayout.BeginArea(trackRect);
                    DrawTrackSection(animatedGameObject, track, trackRect, parameters);
                    GUILayout.EndArea();
                    lastTrackPosition += RowHeight;
                }
            }

            Handles.color = Color.black;
            Handles.DrawAAPolyLine(2f, new Vector3(195f, 0), new Vector3(195f, controlRect.height));
        }
        private void DrawCursor(TimeLineParameters parameters, Rect timelineRect)
        {
            if (parameters.CurrentFrame < parameters.MinFrame || parameters.CurrentFrame > parameters.MaxFrame)
            {
                return;
            }

            var dif = x_dif / _koef;
            var x   = dif * (parameters.CurrentFrame - parameters.MinFrame) + 5;

            Handles.color = Color.red;
            var start = timelineRect.height - 30f;

            Handles.DrawSolidDisc(new Vector3(x, start + 2f), new Vector3(0, 0, 1f), 3f);
            Handles.color = Color.red;
            Handles.DrawAAPolyLine(2f, new Vector3(x, 0), new Vector3(x, start));
        }
        public void OnDraw(TimeLineParameters parameters, Rect timelineRect)
        {
            var framesArea = new Rect(5f, 0f, timelineRect.width - 20f, timelineRect.height - 30f);

            GUILayout.BeginArea(framesArea);
            _gridWidth  = framesArea.width;
            _gridHeight = framesArea.height;
            var frameLength = parameters.MaxFrame - parameters.MinFrame;

            //if (frameLength > )
            x_dif = _gridWidth / frameLength;
            _koef = 1;
            if (x_dif < MinDif)
            {
                _koef  = Mathf.FloorToInt(MinDif / x_dif);
                x_dif *= _koef;
            }
            var linesCount = frameLength / _koef;

            Handles.color = Color.white;
            var i = 0;

            while (i <= linesCount)
            {
                bool evenFrame = i == 0 || i % 5 == 0;
                var  color     = evenFrame
                                        ? Color.black
                                        : new Color(Color.white.r, Color.white.g, Color.white.b, 0.4f);
                if (evenFrame)
                {
                    Handles.color = color;
                    var x = i * x_dif;

                    Handles.DrawLine(new Vector3(x, 0), new Vector3(x, framesArea.height));
                    if (!parameters.IsPlaying && EditorHelper.GetMouseDownRect(new Rect(x - 2f, 0, 4f, _gridHeight)))
                    {
                        ChangeCurrentFrame(i * _koef, parameters);
                    }
                }
                i++;
            }
            GUILayout.EndArea();
            DrawFrameBar(parameters, timelineRect);
            DrawCursor(parameters, timelineRect);
        }
        public static void DrawTrackSection(AnimatedGameObject animatedGameObject, BaseTrack track, Rect trackRect, TimeLineParameters parameters)
        {
            EditorGUILayout.LabelField(track.TrackName);
            DrawTrackMenu(animatedGameObject, track);
            var eventsRect = new Rect(185f, 0, trackRect.width - 205f, RowHeight);

            GUILayout.BeginArea(eventsRect);
            var events       = track.Events.Where(evt => evt.StartFrame <parameters.MaxFrame && evt.EndFrame> parameters.MinFrame).OrderBy(evt => evt.StartFrame).ToList();
            var lastEndFrame = parameters.MinFrame;

            for (int i = 0; i < events.Count; i++)
            {
                var trackEvent = events[i];
                if (trackEvent.StartFrame > lastEndFrame)
                {
                    DrawEmptyEvent(animatedGameObject, track, eventsRect, lastEndFrame, trackEvent.StartFrame, parameters);
                }

                var minFrame = i == 0 ? parameters.MinFrame : events[i - 1].EndFrame;
                var maxFrame = i == events.Count - 1 ? parameters.MaxFrame : events[i + 1].StartFrame;
                DrawTrackEvent(animatedGameObject, track, trackEvent, eventsRect, parameters, minFrame, maxFrame, i);
                lastEndFrame = trackEvent.EndFrame;
                if (i == events.Count - 1 && trackEvent.EndFrame < parameters.MaxFrame)
                {
                    DrawEmptyEvent(animatedGameObject, track, eventsRect, lastEndFrame, parameters.MaxFrame, parameters);
                }
            }
            GUILayout.EndArea();
            Handles.color = Color.black;
            Handles.DrawLine(new Vector3(0, trackRect.height - 1f), new Vector3(trackRect.width, trackRect.height - 1f));
        }
        private static void DrawTrackEvent(AnimatedGameObject animatedGameObject, BaseTrack track, TrackEvent trackEvent, Rect eventsRect, TimeLineParameters parameters, int minFrame, int maxFrame, int index)
        {
            var frameLength     = parameters.MaxFrame - parameters.MinFrame;
            var x_dif           = eventsRect.width / frameLength;
            var backgroundColor = GUI.backgroundColor;

            GUI.backgroundColor = trackEvent.EventInnerColor;
            var evtStyle = FreeSequencerUtility.GetEventStyle();

            var startFr = trackEvent.StartFrame - parameters.MinFrame;
            var start   = Mathf.Clamp(startFr, 0, frameLength);
            var endFr   = trackEvent.EndFrame - parameters.MinFrame;
            var end     = endFr > 0 && frameLength > endFr ? endFr : frameLength;
            var rect    = new Rect(start * x_dif, 0, (end - start) * x_dif, RowHeight);

            if (Event.current.type == EventType.Repaint)
            {
                evtStyle.Draw(rect, false, trackEvent.IsActive, false, false);
            }

            if (trackEvent.IsActive)
            {
                var color = Handles.color;
                Handles.color = new Color(1, 1, 1, 0.3f);
                Handles.DrawSolidRectangleWithOutline(rect, new Color(1, 1, 1, 0.3f), new Color(0, 0, 0, 0));
                Handles.color = color;
            }

            GUILayout.BeginArea(rect);
            GUILayout.Label(trackEvent.EventTitle);
            GUILayout.EndArea();

            var minRect = new Rect(start * x_dif, 0, 5f, RowHeight);
            var maxRect = new Rect(start * x_dif + (end - start) * x_dif - 5f, 0, 5f, RowHeight);

            if (EditorHelper.GetMouseDown())
            {
                var wasDrag = false;
                if (EditorHelper.GetMouseDownRect(minRect) && !trackEvent.IsDragged)
                {
                    wasDrag = trackEvent.IsMinDragged = true;
                }

                if (EditorHelper.GetMouseDownRect(maxRect) && !trackEvent.IsDragged)
                {
                    wasDrag = trackEvent.IsMaxDragged = true;
                }

                if (EditorHelper.GetMouseDownRect(rect))
                {
                    if (OnEventSelection != null)
                    {
                        var holder = new EventSelectionHolder()
                        {
                            AnimatedGameObject = animatedGameObject,
                            Event = trackEvent,
                            Track = track
                        };

                        holder.ResetSelection = !Event.current.shift;

                        OnEventSelection(holder);
                    }
                    trackEvent.InitialDraggedPosition = Event.current.mousePosition;
                    if (!trackEvent.IsMinDragged && !trackEvent.IsMaxDragged)
                    {
                        wasDrag = trackEvent.IsDragged = true;
                    }
                }

                if (!wasDrag)
                {
                    trackEvent.IsDragged    = false;
                    trackEvent.IsMinDragged = false;
                    trackEvent.IsMaxDragged = false;
                }
            }

            if (EditorHelper.GetMouseUp())
            {
                trackEvent.IsDragged    = false;
                trackEvent.IsMinDragged = false;
                trackEvent.IsMaxDragged = false;
            }

            if (trackEvent.IsMinDragged || trackEvent.IsMaxDragged || trackEvent.IsDragged)
            {
                if (EditorHelper.GetMouseDrag())
                {
                    var position        = Event.current.mousePosition;
                    var initialPosition = trackEvent.InitialDraggedPosition;

                    var difX      = initialPosition.x - position.x;
                    int framesDif = (int)(difX / x_dif) * -1;
                    if (Mathf.Abs(framesDif) > 0)
                    {
                        var newStartFrame = trackEvent.StartFrame + framesDif;
                        var newEndFrame   = trackEvent.EndFrame + framesDif;

                        if (trackEvent.IsMinDragged)
                        {
                            trackEvent.StartFrame = Mathf.Clamp(newStartFrame, minFrame, trackEvent.EndFrame - 1);
                        }

                        if (trackEvent.IsMaxDragged)
                        {
                            trackEvent.EndFrame = Mathf.Clamp(newEndFrame, trackEvent.StartFrame + 1, maxFrame);
                        }

                        if (trackEvent.IsDragged)
                        {
                            if (DraggedEvent != null)
                            {
                                DraggedEvent(new TrackEventDragHolder()
                                {
                                    AnimatedGameObject = animatedGameObject,
                                    TrackEvent         = trackEvent,
                                    Track = track,
                                    Step  = framesDif
                                });
                            }

                            /*var eventLenth = trackEvent.Length;
                             * trackEvent.StartFrame = Mathf.Clamp(newStartFrame, minFrame, maxFrame - eventLenth);
                             * trackEvent.EndFrame = Mathf.Clamp(newEndFrame, trackEvent.StartFrame + eventLenth, maxFrame);*/
                        }

                        if (OnEventDragged != null)
                        {
                            OnEventDragged(new EventSelectionHolder()
                            {
                                AnimatedGameObject = animatedGameObject,
                                Event = trackEvent,
                                Track = track
                            });
                        }
                        trackEvent.InitialDraggedPosition = position;
                    }
                }

                var holder = new EventSelectionHolder()
                {
                    AnimatedGameObject = animatedGameObject,
                    Event = trackEvent,
                    Track = track
                };
                if (OnEventSelection != null)
                {
                    OnEventSelection(holder);
                }
            }

            if (EditorHelper.GetMouseDownRect(rect, 1))
            {
                var         mousePos  = Event.current.mousePosition;
                GenericMenu toolsMenu = new GenericMenu();
                toolsMenu.AddItem(new GUIContent("Remove event"), false, OnRemoveEvent, new RemoveEventHolder()
                {
                    Event = trackEvent, Track = track, AnimatedGameObject = animatedGameObject
                });
                if (index > 0)
                {
                    var moveLeftHolder = new MoveHolder()
                    {
                        AnimatedGameObject = animatedGameObject,
                        Track     = track,
                        Event     = trackEvent,
                        MoveRight = false
                    };


                    toolsMenu.AddSeparator(string.Empty);
                    toolsMenu.AddItem(new GUIContent("Move left"), false, OnMove, moveLeftHolder);
                }

                if (index < track.Events.Count - 1)
                {
                    var moveRightHolder = new MoveHolder()
                    {
                        AnimatedGameObject = animatedGameObject,
                        Track     = track,
                        Event     = trackEvent,
                        MoveRight = true
                    };
                    toolsMenu.AddSeparator(string.Empty);
                    toolsMenu.AddItem(new GUIContent("Move right"), false, OnMove, moveRightHolder);
                }

                toolsMenu.DropDown(new Rect(mousePos.x, mousePos.y, 0, 0));
                GUIUtility.ExitGUI();
            }

            GUI.backgroundColor = backgroundColor;
        }
        private static void DrawEmptyEvent(AnimatedGameObject animatedGameObject, BaseTrack track, Rect eventsRect, int startFrame, int endFrame, TimeLineParameters parameters)
        {
            var frameLength = parameters.MaxFrame - parameters.MinFrame;
            var x_dif       = eventsRect.width / frameLength;

            var startFr = startFrame - parameters.MinFrame;
            var start   = Mathf.Clamp(startFr, 0, frameLength);
            var end     = Mathf.Clamp(endFrame - startFr - parameters.MinFrame, 0, frameLength);
            var rect    = new Rect(start * x_dif, 0, end * x_dif, RowHeight);

            if (EditorHelper.GetMouseDownRect(rect, 1))
            {
                var         mousePos  = Event.current.mousePosition;
                GenericMenu toolsMenu = new GenericMenu();
                toolsMenu.AddItem(new GUIContent("Add new event"), false, OnAddEvent, new AddEventHolder()
                {
                    StartFrame = startFrame, EndFrame = endFrame, Track = track, AnimatedGameObject = animatedGameObject
                });
                toolsMenu.DropDown(new Rect(mousePos.x, mousePos.y, 0, 0));
                GUIUtility.ExitGUI();
            }
        }