protected override void OnRender(DrawingContext drawingContext)
        {
            base.OnRender(drawingContext);

            if (AdornedElement == null || _pen == null || DoubleUtil.IsZero(_length))
            {
                return;
            }

            var screenPos = new Utils.Win32.POINT();

            if (Utils.Win32.GetCursorPos(ref screenPos))
            {
                var pos = AdornedElement.PointFromScreen(new Point(screenPos.X, screenPos.Y));

                drawingContext.DrawLine(_pen, new Point(pos.X, 0), new Point(pos.X, _length));
                drawingContext.DrawLine(_pen, new Point(0, pos.Y), new Point(_length, pos.Y));
            }
        }
示例#2
0
        private void MoveChild(UIElement dragedChild)
        {
            var screenPos = new Utils.Win32.POINT();

            if (!Utils.Win32.GetCursorPos(ref screenPos))
            {
                return;
            }

            var posToPanel    = AssociatedObject.PointFromScreen(new Point(screenPos.X, screenPos.Y));
            var dragedElement = dragedChild as FrameworkElement;

            var childRect = new Rect(posToPanel.X - _cacheMouseDownToChildPos.X, DisabledYPosition ? _cacheChildToPanelPos.Y : (posToPanel.Y - _cacheMouseDownToChildPos.Y), dragedElement.ActualWidth, dragedElement.ActualHeight);

            //find the child which has max overlapping area with dragedChild
            Size?            maxOverlapSize  = null;
            FrameworkElement maxOverlapChild = null;

            foreach (FrameworkElement fe in AssociatedObject.Children)
            {
                if (fe == dragedElement)
                {
                    continue;
                }

                var sp          = fe.TranslatePoint(new Point(), AssociatedObject);
                var overlapSize = GetOverlapSize(new Rect(sp, new Point(sp.X + fe.ActualWidth, sp.Y + fe.ActualHeight)), childRect);

                if (overlapSize.IsEmpty)
                {
                    continue;
                }

                if (maxOverlapSize == null || DoubleUtil.GreaterThan(overlapSize.Width * overlapSize.Height, maxOverlapSize.Value.Width * maxOverlapSize.Value.Height))
                {
                    maxOverlapSize  = overlapSize;
                    maxOverlapChild = fe;
                }
            }

            //check the overlapping area whether match the exchanging child condition
            if (!maxOverlapSize.HasValue || maxOverlapSize.Value.IsEmpty)
            {
                return;
            }

            if (DoubleUtil.GreaterThanOrClose(maxOverlapSize.Value.Width, maxOverlapChild.ActualWidth / 2) && DoubleUtil.GreaterThanOrClose(maxOverlapSize.Value.Height, maxOverlapChild.ActualHeight / 2))
            {
                var targetIndex = AssociatedObject.Children.IndexOf(maxOverlapChild);

                if (IsFromItemsPanelTemplate)
                {
                    var sourceIndex = AssociatedObject.Children.IndexOf(dragedChild);

                    if (ItemsContainer.ItemsSource != null)
                    {
                        if (MoveItemFromItemsSource != null)
                        {
                            MoveItemFromItemsSource(sourceIndex, targetIndex);

                            //if use ObservableCollection.Move(...) to exchange position, follow code is unnecessary.
                            //else use ObservableCollection.RemoveAt(...) and ObservableCollection.Insert(...) to exchange position, follow code is necessary.
                            _dragedChild         = AssociatedObject.Children[targetIndex];
                            _dragedChild.Opacity = 0;
                        }
                    }
                    else
                    {
                        var sourceItem = ItemsContainer.Items[sourceIndex];

                        ItemsContainer.Items.RemoveAt(sourceIndex);
                        ItemsContainer.Items.Insert(targetIndex, sourceItem);

                        _dragedChild         = AssociatedObject.Children[targetIndex];
                        _dragedChild.Opacity = 0;
                    }
                }
                else
                {
                    AssociatedObject.Children.Remove(dragedChild);
                    AssociatedObject.Children.Insert(targetIndex, dragedChild);
                }
            }
        }