SHJX_GM/SHJX.Service.Shell/Flowchart/Helper/ItemsControlDragHelper.cs

using System;
using System.Windows;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Shapes;
using System.Windows.Controls;
using System.Windows.Documents;

namespace Flowchart
{
    /// <summary>
    /// Helper class used to start drag&drop operation and display a dragging object
    /// </summary>
    public class ItemsControlDragHelper : IDisposable
    {
        #region DragDropAdorner

        /// <summary>
        /// Renders a visual which can follow the mouse cursor, 
        /// such as during a drag-and-drop operation.
        /// </summary>
        // Copyright (C) Josh Smith - January 2007
        private class DragDropAdorner : Adorner
        {
            #region Data

            private Rectangle child = null;
            private double offsetLeft = 0;
            private double offsetTop = 0;

            #endregion // Data

            #region Constructor

            /// <summary>
            /// Initializes a new instance of DragVisualAdorner.
            /// </summary>
            /// <param name="adornedElement">The element being adorned.</param>
            /// <param name="size">The size of the adorner.</param>
            /// <param name="brush">A brush to with which to paint the adorner.</param>
            public DragDropAdorner(UIElement adornedElement, Size size, Brush brush)
                : base(adornedElement)
            {
                Rectangle rect = new Rectangle();
                rect.Fill = brush;
                rect.Width = size.Width;
                rect.Height = size.Height;
                rect.IsHitTestVisible = false;
                this.child = rect;
            }

            #endregion // Constructor

            #region Public Interface

            #region GetDesiredTransform

            /// <summary>
            /// Override.
            /// </summary>
            /// <param name="transform"></param>
            /// <returns></returns>
            public override GeneralTransform GetDesiredTransform(GeneralTransform transform)
            {
                GeneralTransformGroup result = new GeneralTransformGroup();
                result.Children.Add(base.GetDesiredTransform(transform));
                result.Children.Add(new TranslateTransform(this.offsetLeft, this.offsetTop));
                return result;
            }

            #endregion // GetDesiredTransform

            #region OffsetLeft

            /// <summary>
            /// Gets/sets the horizontal offset of the adorner.
            /// </summary>
            public double OffsetLeft
            {
                get { return this.offsetLeft; }
                set
                {
                    this.offsetLeft = value;
                    UpdateLocation();
                }
            }

            #endregion // OffsetLeft

            #region SetOffsets

            /// <summary>
            /// Updates the location of the adorner in one atomic operation.
            /// </summary>
            /// <param name="left"></param>
            /// <param name="top"></param>
            public void SetOffsets(double left, double top)
            {
                this.offsetLeft = left;
                this.offsetTop = top;
                this.UpdateLocation();
            }

            #endregion // SetOffsets

            #region OffsetTop

            /// <summary>
            /// Gets/sets the vertical offset of the adorner.
            /// </summary>
            public double OffsetTop
            {
                get { return this.offsetTop; }
                set
                {
                    this.offsetTop = value;
                    UpdateLocation();
                }
            }

            #endregion // OffsetTop

            #endregion // Public Interface

            #region Protected Overrides

            /// <summary>
            /// Override.
            /// </summary>
            /// <param name="constraint"></param>
            /// <returns></returns>
            protected override Size MeasureOverride(Size constraint)
            {
                this.child.Measure(constraint);
                return this.child.DesiredSize;
            }

            /// <summary>
            /// Override.
            /// </summary>
            /// <param name="finalSize"></param>
            /// <returns></returns>
            protected override Size ArrangeOverride(Size finalSize)
            {
                this.child.Arrange(new Rect(finalSize));
                return finalSize;
            }

            /// <summary>
            /// Override.
            /// </summary>
            /// <param name="index"></param>
            /// <returns></returns>
            protected override Visual GetVisualChild(int index)
            {
                return this.child;
            }

            /// <summary>
            /// Override.  Always returns 1.
            /// </summary>
            protected override int VisualChildrenCount
            {
                get { return 1; }
            }

            #endregion // Protected Overrides

            #region Private Helpers

            private void UpdateLocation()
            {
                AdornerLayer adornerLayer = this.Parent as AdornerLayer;
                if (adornerLayer != null)
                    adornerLayer.Update(this.AdornedElement);
            }

            #endregion // Private Helpers
        }

        #endregion

        private Point? _mouseDown;
        private Point _offset;
        private ItemsControl _source;
        private UIElement _dragScope;
        private DragDropAdorner _adorner;
        private DragEventHandler _dragOver, _dragEnter, _dragLeave;

        public ItemsControlDragHelper(ItemsControl source, UIElement dragScope)
        {
            _dragEnter = new DragEventHandler(DragScope_DragEnter);
            _dragOver = new DragEventHandler(DragScope_DragOver);
            _dragLeave = new DragEventHandler(DragScope_DragLeave);
            _source = source ?? throw new ArgumentNullException(nameof(source));
            _dragScope = dragScope;
            _source.PreviewMouseLeftButtonDown += SourceMouseLeftButtonDown;
            _source.PreviewMouseMove += SourceMouseMove;
        }

        private void SourceMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            var point = e.GetPosition(_source);
            if (!IsMouseOverScrollbar(point))
            {
                _mouseDown = point;
            }
        }

        private void SourceMouseMove(object sender, MouseEventArgs e)
        {
            if (e.LeftButton == MouseButtonState.Pressed)
            {
                if (_mouseDown.HasValue && HasMoved(e.GetPosition(_source)))
                {
                    var adornerSource = e.OriginalSource as UIElement;
                    adornerSource = _source.ContainerFromElement(adornerSource) as UIElement;
                    _offset = adornerSource is IInputElement input ? e.GetPosition(input) : new Point(0, 0);
                    object subj = e.OriginalSource;
                    if (adornerSource is FrameworkElement fe && fe.Tag != null)
                        subj = fe.Tag;
                    DoDragDrop(subj, adornerSource);
                    e.Handled = true;
                }
            }
            else
            {
                _mouseDown = null;
            }
        }

        private bool HasMoved(Point point)
        {
            return Math.Abs(point.X - _mouseDown.Value.X) > SystemParameters.MinimumHorizontalDragDistance / 2
                || Math.Abs(point.Y - _mouseDown.Value.Y) > SystemParameters.MinimumVerticalDragDistance / 2;
        }

        private bool IsMouseOverScrollbar(Point ptMouse)
        {
            HitTestResult res = VisualTreeHelper.HitTest(_source, ptMouse);
            if (res == null) return false;
            DependencyObject depObj = res.VisualHit;
            while (depObj != null)
            {
                if (depObj is System.Windows.Controls.Primitives.ScrollBar)
                    return true;

                // VisualTreeHelper works with objects of type Visual or Visual3D.
                // If the current object is not derived from Visual or Visual3D,
                // then use the LogicalTreeHelper to find the parent element.
                depObj = depObj is Visual or System.Windows.Media.Media3D.Visual3D
                    ? VisualTreeHelper.GetParent(depObj)
                    : LogicalTreeHelper.GetParent(depObj);
            }

            return false;
        }

        private void DoDragDrop(object dragItem, UIElement adornerSource)
        {
            if (adornerSource != null)
            {
                var rect = VisualTreeHelper.GetDescendantBounds(adornerSource);
                var size = new Size((double)Math.Ceiling(rect.Width), (double)Math.Ceiling(rect.Height));
                var brush = new VisualBrush(adornerSource);
                _adorner = new DragDropAdorner(_dragScope, size, brush)
                {
                    Opacity = 0.7,
                    Visibility = Visibility.Hidden
                };
            }

            DragDrop.AddPreviewDragEnterHandler(_dragScope, _dragEnter);
            DragDrop.AddPreviewDragOverHandler(_dragScope, _dragOver);
            DragDrop.AddPreviewDragLeaveHandler(_dragScope, _dragLeave);

            var resultEffects = DragDrop.DoDragDrop(_source, dragItem, DragDropEffects.All);
            DragFinished(resultEffects);

            DragDrop.RemovePreviewDragEnterHandler(_dragScope, _dragEnter);
            DragDrop.RemovePreviewDragOverHandler(_dragScope, _dragOver);
            DragDrop.RemovePreviewDragLeaveHandler(_dragScope, _dragLeave);
        }

        private void DragScope_DragEnter(object sender, DragEventArgs args)
        {
            if (_adorner != null)
            {
                AdornerLayer.GetAdornerLayer(_source).Add(_adorner);
            }
        }

        private void DragScope_DragOver(object sender, DragEventArgs args)
        {
            if (_adorner != null)
            {
                var pos = args.GetPosition(_dragScope);
                _adorner.SetOffsets(pos.X - _offset.X, pos.Y - _offset.Y);
                _adorner.Visibility = Visibility.Visible;
            }
        }

        private void DragScope_DragLeave(object sender, DragEventArgs args)
        {
            if (_adorner != null)
            {
                AdornerLayer.GetAdornerLayer(_source).Remove(_adorner);
            }
        }

        protected void DragFinished(DragDropEffects ret)
        {
            if (_adorner != null)
            {
                AdornerLayer.GetAdornerLayer(_source).Remove(_adorner);
            }
            _adorner = null;
        }

        #region IDisposable Members

        public void Dispose()
        {
            _source.MouseLeftButtonDown -= SourceMouseLeftButtonDown;
            _source.MouseMove -= SourceMouseMove;
        }

        #endregion
    }
}