//TODO: Fix adorners not being drawn correctly after moving if scale != 1 or being redrawn on scale change

        /// <summary>
        /// Adds adorner to items in list
        /// </summary>
        /// <param name="modifiedList">List of item Points</param>
        private void RenderAdorner(object sender, NotifyCollectionChangedEventArgs e)
        {
            if (e.Action == NotifyCollectionChangedAction.Add && selectedItems.Count > 0)
            {
                ClearAdorner();

                Point pos;
                var   item = Items[0];

                if (selectedPos.Count > 1)
                {
                    pos = LerpMath.CalculateAverage(selectedPos);
                }
                else
                {
                    pos = selectedPos[0];
                }

                var myAdornerLayer = AdornerLayer.GetAdornerLayer(item);
                RenderDragHandles(item, myAdornerLayer, camera.OffsetPosition(pos, true));

                for (int i = 0; i < selectedPos.Count; i++)
                {
                    for (int j = 0; j < Items.Count; j++)
                    {
                        if (Items[j] is Rectangle)
                        {
                            var   listItem = Items[j];
                            Point itemPos  = camera.OffsetPosition(new Point(Canvas.GetLeft(listItem), Canvas.GetTop(listItem)));

                            if (LerpMath.CalculateDelta(selectedPos[i].X, itemPos.X) <= 2.5 && LerpMath.CalculateDelta(selectedPos[i].Y, itemPos.Y) <= 2.5)
                            {
                                RenderSelection(listItem, AdornerLayer.GetAdornerLayer(item));
                                break;
                            }
                        }
                    }
                }
            }
            else
            {
                ClearAdorner();
            }
        }
        private void HandleSelection(object sender, MouseButtonEventArgs e)
        {
            //If rectangle hit
            if (e.OriginalSource.GetType() == typeof(Rectangle))
            {
                if (selectedItems.Count > 0 && !_shift)
                {
                    ClearItems();
                }

                Rectangle rect = (Rectangle)e.OriginalSource;
                selectedPos.Add(camera.OffsetPosition(new Point(Canvas.GetLeft(rect), Canvas.GetTop(rect))));

                if (rect != null && String.IsNullOrEmpty(rect.Name))
                {
                    var myAdornerLayer = AdornerLayer.GetAdornerLayer(rect);

                    if (myAdornerLayer != null)
                    {
                        if (selectedPos.Count > 1)
                        {
                            Point avgPosition = LerpMath.CalculateAverage(selectedPos);

                            Point offset = LerpMath.CalculateDelta(
                                modelitems.Item.Curve[selectedItems[0].Item1].Points[selectedItems[0].Item2],
                                avgPosition,
                                true
                                );
                        }
                        else
                        {
                            RenderSelection(rect, myAdornerLayer);
                        }

                        var matches = Regex.Matches(rect.Tag.ToString(), "[0-9]{1,3}");

                        if (!Keyboard.IsKeyDown(Key.LeftShift) && !Keyboard.IsKeyDown(Key.RightShift))
                        {
                            ClearItems();
                            selectedPos.Add(camera.OffsetPosition(new Point(Canvas.GetLeft(rect), Canvas.GetTop(rect))));
                        }

                        selectedItems.Add(new Tuple <int, int>(Convert.ToInt32(matches[0].ToString()), Convert.ToInt32(matches[1].ToString())));
                    }
                }

                _shift = false;
            }

            //Drag selection
            else if (_dragDropped && (3 * camera.GetScale) < LerpMath.CalculateDelta(dragOrigin[0], dragEnd[0]) ||
                     (3 * camera.GetScale) < LerpMath.CalculateDelta(dragOrigin[1], dragEnd[1]))
            {
                if ((DateTime.Now - _time).Milliseconds > 100)
                {
                    if (!_shift)
                    {
                        ClearItems();
                    }

                    _shift = false;

                    for (int j = 0; j < modelitems.Item.Curve.Count; j++)
                    {
                        var list = modelitems.Item.Curve[j].Original;

                        double minX = (dragOrigin[0] < dragEnd[0]) ? dragOrigin[0] : dragEnd[0];
                        double minY = (dragOrigin[1] < dragEnd[1]) ? dragOrigin[1] : dragEnd[1];

                        double maxX = (dragOrigin[0] > dragEnd[0]) ? dragOrigin[0] : dragEnd[0];
                        double maxY = (dragOrigin[1] > dragEnd[1]) ? dragOrigin[1] : dragEnd[1];


                        for (int i = 0; i < _Canvas.Children.Count; i++)
                        {
                            if (_Canvas.Children[i] is Rectangle)
                            {
                                Rectangle rect = (Rectangle)_Canvas.Children[i];

                                if ((minX - 3) < Canvas.GetLeft(rect) && (maxX + 3) > Canvas.GetLeft(rect))
                                {
                                    if ((minY - 3) < Canvas.GetTop(rect) && (maxY + 3) > Canvas.GetTop(rect))
                                    {
                                        var matches = Regex.Matches(rect.Tag.ToString(), "[0-9]{1,3}");
                                        Tuple <int, int> curvePointNr = new Tuple <int, int>(Convert.ToInt32(matches[0].ToString()), Convert.ToInt32(matches[1].ToString()));
                                        bool             exists       = false;

                                        if (selectedItems.IndexOf(curvePointNr) != -1)
                                        {
                                            exists = true;
                                        }

                                        if (!exists)
                                        {
                                            selectedPos.Add(camera.OffsetPosition(new Point(Canvas.GetLeft(rect), Canvas.GetTop(rect))));
                                            selectedItems.Add(curvePointNr);

                                            dragOrigin[0] = Canvas.GetLeft(rect);
                                            dragOrigin[1] = Canvas.GetTop(rect);

                                            var myAdornerLayer = AdornerLayer.GetAdornerLayer(rect);
                                            RenderSelection(rect, myAdornerLayer);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            //Remove selection
            else
            {
                ClearItems();
                draggedItem = null;
            }
        }
        public override void OnMouseDown(object sender, MouseButtonEventArgs e)
        {
            CheckModifier();

            switch (GraphView_ToolHandler.ActiveTool)
            {
            //Select tool
            case 0:

                //Toolhandle
                if (e.ChangedButton == MouseButton.Left && e.OriginalSource.GetType() == typeof(ToolAdorner))
                {
                    ToolAdorner rect = (ToolAdorner)e.OriginalSource;

                    if (Regex.IsMatch(rect.Name, "(left)?(right)?(top)?(bottom)?"))
                    {
                        dragDirection = (rect.Name == "left" || rect.Name == "right") ? dragDirection = 1 : dragDirection = 2;

                        if (selectedPos.Count > 1)
                        {
                            Point origin = LerpMath.CalculateAverage(selectedPos);
                            dragOrigin[0] = origin.X;
                            dragOrigin[1] = origin.Y;
                        }
                        else
                        {
                            dragOrigin[0] = e.GetPosition(_Canvas).X;
                            dragOrigin[1] = e.GetPosition(_Canvas).Y;
                        }

                        draggedItem = rect;
                        return;
                    }
                    return;
                }

                //Drag select
                if (e.ChangedButton == MouseButton.Left && !(e.OriginalSource.GetType() == typeof(Rectangle) &&
                                                             !(e.OriginalSource.GetType() == typeof(ToolAdorner))))
                {
                    _DragSelection = true;
                    _time          = DateTime.Now;

                    dragOrigin[0] = e.GetPosition(_Canvas).X;
                    dragOrigin[1] = e.GetPosition(_Canvas).Y;

                    return;
                }

                //move camera
                if (_alt && e.ChangedButton == MouseButton.Middle)
                {
                    _alt        = false;
                    oldPosition = Mouse.GetPosition(Application.Current.MainWindow);
                    return;
                }

                //drag move
                if (e.ChangedButton == MouseButton.Middle && selectedItems.Count > 0)
                {
                    dragOrigin[2] = Mouse.GetPosition(Application.Current.MainWindow).X;
                    dragOrigin[3] = Mouse.GetPosition(Application.Current.MainWindow).Y;

                    MiddleMouseUsed = true;

                    return;
                }
                break;

            //Insert Point Tool
            case 1:

                if (e.ChangedButton == MouseButton.Left)
                {
                    Point pos = camera.OffsetPosition(e.GetPosition(_Canvas));

                    CurveGraphModel model = ModelItems;
                    // TODO: Need to find ways to separate curves from each other
                    //BezierCurve curve = model.Item.Curve;

                    //curve.InsertPoint(pos);

                    //Add(model);
                }
                break;

            default:
                break;
            }
        }