private void panTimelineViewer_DragDrop(object sender, DragEventArgs e)
        {
            if (TimelineDragDropInsertIndex >= 0)
            {
                Timeline ItemToMove = GetTimelineEvent(TimelineDragDropSelectedItemIndex, true);
                InsertTimelineEvent(TimelineDragDropInsertIndex, ItemToMove, false);
                FinishTimelineEventRemove();
            }
            else if (TimelineDragDropInsertIndex == -1)
            {
                Point MousePos = PointToClient(new Point(e.X, e.Y));

                int NewDragDropInsertIndex = (MousePos.Y - 20) / 21 + vsbTimeline.Value;
                if (NewDragDropInsertIndex < TimelineActiveItems)
                {
                    if (NewDragDropInsertIndex != TimelineDragDropSelectedItemIndex)
                    {
                        GroupTimeline SelectGroup = GetTimelineEvent(NewDragDropInsertIndex) as GroupTimeline;
                        Timeline      ItemToMove  = GetTimelineEvent(TimelineDragDropSelectedItemIndex, true);

                        if (SelectGroup != null)
                        {
                            InsertTimelineEvent(NewDragDropInsertIndex, ItemToMove, true);
                        }
                    }
                }
                FinishTimelineEventRemove();
            }
            TimelineDragDropInsertIndex = -1;
            DrawTimeline();
        }
        private void InsertTimelineEvent(int TargetIndex, Timeline ActiveEvent, bool InsertInGroup)
        {
            int CurrentIndex = 0;

            for (int i = 0; i < ActiveAnimation.ListTimelineEvent.Count; i++)
            {
                if (ActiveAnimation.ListTimelineEvent[i] == null)
                {
                    if (TargetIndex == i)
                    {
                        break;
                    }
                    else
                    {
                        CurrentIndex++;
                        continue;
                    }
                }

                GroupTimeline ActiveGroup = ActiveAnimation.ListTimelineEvent[i] as GroupTimeline;

                if (CurrentIndex == TargetIndex)
                {
                    if (InsertInGroup && ActiveGroup != null)
                    {
                        ActiveEvent.GroupIndex = (int)ActiveGroup.KeyValue;
                        ActiveGroup.ListEvent.Add(ActiveEvent);
                        return;
                    }
                    else
                    {
                        ActiveEvent.GroupIndex = -1;
                        ActiveAnimation.ListTimelineEvent.Insert(i, ActiveEvent);
                        return;
                    }
                }
                if (ActiveGroup != null)
                {
                    if (InsertTimelineEvent(TargetIndex, ref CurrentIndex, ActiveGroup, ActiveEvent, InsertInGroup))
                    {
                        return;
                    }
                }
                else
                {
                    CurrentIndex++;
                }
            }
            if (CurrentIndex <= TargetIndex)
            {
                ActiveEvent.GroupIndex = -1;
                ActiveAnimation.ListTimelineEvent.Insert(CurrentIndex, ActiveEvent);
                return;
            }
        }
예제 #3
0
        public override Timeline Copy(AnimationClass.AnimationLayer ActiveLayer)
        {
            GroupTimeline NewGroupEvent = new GroupTimeline(Name);

            NewGroupEvent.UpdateFrom(this, ActiveLayer);

            NewGroupEvent.ListEvent = ListEvent;

            NewGroupEvent.KeyValue = KeyValue;
            NewGroupEvent.IsOpen   = IsOpen;

            return(NewGroupEvent);
        }
        private bool InsertTimelineEvent(int TargetIndex, ref int CurrentIndex, GroupTimeline ActiveGroup, Timeline ActiveEvent, bool InsertInGroup)
        {
            if (CurrentIndex == TargetIndex)
            {
                ActiveEvent.GroupIndex = ActiveGroup.GroupIndex;
                ActiveGroup.ListEvent.Insert(0, ActiveEvent);
                return(true);
            }

            CurrentIndex++;
            if (!ActiveGroup.IsOpen)
            {
                return(false);
            }

            for (int i = 0; i < ActiveGroup.ListEvent.Count; i++)
            {
                if (ActiveGroup.ListEvent[i] == null)
                {
                    CurrentIndex++;
                    continue;
                }

                GroupTimeline ChildGroup = ActiveGroup.ListEvent[i] as GroupTimeline;
                if (ChildGroup != null)
                {
                    if (InsertInGroup && CurrentIndex == TargetIndex)
                    {
                        ActiveEvent.GroupIndex = (int)ChildGroup.KeyValue;
                        ChildGroup.ListEvent.Add(ActiveEvent);
                        return(true);
                    }
                    else if (InsertTimelineEvent(TargetIndex, ref CurrentIndex, ChildGroup, ActiveEvent, InsertInGroup))
                    {
                        return(true);
                    }
                }
                else
                {
                    if (CurrentIndex == TargetIndex)
                    {
                        ActiveGroup.ListEvent.Insert(i, ActiveEvent);
                        return(true);
                    }
                    CurrentIndex++;
                }
            }
            return(false);
        }
            public virtual void LoadLayer(BinaryReader BR, Microsoft.Xna.Framework.Content.ContentManager Content, Dictionary <string, Timeline> DicTimeline)
            {
                Name                = BR.ReadString();
                LayerBlendState     = (LayerBlendStates)BR.ReadByte();
                _LayerSamplerStates = (LayerSamplerStates)BR.ReadByte();
                UpdateSamplerState();

                int DicGroupEventCount = BR.ReadInt32();

                DicGroupEvent = new Dictionary <uint, GroupTimeline>(DicGroupEventCount);
                for (int T = 0; T < DicGroupEventCount; T++)
                {
                    uint          Key        = BR.ReadUInt32();
                    GroupTimeline NewGroup   = new GroupTimeline(BR.ReadString());
                    int           GroupIndex = BR.ReadInt32();
                    NewGroup.GroupIndex = GroupIndex;
                    NewGroup.KeyValue   = Key;
                    DicGroupEvent.Add(Key, NewGroup);
                }

                int DicTimelineEventCount = BR.ReadInt32();

                DicTimelineEvent = new Dictionary <int, List <Timeline> >(DicTimelineEventCount);
                for (int T = 0; T < DicTimelineEventCount; T++)
                {
                    int ListEventCount = BR.ReadInt32();

                    for (int E = 0; E < ListEventCount; E++)
                    {
                        Timeline ActiveEvent = Timeline.Load(BR, Content, this, DicTimeline);

                        if (!DicTimelineEvent.ContainsKey(ActiveEvent.SpawnFrame))
                        {
                            DicTimelineEvent.Add(ActiveEvent.SpawnFrame, new List <Timeline>());
                        }

                        DicTimelineEvent[ActiveEvent.SpawnFrame].Add(ActiveEvent);
                    }
                }
                int ChildrenCount = BR.ReadInt32();

                for (int L = 0; L < ChildrenCount; L++)
                {
                    AnimationLayer NewChildrenLayer = new AnimationLayer(Owner, "");
                    NewChildrenLayer.LoadLayer(BR, Content, DicTimeline);
                    ListChildren.Add(NewChildrenLayer);
                }
            }
        private void DrawGroup(ref int Index, ref int VisibleIndex, int Indent, GroupTimeline ActiveGroup)
        {
            if (Index >= vsbTimeline.Value)
            {
                if (ActiveAnimation.ListSelectedObjects.Contains(ActiveGroup))
                {
                    panTimelineViewerGraphicDevice.Graphics.FillRectangle(Brushes.CornflowerBlue, new Rectangle(10, 20 + VisibleIndex * 21, 100, 20));
                }

                if (ActiveGroup.IsOpen)
                {
                    panTimelineViewerGraphicDevice.Graphics.DrawLine(Pens.Black, 1 + Indent * 5, 30 + VisibleIndex * 21, 6 + Indent * 5, 30 + VisibleIndex * 21);
                    panTimelineViewerGraphicDevice.Graphics.DrawLine(Pens.Black, 1 + Indent * 5, 30 + VisibleIndex * 21, 6 + Indent * 5, 25 + VisibleIndex * 21);
                    panTimelineViewerGraphicDevice.Graphics.DrawLine(Pens.Black, 6 + Indent * 5, 25 + VisibleIndex * 21, 6 + Indent * 5, 30 + VisibleIndex * 21);
                }
                else
                {
                    panTimelineViewerGraphicDevice.Graphics.DrawLine(Pens.Black, 2 + Indent * 5, 22 + VisibleIndex * 21, 6 + Indent * 5, 26 + VisibleIndex * 21);
                    panTimelineViewerGraphicDevice.Graphics.DrawLine(Pens.Black, 2 + Indent * 5, 30 + VisibleIndex * 21, 6 + Indent * 5, 26 + VisibleIndex * 21);
                    panTimelineViewerGraphicDevice.Graphics.DrawLine(Pens.Black, 2 + Indent * 5, 22 + VisibleIndex * 21, 2 + Indent * 5, 30 + VisibleIndex * 21);
                }
                panTimelineViewerGraphicDevice.Graphics.DrawString(ActiveGroup.Name, fntListView, Brushes.Black, 10 + Indent * 5, 20 + VisibleIndex * 21);
                ++VisibleIndex;
            }
            Index++;

            if (ActiveGroup.IsOpen)
            {
                for (int i = 0; i < ActiveGroup.ListEvent.Count; i++)
                {
                    Timeline      ChildEvent = ActiveGroup.ListEvent[i];
                    GroupTimeline ChildGroup = ChildEvent as GroupTimeline;

                    if (ChildGroup != null)
                    {
                        DrawGroup(ref Index, ref VisibleIndex, Indent + 1, ChildGroup);
                    }
                    else
                    {
                        if (Index >= vsbTimeline.Value)
                        {
                            DrawTimelineEvent(Indent + 1, ref VisibleIndex, ChildEvent);
                        }
                        Index++;
                    }
                }
            }
        }
        private void tsmCreateGroup_Click(object sender, EventArgs e)
        {
            GroupTimeline NewGroup = new GroupTimeline();

            ActiveAnimation.ListTimelineEvent.Add(NewGroup);
            uint InsertIndex = 0;

            while (ActiveLayer.DicGroupEvent.ContainsKey(InsertIndex))
            {
                InsertIndex++;
            }

            NewGroup.KeyValue = InsertIndex;
            ActiveLayer.DicGroupEvent.Add(InsertIndex, NewGroup);
            UpdateTimelineVisibleItems();
            DrawTimeline();
        }
        private void FinishTimelineEventRemove(GroupTimeline ActiveGroup)
        {
            for (int i = 0; i < ActiveGroup.ListEvent.Count; i++)
            {
                if (ActiveGroup.ListEvent[i] == null)
                {
                    ActiveGroup.ListEvent.RemoveAt(i--);
                }
                else
                {
                    GroupTimeline ChildGroup = ActiveGroup.ListEvent[i] as GroupTimeline;

                    if (ChildGroup != null)
                    {
                        FinishTimelineEventRemove(ChildGroup);
                    }
                }
            }
        }
        private void UpdateTimelineVisibleItems(GroupTimeline ActiveGroup)
        {
            if (!ActiveGroup.IsOpen)
            {
                return;
            }

            for (int i = 0; i < ActiveGroup.ListEvent.Count; i++)
            {
                TimelineActiveItems++;

                GroupTimeline ChildGroup = ActiveGroup.ListEvent[i] as GroupTimeline;

                if (ChildGroup != null)
                {
                    UpdateTimelineVisibleItems(ChildGroup);
                }
            }
        }
        private Timeline GetTimelineEventFromGroup(int TargetIndex, ref int CurrentIndex, GroupTimeline ActiveGroup, bool Remove, int Indent = 1)
        {
            if (!ActiveGroup.IsOpen)
            {
                return(null);
            }

            Timeline TempEvent;

            for (int i = 0; i < ActiveGroup.ListEvent.Count; i++)
            {
                if (CurrentIndex == TargetIndex)
                {
                    TimelineDragDropSelectedItemIndent = Indent;
                    if (Remove)
                    {
                        TempEvent = ActiveGroup.ListEvent[i];
                        ActiveGroup.ListEvent[i] = null;
                        return(TempEvent);
                    }
                    else
                    {
                        return(ActiveGroup.ListEvent[i]);
                    }
                }
                else
                {
                    CurrentIndex++;
                    GroupTimeline ChildGroup = ActiveGroup.ListEvent[i] as GroupTimeline;
                    if (ChildGroup != null)
                    {
                        TempEvent = GetTimelineEventFromGroup(TargetIndex, ref CurrentIndex, ChildGroup, Remove, Indent + 1);
                        if (TempEvent != null)
                        {
                            return(TempEvent);
                        }
                    }
                }
            }
            return(null);
        }
        public void UpdateTimelineVisibleItems()
        {
            TimelineActiveItems = 0;

            for (int i = 0; i < ActiveAnimation.ListTimelineEvent.Count; i++)
            {
                TimelineActiveItems++;

                GroupTimeline ActiveGroup = ActiveAnimation.ListTimelineEvent[i] as GroupTimeline;

                if (ActiveGroup != null)
                {
                    UpdateTimelineVisibleItems(ActiveGroup);
                }
            }

            if (TimelineActiveItems > TimelineVisibleItemCount)
            {
                vsbTimeline.Maximum = 1 + TimelineActiveItems - TimelineVisibleItemCount;
            }
        }
        private void panTimelineViewer_DragOver(object sender, DragEventArgs e)
        {
            Point MousePos = PointToClient(new Point(e.X, e.Y));

            if (MousePos.X < TimelineStartX)
            {
                int NewDragDropInsertIndex = (MousePos.Y - 20) / 21 + vsbTimeline.Value;
                if (NewDragDropInsertIndex < TimelineActiveItems)
                {
                    if (NewDragDropInsertIndex != TimelineDragDropSelectedItemIndex)
                    {
                        GroupTimeline SelectGroup = GetTimelineEvent(NewDragDropInsertIndex) as GroupTimeline;

                        if (SelectGroup != null)
                        {
                            TimelineDragDropInsertIndex = -1;
                        }
                        else
                        {
                            TimelineDragDropInsertIndex = (MousePos.Y - 10) / 21 + vsbTimeline.Value;
                        }
                    }
                    else
                    {
                        TimelineDragDropInsertIndex = -2;
                    }
                }
                else
                {
                    TimelineDragDropInsertIndex = TimelineActiveItems;
                }

                DrawTimeline();
            }
            else
            {
                TimelineDragDropInsertIndex = -2;
            }
        }
        private void SelectTimelineGroup(GroupTimeline ActiveGroup, bool IsSelected)
        {
            for (int i = 0; i < ActiveGroup.ListEvent.Count; i++)
            {
                if (IsSelected)
                {
                    if (!ActiveAnimation.ListSelectedObjects.Contains(ActiveGroup.ListEvent[i]))
                    {
                        ActiveAnimation.ListSelectedObjects.Add(ActiveGroup.ListEvent[i]);
                    }
                }
                else
                {
                    ActiveAnimation.ListSelectedObjects.Remove(ActiveGroup.ListEvent[i]);
                }

                GroupTimeline ChildGroup = ActiveGroup.ListEvent[i] as GroupTimeline;

                if (ChildGroup != null)
                {
                    SelectTimelineGroup(ChildGroup, IsSelected);
                }
            }
        }
        private Timeline GetTimelineEvent(int TargetIndex, bool Remove = false)
        {
            int      CurrentIndex = 0;
            Timeline TempEvent;

            for (int i = 0; i < ActiveAnimation.ListTimelineEvent.Count; i++)
            {
                if (CurrentIndex == TargetIndex)
                {
                    TimelineDragDropSelectedItemIndent = 0;
                    if (Remove)
                    {
                        TempEvent = ActiveAnimation.ListTimelineEvent[i];
                        ActiveAnimation.ListTimelineEvent[i] = null;
                        return(TempEvent);
                    }
                    else
                    {
                        return(ActiveAnimation.ListTimelineEvent[i]);
                    }
                }

                CurrentIndex++;
                GroupTimeline ActiveGroup = ActiveAnimation.ListTimelineEvent[i] as GroupTimeline;

                if (ActiveGroup != null)
                {
                    TempEvent = GetTimelineEventFromGroup(TargetIndex, ref CurrentIndex, ActiveGroup, Remove);
                    if (TempEvent != null)
                    {
                        return(TempEvent);
                    }
                }
            }
            return(null);
        }
        private void DrawTimeline()
        {
            panTimelineViewerGraphicDevice.Graphics.Clear(Color.White);
            int TimelineWidth = Width - TimelineStartX;

            //Draw Key Frame limit lines.
            for (int X = ScrollbarStartIndex < 8 ? -ScrollbarStartIndex : -ScrollbarStartIndex % 8, i = ScrollbarStartIndex < 8 ? 0 : 5 - (ScrollbarStartIndex / 8) % 5; X < TimelineStartX + TimelineWidth - 1 - TimelineStartX; X += 8)
            {
                if (i == 0)
                {
                    panTimelineViewerGraphicDevice.Graphics.DrawLine(Pens.Black, TimelineStartX + X, 0, TimelineStartX + X, 5);
                    panTimelineViewerGraphicDevice.Graphics.DrawLine(Pens.Black, TimelineStartX + X, 15, TimelineStartX + X, 20);
                    i = 4;
                }
                else
                {
                    panTimelineViewerGraphicDevice.Graphics.DrawLine(Pens.Gray, TimelineStartX + X, 0, TimelineStartX + X, 5);
                    panTimelineViewerGraphicDevice.Graphics.DrawLine(Pens.Gray, TimelineStartX + X, 15, TimelineStartX + X, 20);
                    i--;
                }
            }
            panTimelineViewerGraphicDevice.Graphics.DrawRectangle(Pens.Black, new Rectangle(TimelineStartX, 0, TimelineWidth - 1, TimelineHeight - 1));
            panTimelineViewerGraphicDevice.Graphics.DrawLine(Pens.Black, 0, 20, TimelineStartX + TimelineWidth - 1, 20);

            int VisibleIndex = 0;
            int Index        = 0;

            if (ActiveAnimation != null)
            {
                for (int i = 0; i < ActiveAnimation.ListTimelineEvent.Count && VisibleIndex < TimelineVisibleItemCount; i++)
                {
                    Timeline ActiveEvent = ActiveAnimation.ListTimelineEvent[i];

                    GroupTimeline ActiveGroup = ActiveEvent as GroupTimeline;

                    if (ActiveGroup != null)
                    {
                        DrawGroup(ref Index, ref VisibleIndex, 0, ActiveGroup);
                    }
                    else
                    {
                        if (Index >= vsbTimeline.Value)
                        {
                            DrawTimelineEvent(0, ref VisibleIndex, ActiveEvent);
                        }

                        ++Index;
                    }

                    if (TimelineDragDropInsertIndex >= 0)
                    {
                        panTimelineViewerGraphicDevice.Graphics.DrawLine(Pens.Black, 5, 20 + (TimelineDragDropInsertIndex - vsbTimeline.Value) * 21, TimelineStartX - 5, 20 + (TimelineDragDropInsertIndex - vsbTimeline.Value) * 21);
                    }
                }

                if (PlaybackEndKeyFrame >= 0)
                {
                    panTimelineViewerGraphicDevice.Graphics.FillRectangle(PlaybackBrush, new Rectangle(TimelineStartX + PlaybackStartKeyFrame * 8 - ScrollbarStartIndex, 0, (PlaybackEndKeyFrame - PlaybackStartKeyFrame) * 8 - ScrollbarStartIndex, TimelineHeight - 1));
                }

                //Draw the timeline cursor.
                panTimelineViewerGraphicDevice.Graphics.FillRectangle(Brushes.LightSalmon, new Rectangle(TimelineStartX + ActiveKeyFrame * 8 - ScrollbarStartIndex, 0, 8, 20));
                panTimelineViewerGraphicDevice.Graphics.DrawRectangle(Pens.Red, new Rectangle(TimelineStartX + ActiveKeyFrame * 8 - ScrollbarStartIndex, 0, 8, 20));
                panTimelineViewerGraphicDevice.Graphics.DrawLine(Pens.Red, TimelineStartX + ActiveKeyFrame * 8 - ScrollbarStartIndex, 0, TimelineStartX + ActiveKeyFrame * 8 - ScrollbarStartIndex, TimelineHeight - 1);
            }

            //Draw the Key Frames.
            for (int X = -ScrollbarStartIndex % 40 + 1, i = (ScrollbarStartIndex / 40) * 5; X < TimelineWidth - 1; X += 40, i += 5)
            {
                panTimelineViewerGraphicDevice.Graphics.DrawString(i.ToString(), fntTimeline, Brushes.Black, TimelineStartX + X, 6);
            }

            #region Scrollbar

            panTimelineViewerGraphicDevice.Graphics.FillRectangle(Brushes.DarkGray, new Rectangle(TimelineStartX, TimelineHeight, TimelineWidth, 20));
            panTimelineViewerGraphicDevice.Graphics.FillRectangle(Brushes.LightGray, new Rectangle(TimelineStartX + 1, TimelineHeight + 1, 18, 18));
            panTimelineViewerGraphicDevice.Graphics.FillRectangle(Brushes.LightGray, new Rectangle(TimelineStartX + TimelineWidth - 19, TimelineHeight + 1, 18, 18));

            int   ScrollbarPos         = (int)(ScrollbarWidth / (float)TimelineWidth * ScrollbarStartIndex);
            float ScrollbarActualWidth = Width - TimelineStartX - 40 - ScrollbarWidth;

            ScrollbarPos = (int)(ScrollbarStartIndex * (ScrollbarActualWidth / MaximumKeyFrame));

            panTimelineViewerGraphicDevice.Graphics.FillRectangle(Brushes.LightGray, new Rectangle(TimelineStartX + 20 + ScrollbarPos, TimelineHeight + 1, ScrollbarWidth, 18));

            #endregion

            panTimelineViewerGraphicDevice.Render();
        }
        private void panTimelineViewer_MouseDown(object sender, MouseEventArgs e)
        {
            MouseEventOriginal = e;
            MouseEventOld      = e;

            if (e.X < 0)
            {
                return;
            }

            #region Left Button

            if (e.Button == MouseButtons.Left)
            {
                if (e.X < TimelineStartX)
                {
                    TimelineDragDropSelectedItemIndex = -2;
                    int VisibleIndex = 0;

                    for (int i = 0; i < TimelineActiveItems && VisibleIndex < TimelineVisibleItemCount; i++)
                    {
                        ActiveTimelineEvent = GetTimelineEvent(i);

                        //End of TimelineEvent list.
                        if (ActiveTimelineEvent == null)
                        {
                            break;
                        }

                        if (e.Y >= (VisibleIndex + 1) * 20 && e.Y < (VisibleIndex + 2) * 20 && i >= vsbTimeline.Value)
                        {
                            TimelineDragDropSelectedItemIndex = i;
                        }
                        else
                        {
                            if (Control.ModifierKeys != Keys.Shift)
                            {
                                ActiveAnimation.ListSelectedObjects.Remove(ActiveTimelineEvent);
                                GroupTimeline ActiveGroup = ActiveTimelineEvent as GroupTimeline;

                                if (ActiveGroup != null)
                                {
                                    SelectTimelineGroup(ActiveGroup, false);
                                }
                            }
                        }
                        if (i >= vsbTimeline.Value)
                        {
                            VisibleIndex++;
                        }
                    }

                    if (TimelineDragDropSelectedItemIndex >= 0)
                    {
                        ActiveTimelineEvent = GetTimelineEvent(TimelineDragDropSelectedItemIndex);
                        GroupTimeline ActiveGroup = ActiveTimelineEvent as GroupTimeline;

                        if (ActiveGroup != null)
                        {
                            //Expend/Collapse the group
                            if (e.X >= 1 + TimelineDragDropSelectedItemIndent * 5 && e.X < 9 + TimelineDragDropSelectedItemIndent * 5)
                            {
                                ActiveGroup.IsOpen = !ActiveGroup.IsOpen;
                                TimelineDragDropSelectedItemIndex = -2;
                                UpdateTimelineVisibleItems();
                            }
                            else
                            {
                                SelectTimelineGroup(ActiveGroup, true);
                                OnTimelineSelected(ActiveTimelineEvent);
                            }
                        }
                        else
                        {
                            OnTimelineSelected(ActiveTimelineEvent);
                        }
                    }
                    DrawTimeline();
                }
                else if (e.Y <= 20)
                {
                    OnKeyFrameChange((e.X - TimelineStartX + ScrollbarStartIndex) / 8);
                    PlaybackStartKeyFrame = ActiveKeyFrame;
                    PlaybackEndKeyFrame   = -1;
                    DrawTimeline();
                }
                else if (e.Y >= Height - 20)
                {
                    ScrollbarSelected = true;
                }
                else if (ActiveTimelineEvent == null)
                {
                    int MouseFrameHalf  = (e.X - TimelineStartX + ScrollbarStartIndex + 4) / 8;
                    int MouseEventFrame = (e.X - TimelineStartX + ScrollbarStartIndex) / 8;

                    for (int i = vsbTimeline.Value, VisibleIndex = 0; i < TimelineActiveItems && VisibleIndex < TimelineVisibleItemCount; i++, VisibleIndex++)
                    {
                        if (e.Y < (VisibleIndex + 1) * 20 || e.Y >= (VisibleIndex + 2) * 20)
                        {
                            continue;
                        }

                        Timeline ActiveEvent = GetTimelineEvent(i);
                        ActiveTimelineEvent = ActiveEvent;

                        AnimationObjectKeyFrame ActiveAnimationObjectKeyFrame = null;

                        if (MouseEventFrame == ActiveEvent.SpawnFrame)
                        {
                            TimelineResizeSide = TimelineResizeSides.Left;
                        }
                        else if (MouseFrameHalf == ActiveEvent.DeathFrame)
                        {
                            TimelineResizeSide = TimelineResizeSides.Right;
                        }
                        else if (ActiveEvent.TryGetValue(MouseEventFrame, out ActiveAnimationObjectKeyFrame))
                        {
                            OnKeyFrameSelected(ActiveAnimationObjectKeyFrame);
                            TimelineResizeSide = TimelineResizeSides.MoveKeyFrame;
                        }
                        else if (MouseEventFrame > ActiveEvent.SpawnFrame && MouseEventFrame < ActiveEvent.DeathFrame)
                        {
                            TimelineResizeSide = TimelineResizeSides.All;
                        }
                    }
                }
            }

            #endregion

            #region Right Button

            else if (e.Button == MouseButtons.Right)
            {
                Timeline ActiveEvent;

                if (e.X < TimelineStartX)
                {
                    for (int i = vsbTimeline.Value, VisibleIndex = 0; i < TimelineActiveItems && VisibleIndex < TimelineVisibleItemCount; i++, VisibleIndex++)
                    {
                        ActiveEvent = GetTimelineEvent(i);

                        if (e.Y < (VisibleIndex + 1) * 20 || e.Y >= (VisibleIndex + 2) * 20)
                        {
                            ActiveAnimation.ListSelectedObjects.Remove(ActiveEvent);
                            continue;
                        }

                        ActiveAnimation.ListSelectedObjects.Add(ActiveEvent);
                        ActiveTimelineEvent = ActiveEvent;
                    }
                    DrawTimeline();
                }
                else
                {
                    ActiveKeyFrame = (e.X - TimelineStartX + ScrollbarStartIndex) / 8;

                    for (int i = vsbTimeline.Value, VisibleIndex = 0; i < TimelineActiveItems && VisibleIndex < TimelineVisibleItemCount; i++, VisibleIndex++)
                    {
                        if (e.Y < (VisibleIndex + 1) * 20 || e.Y >= (VisibleIndex + 2) * 20)
                        {
                            continue;
                        }

                        ActiveEvent = GetTimelineEvent(i);

                        ActiveTimelineEvent = ActiveEvent;
                    }
                }
            }

            #endregion
        }