replace v6 with experimental v7 code

src/MpvNet.Windows/WPF/HandyControl/Controls/Attach/BorderElement.cs

@@ -0,0 +1,52 @@
+
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+
+using HandyControl.Data;
+using HandyControl.Tools.Converter;
+
+namespace HandyControl.Controls
+{
+    public class BorderElement
+    {
+        public static readonly DependencyProperty CornerRadiusProperty = DependencyProperty.RegisterAttached(
+            "CornerRadius", typeof(CornerRadius), typeof(BorderElement), new FrameworkPropertyMetadata(default(CornerRadius), FrameworkPropertyMetadataOptions.Inherits));
+
+        public static void SetCornerRadius(DependencyObject element, CornerRadius value) => element.SetValue(CornerRadiusProperty, value);
+
+        public static CornerRadius GetCornerRadius(DependencyObject element) => (CornerRadius) element.GetValue(CornerRadiusProperty);
+
+        public static readonly DependencyProperty CircularProperty = DependencyProperty.RegisterAttached(
+            "Circular", typeof(bool), typeof(BorderElement), new PropertyMetadata(ValueBoxes.FalseBox, OnCircularChanged));
+
+        private static void OnCircularChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            if (d is Border border)
+            {
+                if ((bool) e.NewValue)
+                {
+                    var binding = new MultiBinding
+                    {
+                        Converter = new BorderCircularConverter()
+                    };
+                    binding.Bindings.Add(new Binding(FrameworkElement.ActualWidthProperty.Name) { Source = border });
+                    binding.Bindings.Add(new Binding(FrameworkElement.ActualHeightProperty.Name) { Source = border });
+                    border.SetBinding(Border.CornerRadiusProperty, binding);
+                }
+                else
+                {
+                    BindingOperations.ClearBinding(border, FrameworkElement.ActualWidthProperty);
+                    BindingOperations.ClearBinding(border, FrameworkElement.ActualHeightProperty);
+                    BindingOperations.ClearBinding(border, Border.CornerRadiusProperty);
+                }
+            }
+        }
+
+        public static void SetCircular(DependencyObject element, bool value)
+            => element.SetValue(CircularProperty, ValueBoxes.BooleanBox(value));
+
+        public static bool GetCircular(DependencyObject element)
+            => (bool) element.GetValue(CircularProperty);
+    }
+}

src/MpvNet.Windows/WPF/HandyControl/Controls/Attach/IconElement.cs

@@ -0,0 +1,36 @@
+
+using System.Windows;
+using System.Windows.Media;
+
+namespace HandyControl.Controls
+{
+    public class IconElement
+    {
+        public static readonly DependencyProperty GeometryProperty = DependencyProperty.RegisterAttached(
+            "Geometry", typeof(Geometry), typeof(IconElement), new PropertyMetadata(default(Geometry)));
+
+        public static void SetGeometry(DependencyObject element, Geometry value)
+            => element.SetValue(GeometryProperty, value);
+
+        public static Geometry GetGeometry(DependencyObject element)
+            => (Geometry) element.GetValue(GeometryProperty);
+
+        public static readonly DependencyProperty WidthProperty = DependencyProperty.RegisterAttached(
+            "Width", typeof(double), typeof(IconElement), new PropertyMetadata(double.NaN));
+
+        public static void SetWidth(DependencyObject element, double value)
+            => element.SetValue(WidthProperty, value);
+
+        public static double GetWidth(DependencyObject element)
+            => (double) element.GetValue(WidthProperty);
+
+        public static readonly DependencyProperty HeightProperty = DependencyProperty.RegisterAttached(
+            "Height", typeof(double), typeof(IconElement), new PropertyMetadata(double.NaN));
+
+        public static void SetHeight(DependencyObject element, double value)
+            => element.SetValue(HeightProperty, value);
+
+        public static double GetHeight(DependencyObject element)
+            => (double) element.GetValue(HeightProperty);
+    }
+}

src/MpvNet.Windows/WPF/HandyControl/Controls/Attach/MenuTopLineAttach.cs

@@ -0,0 +1,110 @@
+
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+
+using HandyControl.Tools;
+using HandyControl.Tools.Interop;
+
+namespace HandyControl.Controls
+{
+    public class MenuTopLineAttach
+    {
+        public static readonly DependencyProperty PopupProperty = DependencyProperty.RegisterAttached(
+            "Popup", typeof(Popup), typeof(MenuTopLineAttach), new PropertyMetadata(default(Popup), OnPopupChanged));
+
+        private static void OnPopupChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            var topLine = (FrameworkElement)d;
+
+            if (e.NewValue is Popup)
+            {
+                Popup popup = e.NewValue as Popup;
+                MenuItem menuItem = popup.TemplatedParent as MenuItem;
+                SetTopLine(menuItem, topLine);
+                menuItem.Loaded += MenuItem_Loaded;
+            }
+        }
+
+        private static void MenuItem_Loaded(object sender, RoutedEventArgs e)
+        {
+            var menuItem = (FrameworkElement)sender;
+            menuItem.Unloaded += MenuItem_Unloaded;
+            var topLine = GetTopLine(menuItem);
+            var popup = GetPopup(topLine);
+            if (popup != null)
+            {
+                popup.Opened += Popup_Opened;
+            }
+        }
+
+        private static void MenuItem_Unloaded(object sender, RoutedEventArgs e)
+        {
+            var menuItem = (FrameworkElement)sender;
+            menuItem.Unloaded -= MenuItem_Unloaded;
+            var topLine = GetTopLine(menuItem);
+            var popup = GetPopup(topLine);
+            if (popup != null)
+            {
+                popup.Opened -= Popup_Opened;
+            }
+        }
+
+        private static void Popup_Opened(object sender, EventArgs e)
+        {
+            var popup = (Popup)sender;
+            if (popup.TemplatedParent is MenuItem menuItem)
+            {
+                var topLine = GetTopLine(menuItem);
+                if (topLine == null) return;
+
+                topLine.HorizontalAlignment = HorizontalAlignment.Left;
+                topLine.Width = menuItem.ActualWidth;
+                topLine.Margin = new Thickness();
+
+                var positionLeftTop = menuItem.PointToScreen(new Point());
+                var positionRightBottom = menuItem.PointToScreen(new Point(menuItem.ActualWidth, menuItem.ActualHeight));
+                ScreenHelper.FindMonitorRectsFromPoint(InteropMethods.GetCursorPos(), out Rect monitorRect, out var workAreaRect);
+                var panel = VisualHelper.GetParent<Panel>(topLine);
+
+                if (positionLeftTop.X < 0)
+                {
+
+                    topLine.Margin = new Thickness(positionLeftTop.X - panel.Margin.Left, 0, 0, 0);
+                }
+                else if (positionLeftTop.X + panel.ActualWidth > workAreaRect.Right)
+                {
+                    var overflowWidth = positionRightBottom.X - workAreaRect.Right;
+                    if (overflowWidth > 0)
+                    {
+                        topLine.Width -= overflowWidth + panel.Margin.Right;
+                    }
+                    topLine.HorizontalAlignment = HorizontalAlignment.Left;
+                    topLine.Margin = new Thickness(positionLeftTop.X + panel.ActualWidth - workAreaRect.Right + panel.Margin.Right, 0, 0, 0);
+                }
+
+                if (positionRightBottom.Y > workAreaRect.Bottom)
+                {
+                    topLine.Width = 0;
+                    topLine.HorizontalAlignment = HorizontalAlignment.Stretch;
+                    topLine.Margin = new Thickness();
+                }
+            }
+        }
+
+        public static void SetPopup(DependencyObject element, Popup value)
+            => element.SetValue(PopupProperty, value);
+
+        public static Popup GetPopup(DependencyObject element)
+            => (Popup)element.GetValue(PopupProperty);
+
+        internal static readonly DependencyProperty TopLineProperty = DependencyProperty.RegisterAttached(
+            "TopLine", typeof(FrameworkElement), typeof(MenuTopLineAttach), new PropertyMetadata(default(FrameworkElement)));
+
+        internal static void SetTopLine(DependencyObject element, FrameworkElement value)
+            => element.SetValue(TopLineProperty, value);
+
+        internal static FrameworkElement GetTopLine(DependencyObject element)
+            => (FrameworkElement)element.GetValue(TopLineProperty);
+    }
+}

src/MpvNet.Windows/WPF/HandyControl/Controls/Attach/ScrollViewerAttach.cs

@@ -0,0 +1,19 @@
+
+using System.Windows;
+
+using HandyControl.Data;
+
+namespace HandyControl.Controls
+{
+    public class ScrollViewerAttach
+    {
+        public static readonly DependencyProperty AutoHideProperty = DependencyProperty.RegisterAttached(
+            "AutoHide", typeof(bool), typeof(ScrollViewerAttach), new FrameworkPropertyMetadata(ValueBoxes.TrueBox, FrameworkPropertyMetadataOptions.Inherits));
+
+        public static void SetAutoHide(DependencyObject element, bool value)
+            => element.SetValue(AutoHideProperty, value);
+
+        public static bool GetAutoHide(DependencyObject element)
+            => (bool) element.GetValue(AutoHideProperty);
+    }
+}

src/MpvNet.Windows/WPF/HandyControl/Controls/ScrollViewer.cs

@@ -0,0 +1,192 @@
+
+
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Animation;
+
+using HandyControl.Data;
+using HandyControl.Tools;
+
+namespace HandyControl.Controls
+{
+    public class ScrollViewer : System.Windows.Controls.ScrollViewer
+    {
+        private double _totalVerticalOffset;
+
+        private double _totalHorizontalOffset;
+
+        private bool _isRunning;
+
+        public static readonly DependencyProperty OrientationProperty = DependencyProperty.Register(
+            "Orientation", typeof(Orientation), typeof(ScrollViewer), new PropertyMetadata(Orientation.Vertical));
+
+        public Orientation Orientation
+        {
+            get => (Orientation) GetValue(OrientationProperty);
+            set => SetValue(OrientationProperty, value);
+        }
+
+        public static readonly DependencyProperty CanMouseWheelProperty = DependencyProperty.Register(
+            "CanMouseWheel", typeof(bool), typeof(ScrollViewer), new PropertyMetadata(ValueBoxes.TrueBox));
+
+        public bool CanMouseWheel
+        {
+            get => (bool) GetValue(CanMouseWheelProperty);
+            set => SetValue(CanMouseWheelProperty, ValueBoxes.BooleanBox(value));
+        }
+
+        protected override void OnMouseWheel(MouseWheelEventArgs e)
+        {
+            if (!CanMouseWheel) return;
+
+            if (!IsInertiaEnabled)
+            {
+                if (Orientation == Orientation.Vertical)
+                {
+                    base.OnMouseWheel(e);
+                }
+                else
+                {
+                    _totalHorizontalOffset = HorizontalOffset;
+                    CurrentHorizontalOffset = HorizontalOffset;
+                    _totalHorizontalOffset = Math.Min(Math.Max(0, _totalHorizontalOffset - e.Delta), ScrollableWidth);
+                    CurrentHorizontalOffset = _totalHorizontalOffset;
+                }
+                return;
+            }
+            e.Handled = true;
+
+            if (Orientation == Orientation.Vertical)
+            {
+                if (!_isRunning)
+                {
+                    _totalVerticalOffset = VerticalOffset;
+                    CurrentVerticalOffset = VerticalOffset;
+                }
+                _totalVerticalOffset = Math.Min(Math.Max(0, _totalVerticalOffset - e.Delta), ScrollableHeight);
+                ScrollToVerticalOffsetWithAnimation(_totalVerticalOffset);
+            }
+            else
+            {
+                if (!_isRunning)
+                {
+                    _totalHorizontalOffset = HorizontalOffset;
+                    CurrentHorizontalOffset = HorizontalOffset;
+                }
+                _totalHorizontalOffset = Math.Min(Math.Max(0, _totalHorizontalOffset - e.Delta), ScrollableWidth);
+                ScrollToHorizontalOffsetWithAnimation(_totalHorizontalOffset);
+            }
+        }
+
+        internal void ScrollToTopInternal(double milliseconds = 500)
+        {
+            if (!_isRunning)
+            {
+                _totalVerticalOffset = VerticalOffset;
+                CurrentVerticalOffset = VerticalOffset;
+            }
+            ScrollToVerticalOffsetWithAnimation(0, milliseconds);
+        }
+
+        public void ScrollToVerticalOffsetWithAnimation(double offset, double milliseconds = 500)
+        {
+            var animation = AnimationHelper.CreateAnimation(offset, milliseconds);
+            animation.EasingFunction = new CubicEase
+            {
+                EasingMode = EasingMode.EaseOut
+            };
+            animation.FillBehavior = FillBehavior.Stop;
+            animation.Completed += (s, e1) =>
+            {
+                CurrentVerticalOffset = offset;
+                _isRunning = false;
+            };
+            _isRunning = true;
+
+            BeginAnimation(CurrentVerticalOffsetProperty, animation, HandoffBehavior.Compose);
+        }
+
+        public void ScrollToHorizontalOffsetWithAnimation(double offset, double milliseconds = 500)
+        {
+            var animation = AnimationHelper.CreateAnimation(offset, milliseconds);
+            animation.EasingFunction = new CubicEase
+            {
+                EasingMode = EasingMode.EaseOut
+            };
+            animation.FillBehavior = FillBehavior.Stop;
+            animation.Completed += (s, e1) =>
+            {
+                CurrentHorizontalOffset = offset;
+                _isRunning = false;
+            };
+            _isRunning = true;
+
+            BeginAnimation(CurrentHorizontalOffsetProperty, animation, HandoffBehavior.Compose);
+        }
+
+        protected override HitTestResult HitTestCore(PointHitTestParameters hitTestParameters) =>
+            IsPenetrating ? null : base.HitTestCore(hitTestParameters);
+
+        public static readonly DependencyProperty IsInertiaEnabledProperty = DependencyProperty.RegisterAttached(
+            "IsInertiaEnabled", typeof(bool), typeof(ScrollViewer), new PropertyMetadata(ValueBoxes.FalseBox));
+
+        public static void SetIsInertiaEnabled(DependencyObject element, bool value) => element.SetValue(IsInertiaEnabledProperty, ValueBoxes.BooleanBox(value));
+
+        public static bool GetIsInertiaEnabled(DependencyObject element) => (bool) element.GetValue(IsInertiaEnabledProperty);
+
+        public bool IsInertiaEnabled
+        {
+            get => (bool) GetValue(IsInertiaEnabledProperty);
+            set => SetValue(IsInertiaEnabledProperty, ValueBoxes.BooleanBox(value));
+        }
+
+        public static readonly DependencyProperty IsPenetratingProperty = DependencyProperty.RegisterAttached(
+            "IsPenetrating", typeof(bool), typeof(ScrollViewer), new PropertyMetadata(ValueBoxes.FalseBox));
+
+        public bool IsPenetrating
+        {
+            get => (bool) GetValue(IsPenetratingProperty);
+            set => SetValue(IsPenetratingProperty, ValueBoxes.BooleanBox(value));
+        }
+
+        public static void SetIsPenetrating(DependencyObject element, bool value) => element.SetValue(IsPenetratingProperty, ValueBoxes.BooleanBox(value));
+
+        public static bool GetIsPenetrating(DependencyObject element) => (bool) element.GetValue(IsPenetratingProperty);
+
+        internal static readonly DependencyProperty CurrentVerticalOffsetProperty = DependencyProperty.Register(
+            "CurrentVerticalOffset", typeof(double), typeof(ScrollViewer), new PropertyMetadata(ValueBoxes.Double0Box, OnCurrentVerticalOffsetChanged));
+
+        private static void OnCurrentVerticalOffsetChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            if (d is ScrollViewer ctl && e.NewValue is double v)
+            {
+                ctl.ScrollToVerticalOffset(v);
+            }
+        }
+
+        internal double CurrentVerticalOffset
+        {
+            get => (double) GetValue(CurrentVerticalOffsetProperty);
+            set => SetValue(CurrentVerticalOffsetProperty, value);
+        }
+
+        internal static readonly DependencyProperty CurrentHorizontalOffsetProperty = DependencyProperty.Register(
+            "CurrentHorizontalOffset", typeof(double), typeof(ScrollViewer), new PropertyMetadata(ValueBoxes.Double0Box, OnCurrentHorizontalOffsetChanged));
+
+        private static void OnCurrentHorizontalOffsetChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            if (d is ScrollViewer ctl && e.NewValue is double v)
+            {
+                ctl.ScrollToHorizontalOffset(v);
+            }
+        }
+
+        internal double CurrentHorizontalOffset
+        {
+            get => (double) GetValue(CurrentHorizontalOffsetProperty);
+            set => SetValue(CurrentHorizontalOffsetProperty, value);
+        }
+    }
+}

src/MpvNet.Windows/WPF/HandyControl/Controls/SimplePanel.cs

@@ -0,0 +1,37 @@
+
+
+using System.Windows;
+using System.Windows.Controls;
+
+namespace HandyControl.Controls
+{
+    public class SimplePanel : Panel
+    {
+        protected override Size MeasureOverride(Size constraint)
+        {
+            var maxSize = new Size();
+
+            foreach (UIElement child in InternalChildren)
+            {
+                if (child != null)
+                {
+                    child.Measure(constraint);
+                    maxSize.Width = Math.Max(maxSize.Width, child.DesiredSize.Width);
+                    maxSize.Height = Math.Max(maxSize.Height, child.DesiredSize.Height);
+                }
+            }
+
+            return maxSize;
+        }
+
+        protected override Size ArrangeOverride(Size arrangeSize)
+        {
+            foreach (UIElement child in InternalChildren)
+            {
+                child?.Arrange(new Rect(arrangeSize));
+            }
+
+            return arrangeSize;
+        }
+    }
+}