Adjust project structure

src/Shared/HandyControl_Shared/Controls/Panel/CirclePanel.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using HandyControl.Data;
+
+namespace HandyControl.Controls
+{
+    public class CirclePanel : Panel
+    {
+        public static readonly DependencyProperty DiameterProperty = DependencyProperty.Register(
+            "Diameter", typeof(double), typeof(CirclePanel), new FrameworkPropertyMetadata(170.0, FrameworkPropertyMetadataOptions.AffectsMeasure));
+
+        public double Diameter
+        {
+            get => (double) GetValue(DiameterProperty);
+            set => SetValue(DiameterProperty, value);
+        }
+
+        public static readonly DependencyProperty KeepVerticalProperty = DependencyProperty.Register(
+            "KeepVertical", typeof(bool), typeof(CirclePanel), new FrameworkPropertyMetadata(ValueBoxes.FalseBox, FrameworkPropertyMetadataOptions.AffectsMeasure));
+
+        public bool KeepVertical
+        {
+            get => (bool) GetValue(KeepVerticalProperty);
+            set => SetValue(KeepVerticalProperty, value);
+        }
+
+        public static readonly DependencyProperty OffsetAngleProperty = DependencyProperty.Register(
+            "OffsetAngle", typeof(double), typeof(CirclePanel), new FrameworkPropertyMetadata(ValueBoxes.Double0Box, FrameworkPropertyMetadataOptions.AffectsMeasure));
+
+        public double OffsetAngle
+        {
+            get => (double) GetValue(OffsetAngleProperty);
+            set => SetValue(OffsetAngleProperty, value);
+        }
+
+        // ReSharper disable once RedundantAssignment
+        protected override Size MeasureOverride(Size availableSize)
+        {
+            if (Children.Count == 0) return new Size(Diameter, Diameter);
+
+            availableSize = new Size(Diameter, Diameter);
+            var i = 0;
+            var perDeg = 360.0 / Children.Count;
+            var radius = Diameter / 2;
+            foreach (UIElement element in Children)
+            {
+                element.Measure(availableSize);
+                var centerX = element.DesiredSize.Width / 2.0;
+                var centerY = element.DesiredSize.Height / 2.0;
+                var angle = perDeg * i++ + OffsetAngle;
+                var transform = new RotateTransform
+                {
+                    CenterX = centerX,
+                    CenterY = centerY,
+                    Angle = KeepVertical ? 0 : angle
+                };
+                element.RenderTransform = transform;
+                var r = Math.PI * angle / 180.0;
+                var x = radius * Math.Cos(r);
+                var y = radius * Math.Sin(r);
+                var rectX = x + availableSize.Width / 2 - centerX;
+                var rectY = y + availableSize.Height / 2 - centerY;
+                element.Arrange(new Rect(rectX, rectY, element.DesiredSize.Width, element.DesiredSize.Height));
+            }
+            return availableSize;
+        }
+    }
+}

src/Shared/HandyControl_Shared/Controls/Panel/SimplePanel.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Windows;
+using System.Windows.Controls;
+
+namespace HandyControl.Controls
+{
+    /// <summary>
+    ///     用以代替Grid
+    /// </summary>
+    /// <remarks>
+    ///     当不需要Grid的行、列分隔等功能时建议用此轻量级类代替
+    /// </remarks>
+    public class SimplePanel : Panel
+    {
+        protected override Size MeasureOverride(Size availableSize)
+        {
+            var maxSize = new Size();
+            var children = InternalChildren;
+
+            for (int i = 0, count = children.Count; i < count; ++i)
+            {
+                var child = children[i];
+                if (child != null)
+                {
+                    child.Measure(availableSize);
+                    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;
+        }
+    }
+}

src/Shared/HandyControl_Shared/Controls/Panel/WaterfallPanel.cs

@@ -0,0 +1,85 @@
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using HandyControl.Data;
+
+namespace HandyControl.Controls
+{
+    public class WaterfallPanel : Panel
+    {
+        public static readonly DependencyProperty GroupsProperty = DependencyProperty.Register(
+            "Groups", typeof(int), typeof(WaterfallPanel), new FrameworkPropertyMetadata(ValueBoxes.Int2Box, FrameworkPropertyMetadataOptions.AffectsMeasure), IsGroupsValid);
+
+        public int Groups
+        {
+            get => (int) GetValue(GroupsProperty);
+            set => SetValue(GroupsProperty, value);
+        }
+
+        private static bool IsGroupsValid(object value)
+        {
+            var v = (int)value;
+            return v >= 1;
+        }
+
+        public static readonly DependencyProperty OrientationProperty = DependencyProperty.Register(
+            "Orientation", typeof(Orientation), typeof(WaterfallPanel), new FrameworkPropertyMetadata(
+                Orientation.Horizontal, FrameworkPropertyMetadataOptions.AffectsMeasure));
+
+        public Orientation Orientation
+        {
+            get => (Orientation) GetValue(OrientationProperty);
+            set => SetValue(OrientationProperty, value);
+        }       
+
+        protected override Size MeasureOverride(Size constraint)
+        {
+            if (Groups < 1) return constraint;
+            var children = InternalChildren;
+            Size panelSize;
+
+            if (Orientation == Orientation.Horizontal)
+            {
+                var heightArr = new double[Groups].ToList();
+                var itemWidth = constraint.Width / Groups;
+                if (double.IsNaN(itemWidth) || double.IsInfinity(itemWidth)) return constraint;
+
+                for (int i = 0, count = children.Count; i < count; i++)
+                {
+                    var child = children[i];
+                    if (child == null) continue;
+
+                    child.Measure(constraint);
+                    var minIndex = heightArr.IndexOf(heightArr.Min());
+                    var minY = heightArr[minIndex];
+                    child.Arrange(new Rect(new Point(minIndex * itemWidth, minY), new Size(itemWidth, child.DesiredSize.Height)));
+
+                    heightArr[minIndex] = minY + child.DesiredSize.Height;
+                }
+                panelSize = new Size(constraint.Width, heightArr.Max());
+            }
+            else
+            {
+                var widthArr = new double[Groups].ToList();
+                var itemHeight = constraint.Height / Groups;
+                if (double.IsNaN(itemHeight) || double.IsInfinity(itemHeight)) return constraint;
+
+                for (int i = 0, count = children.Count; i < count; i++)
+                {
+                    var child = children[i];
+                    if (child == null) continue;
+
+                    child.Measure(constraint);
+                    var minIndex = widthArr.IndexOf(widthArr.Min());
+                    var minX = widthArr[minIndex];
+                    child.Arrange(new Rect(new Point(minX, minIndex * itemHeight), new Size(child.DesiredSize.Width, itemHeight)));
+
+                    widthArr[minIndex] = minX + child.DesiredSize.Width;
+                }
+                panelSize = new Size(widthArr.Max(), constraint.Height);
+            }
+
+            return panelSize;
+        }
+    }
+}