improve the CoverView

add ItemContentHeightFixedProperty for CoverView

HandyControl/Controls/Cover/CoverView/CoverView.cs

@@ -1,6 +1,7 @@
 using System.Windows;
 using System.Windows.Data;
 using HandyControl.Data;
+using HandyControl.Tools;
 
 namespace HandyControl.Controls
 {
@@ -12,9 +13,10 @@ namespace HandyControl.Controls
 
         public CoverView()
         {
-            _viewContent = new CoverViewContent {ContentHeight = ItemContentHeight};
+            _viewContent = new CoverViewContent();
 
             AddHandler(SelectableItem.SelectedEvent, new RoutedEventHandler(CoverViewItem_OnSelected));
+            _viewContent.SetBinding(CoverViewContent.ContentHeightProperty, new Binding(ItemContentHeightProperty.Name) { Source = this });
             _viewContent.SetBinding(WidthProperty, new Binding(ActualWidthProperty.Name) { Source = this });
         }
 
@@ -35,7 +37,7 @@ namespace HandyControl.Controls
                     return;
                 }
 
-                if(!Equals(_selectedItem, item))
+                if (!Equals(_selectedItem, item))
                 {
                     _selectedItem.IsSelected = false;
                     item.IsSelected = true;
@@ -83,12 +85,14 @@ namespace HandyControl.Controls
 
         public Style CoverViewContentStyle
         {
-            get => (Style) GetValue(CoverViewContentStyleProperty);
+            get => (Style)GetValue(CoverViewContentStyleProperty);
             set => SetValue(CoverViewContentStyleProperty, value);
         }
 
         internal static readonly DependencyProperty GroupsProperty = DependencyProperty.Register(
-            "Groups", typeof(int), typeof(CoverView), new FrameworkPropertyMetadata(ValueBoxes.Int5Box, FrameworkPropertyMetadataOptions.AffectsMeasure, OnGroupsChanged), IsGroupsValid);
+            "Groups", typeof(int), typeof(CoverView),
+            new FrameworkPropertyMetadata(ValueBoxes.Int5Box, FrameworkPropertyMetadataOptions.AffectsMeasure,
+                OnGroupsChanged), IsGroupsValid);
 
         internal static void OnGroupsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
         {
@@ -111,14 +115,24 @@ namespace HandyControl.Controls
         }
 
         public static readonly DependencyProperty ItemContentHeightProperty = DependencyProperty.Register(
-            "ItemContentHeight", typeof(double), typeof(CoverView), new PropertyMetadata(ValueBoxes.Double300Box));
+            "ItemContentHeight", typeof(double), typeof(CoverView), new PropertyMetadata(ValueBoxes.Double300Box),
+            value => ValidateHelper.IsInRangeOfPosDouble(value, true));
 
         public double ItemContentHeight
         {
-            get => (double) GetValue(ItemContentHeightProperty);
+            get => (double)GetValue(ItemContentHeightProperty);
             set => SetValue(ItemContentHeightProperty, value);
         }
 
+        public static readonly DependencyProperty ItemContentHeightFixedProperty = DependencyProperty.Register(
+            "ItemContentHeightFixed", typeof(bool), typeof(CoverView), new PropertyMetadata(ValueBoxes.TrueBox));
+
+        public bool ItemContentHeightFixed
+        {
+            get => (bool)GetValue(ItemContentHeightFixedProperty);
+            set => SetValue(ItemContentHeightFixedProperty, value);
+        }
+
         protected override void OnRenderSizeChanged(SizeChangedInfo sizeInfo)
         {
             base.OnRenderSizeChanged(sizeInfo);
@@ -163,6 +177,16 @@ namespace HandyControl.Controls
 
             ItemsHost.Children.Remove(_viewContent);
 
+            if (!ItemContentHeightFixed)
+            {
+                _viewContent.ManualHeight = 0;
+                if (_viewContent.Content is FrameworkElement element)
+                {
+                    element.Arrange(new Rect(new Size(double.MaxValue, double.MaxValue)));
+                    _viewContent.ManualHeight = element.ActualHeight;
+                }
+            }
+
             var total = Items.Count + 1;
             var totalRow = total / Groups + (total % Groups > 0 ? 1 : 0);
             if (total <= Groups)

HandyControl/Controls/Cover/CoverView/CoverViewContent.cs

@@ -1,6 +1,7 @@
 using System.Windows;
 using System.Windows.Controls;
 using HandyControl.Data;
+using HandyControl.Expression.Drawing;
 using HandyControl.Tools;
 using HandyControl.Tools.Extension;
 
@@ -26,10 +27,10 @@ namespace HandyControl.Controls
 
         private double _itemWidth;
 
-        private bool _isOpen;
-
         internal bool CanSwitch { get; set; } = true;
 
+        private bool _isOpen;
+
         internal bool IsOpen
         {
             get => _isOpen;
@@ -41,12 +42,22 @@ namespace HandyControl.Controls
             }
         }
 
+        internal static readonly DependencyProperty ManualHeightProperty = DependencyProperty.Register(
+            "ManualHeight", typeof(double), typeof(CoverViewContent), new PropertyMetadata(default(double)), value => ValidateHelper.IsInRangeOfPosDouble(value, true));
+
+        internal double ManualHeight
+        {
+            get => (double)GetValue(ManualHeightProperty);
+            set => SetValue(ManualHeightProperty, value);
+        }
+
         public static readonly DependencyProperty ContentHeightProperty = DependencyProperty.Register(
-            "ContentHeight", typeof(double), typeof(CoverViewContent), new PropertyMetadata(ValueBoxes.Double300Box));
+            "ContentHeight", typeof(double), typeof(CoverViewContent), new PropertyMetadata(ValueBoxes.Double300Box),
+            value => ValidateHelper.IsInRangeOfPosDouble(value, true));
 
         public double ContentHeight
         {
-            get => (double) GetValue(ContentHeightProperty);
+            get => (double)GetValue(ContentHeightProperty);
             set => SetValue(ContentHeightProperty, value);
         }
 
@@ -76,12 +87,23 @@ namespace HandyControl.Controls
                 return;
             }
             _triangle.BeginAnimation(MarginProperty, AnimationHelper.CreateAnimation(new Thickness((index % groups + .5) * itemWidth - _triangle.Width / 2, 0, 0, 0)));
+            if (IsOpen)
+            {
+                if (ManualHeight > 0 && !MathHelper.AreClose(ManualHeight, ContentHeight))
+                {
+                    _content.BeginAnimation(HeightProperty, AnimationHelper.CreateAnimation(ManualHeight));
+                }
+                else
+                {
+                    _content.BeginAnimation(HeightProperty, AnimationHelper.CreateAnimation(ContentHeight));
+                }
+            }
         }
 
         private void OpenSwitch(bool isOpen)
         {
             if (_content == null) return;
-            var animation = AnimationHelper.CreateAnimation(isOpen ? ContentHeight : 0);
+            var animation = AnimationHelper.CreateAnimation(isOpen ? ManualHeight > 0 ? ManualHeight : ContentHeight : 0);
             _triangle.Show(false);
             this.Show(true);
             animation.Completed += (s, e) =>

HandyControl/Tools/Helper/ValidateHelper.cs

@@ -3,17 +3,41 @@
     /// <summary>
     ///     验证帮助类
     /// </summary>
-    internal class ValidateHelper
+    public class ValidateHelper
     {
         /// <summary>
         ///     是否在浮点数范围内
         /// </summary>
         /// <param name="value"></param>
         /// <returns></returns>
-        internal static bool IsInRangeOfDouble(object value)
+        public static bool IsInRangeOfDouble(object value)
         {
             var v = (double)value;
             return !(double.IsNaN(v) || double.IsInfinity(v));
         }
+
+        /// <summary>
+        ///     是否在正浮点数范围内
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="includeZero"></param>
+        /// <returns></returns>
+        public static bool IsInRangeOfPosDouble(object value, bool includeZero = false)
+        {
+            var v = (double)value;
+            return !(double.IsNaN(v) || double.IsInfinity(v)) && (includeZero ? v >= 0 : v > 0);
+        }
+
+        /// <summary>
+        ///     是否在正浮点数范围内
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="includeZero"></param>
+        /// <returns></returns>
+        public static bool IsInRangeOfNegDouble(object value, bool includeZero = false)
+        {
+            var v = (double)value;
+            return !(double.IsNaN(v) || double.IsInfinity(v)) && (includeZero ? v <= 0 : v < 0);
+        }
     }
 }