Changed ItemsJustification to an enum

Avid29 · Avid29 · commit e512d6caf41b · 2025-12-18T07:39:31.000+02:00
diff --git a/components/WrapPanel2/samples/WrapPanel2BasicSample.xaml b/components/WrapPanel2/samples/WrapPanel2BasicSample.xaml
@@ -42,8 +42,8 @@
                              Grid.Row="1"
                              HorizontalAlignment="{x:Bind LayoutHorizontalAlignment, Mode=OneWay}"
                              VerticalAlignment="{x:Bind LayoutVerticalAlignment, Mode=OneWay}"
-                             ItemJustification="{x:Bind ItemJustification, Mode=OneWay}"
                              ItemSpacing="{x:Bind ItemSpacing, Mode=OneWay}"
+                             ItemsJustification="{x:Bind local:WrapPanel2BasicSample.ConvertStringToItemsJustification(LayoutItemsJustification), Mode=OneWay}"
                              ItemsStretch="{x:Bind local:WrapPanel2BasicSample.ConvertStringToItemsStretch(LayoutItemsStretch), Mode=OneWay}"
                              LineSpacing="{x:Bind LineSpacing, Mode=OneWay}"
                              Orientation="{x:Bind local:WrapPanel2BasicSample.ConvertStringToOrientation(LayoutOrientation), Mode=OneWay}" />
diff --git a/components/WrapPanel2/samples/WrapPanel2BasicSample.xaml.cs b/components/WrapPanel2/samples/WrapPanel2BasicSample.xaml.cs
@@ -14,7 +14,7 @@ namespace WrapPanel2Experiment.Samples;
 [ToolkitSampleMultiChoiceOption("LayoutVerticalAlignment", "Top", "Center", "Bottom", "Stretch", Title = "Vertical Alignment")]
 [ToolkitSampleNumericOption("ItemSpacing", 8, 0, 16, Title = "Item Spacing")]
 [ToolkitSampleNumericOption("LineSpacing", 2, 0, 16, Title = "Line Spacing")]
-[ToolkitSampleBoolOption("ItemJustification", false, Title = "Item Justification")]
+[ToolkitSampleMultiChoiceOption("LayoutItemsJustification", "Automatic", "Start", "Center", "End", "SpaceAround", "SpaceBetween", "SpaceEvenly", Title = "Items Justification")]
 [ToolkitSampleMultiChoiceOption("LayoutItemsStretch", "None", "First", "Last", "Equal", "Proportional", Title = "Items Stretch")]
 
 [ToolkitSample(id: nameof(WrapPanel2BasicSample), $"Basic demo of the {nameof(WrapPanel2)} with auto-sized items.", description: $"A sample showing every property of the {nameof(WrapPanel2)} panel.")]
@@ -53,6 +53,19 @@ public WrapPanel2BasicSample()
         _ => throw new System.NotImplementedException(),
     };
 
+    // TODO: See https://github.com/CommunityToolkit/Labs-Windows/issues/149
+    public static WrapPanelItemsJustification ConvertStringToItemsJustification(string itemsJustification) => itemsJustification switch
+    {
+        "Automatic" => WrapPanelItemsJustification.Automatic,
+        "Start" => WrapPanelItemsJustification.Start,
+        "Center" => WrapPanelItemsJustification.Center,
+        "End" => WrapPanelItemsJustification.End,
+        "SpaceAround" => WrapPanelItemsJustification.SpaceAround,
+        "SpaceBetween" => WrapPanelItemsJustification.SpaceBetween,
+        "SpaceEvenly" => WrapPanelItemsJustification.SpaceEvenly,
+        _ => throw new System.NotImplementedException(),
+    };
+
     // TODO: See https://github.com/CommunityToolkit/Labs-Windows/issues/149
     public static WrapPanelItemsStretch ConvertStringToItemsStretch(string stretchMethod) => stretchMethod switch
     {
diff --git a/components/WrapPanel2/samples/WrapPanel2MegaSample.xaml b/components/WrapPanel2/samples/WrapPanel2MegaSample.xaml
@@ -24,8 +24,8 @@
           Margin="16">
         <controls:WrapPanel2 HorizontalAlignment="{x:Bind LayoutHorizontalAlignment, Mode=OneWay}"
                              VerticalAlignment="{x:Bind LayoutVerticalAlignment, Mode=OneWay}"
-                             ItemJustification="{x:Bind ItemJustification, Mode=OneWay}"
                              ItemSpacing="{x:Bind ItemSpacing, Mode=OneWay}"
+                             ItemsJustification="{x:Bind local:WrapPanel2MegaSample.ConvertStringToItemsJustification(LayoutItemsJustification), Mode=OneWay}"
                              ItemsStretch="{x:Bind local:WrapPanel2MegaSample.ConvertStringToItemsStretch(LayoutItemsStretch), Mode=OneWay}"
                              LineSpacing="{x:Bind LineSpacing, Mode=OneWay}"
                              Orientation="{x:Bind local:WrapPanel2MegaSample.ConvertStringToOrientation(LayoutOrientation), Mode=OneWay}">
diff --git a/components/WrapPanel2/samples/WrapPanel2MegaSample.xaml.cs b/components/WrapPanel2/samples/WrapPanel2MegaSample.xaml.cs
@@ -14,7 +14,7 @@ namespace WrapPanel2Experiment.Samples;
 [ToolkitSampleMultiChoiceOption("LayoutVerticalAlignment", "Top", "Center", "Bottom", "Stretch", Title = "Vertical Alignment")]
 [ToolkitSampleNumericOption("ItemSpacing", 8, 0, 16, Title = "Item Spacing")]
 [ToolkitSampleNumericOption("LineSpacing", 2, 0, 16, Title = "Line Spacing")]
-[ToolkitSampleBoolOption("ItemJustification", false, Title = "Item Justification")]
+[ToolkitSampleMultiChoiceOption("LayoutItemsJustification", "Automatic", "Start", "Center", "End", "SpaceAround", "SpaceBetween", "SpaceEvenly", Title = "Items Justification")]
 [ToolkitSampleMultiChoiceOption("LayoutItemsStretch", "None", "First", "Last", "Equal", "Proportional", Title = "Items Stretch")]
 
 [ToolkitSample(id: nameof(WrapPanel2MegaSample), "Demo of all WrapPanel2 feature", description: $"A sample showing every property of the {nameof(WrapPanel2)} panel.")]
@@ -53,6 +53,19 @@ public WrapPanel2MegaSample()
         _ => throw new System.NotImplementedException(),
     };
 
+    // TODO: See https://github.com/CommunityToolkit/Labs-Windows/issues/149
+    public static WrapPanelItemsJustification ConvertStringToItemsJustification(string itemsJustification) => itemsJustification switch
+    {
+        "Automatic" => WrapPanelItemsJustification.Automatic,
+        "Start" => WrapPanelItemsJustification.Start,
+        "Center" => WrapPanelItemsJustification.Center,
+        "End" => WrapPanelItemsJustification.End,
+        "SpaceAround" => WrapPanelItemsJustification.SpaceAround,
+        "SpaceBetween" => WrapPanelItemsJustification.SpaceBetween,
+        "SpaceEvenly" => WrapPanelItemsJustification.SpaceEvenly,
+        _ => throw new System.NotImplementedException(),
+    };
+
     // TODO: See https://github.com/CommunityToolkit/Labs-Windows/issues/149
     public static WrapPanelItemsStretch ConvertStringToItemsStretch(string stretchMethod) => stretchMethod switch
     {
diff --git a/components/WrapPanel2/src/WrapPanel2.Properties.cs b/components/WrapPanel2/src/WrapPanel2.Properties.cs
@@ -44,11 +44,11 @@ public partial class WrapPanel2
         new PropertyMetadata(default(double), OnPropertyChanged));
 
     /// <summary>
-    /// Backing <see cref="DependencyProperty"/> for the <see cref="ItemJustification"/> property.
+    /// Backing <see cref="DependencyProperty"/> for the <see cref="ItemsJustification"/> property.
     /// </summary>
-    public static readonly DependencyProperty ItemJustificationProperty = DependencyProperty.Register(
-        nameof(ItemJustification),
-        typeof(bool),
+    public static readonly DependencyProperty ItemsJustificationProperty = DependencyProperty.Register(
+        nameof(ItemsJustification),
+        typeof(WrapPanelItemsJustification),
         typeof(WrapPanel2),
         new PropertyMetadata(default(bool), OnPropertyChanged));
 
@@ -74,7 +74,7 @@ public Orientation Orientation
     /// Gets or sets the spacing between items.
     /// </summary>
     /// <remarks>
-    /// When <see cref="ItemJustification"/> is enabled and <see cref="ItemsStretch"/> is <see cref="WrapPanelItemsStretch.None"/>,
+    /// When <see cref="ItemsJustification"/> is in a spacing mode and <see cref="ItemsStretch"/> is <see cref="WrapPanelItemsStretch.None"/>,
     /// this may instead be used as the minimum space between items, while the exact spacing is adjusted to ensure the items span from margin to margin.
     /// </remarks>
     public double ItemSpacing
@@ -98,14 +98,14 @@ public double LineSpacing
     /// <remarks>
     /// This will not apply on lines without star-sized items unless a <see cref="ItemsStretch"/> behavior is selected.
     /// </remarks>
-    public bool ItemJustification
+    public WrapPanelItemsJustification ItemsJustification
     {
-        get => (bool)GetValue(ItemJustificationProperty);
-        set => SetValue(ItemJustificationProperty, value);
+        get => (WrapPanelItemsJustification)GetValue(ItemsJustificationProperty);
+        set => SetValue(ItemsJustificationProperty, value);
     }
 
     /// <summary>
-    /// Gets or sets the method used to fill rows without a star-sized item when <see cref="ItemJustification"/> is enabled.
+    /// Gets or sets the method used to fill rows without a star-sized item when <see cref="ItemsJustification"/> is in a spacing mode.
     /// </summary>
     public WrapPanelItemsStretch ItemsStretch
     {
diff --git a/components/WrapPanel2/src/WrapPanel2.Structs.cs b/components/WrapPanel2/src/WrapPanel2.Structs.cs
@@ -74,21 +74,26 @@ public RowSpec(GridLength layout, UVCoord desiredSize)
         /// </summary>
         public int ItemsCount { get; private set; }
 
-        public bool TryAdd(RowSpec addend, double spacing, double maxSize, bool equalStretching)
+        /// <remarks>
+        /// New size is only set if the size changes.
+        /// Otherwise it will be 0.
+        /// </remarks>
+        public bool TryAdd(RowSpec addend, double spacing, double maxSize, WrapPanelItemsStretch stretching, WrapPanelItemsJustification justification)
         {
             // Check if adding the new spec would exceed the maximum size
             var sum = this + addend;
-            if (sum.Measure(spacing, equalStretching) > maxSize)
+            if (sum.Measure(spacing, stretching, justification) > maxSize)
                 return false;
 
             // Update the current spec to include the new spec
             this = sum;
             return true;
         }
 
-        public readonly double Measure(double spacing, bool equalStretching)
+        public readonly double Measure(double spacing, WrapPanelItemsStretch stretching, WrapPanelItemsJustification justification)
         {
-            var totalSpacing = (ItemsCount - 1) * spacing;
+            var totalSpacing = GetTotalSpacing(ItemsCount, spacing, justification);
+            var equalStretching = stretching is WrapPanelItemsStretch.Equal && IsSpacingJustified(justification);
 
             // Handle equal-sized items child stretching.
             // Without this check, children might become scrunched in the arrange
diff --git a/components/WrapPanel2/src/WrapPanel2.cs b/components/WrapPanel2/src/WrapPanel2.cs
@@ -31,10 +31,6 @@ protected override Size MeasureOverride(Size availableSize)
             return new Size(0, 0);
         }
 
-        // Adjusted measuring will be required if items justification is enabled and
-        // ItemsStreching is set to Equal. Condense this into a bool here.
-        bool equalStretching = ItemJustification && ItemsStretch is WrapPanelItemsStretch.Equal;
-
         foreach (var child in elements)
         {
             // Measure the child's desired size and get layout
@@ -44,19 +40,20 @@ protected override Size MeasureOverride(Size availableSize)
 
             // Attempt to add the child to the current row/column
             var spec = new RowSpec(layoutLength, uvDesiredSize);
-            if (!currentRowSpec.TryAdd(spec, ItemSpacing, uvAvailableSize.U, equalStretching))
+            if (!currentRowSpec.TryAdd(spec, ItemSpacing, uvAvailableSize.U, ItemsStretch, RealJustification))
             {
                 // Could not add to current row/column
                 // Start a new row/column
                 _rowSpecs.Add(currentRowSpec);
-                _longestRowSize = Math.Max(_longestRowSize, currentRowSpec.Measure(ItemSpacing, equalStretching));
+                var newSize = currentRowSpec.Measure(ItemSpacing, ItemsStretch, RealJustification);
+                _longestRowSize = Math.Max(_longestRowSize, newSize);
                 currentRowSpec = spec;
             }
         }
 
         // Add the final row/column
         _rowSpecs.Add(currentRowSpec);
-        _longestRowSize = Math.Max(_longestRowSize, currentRowSpec.Measure(ItemSpacing, equalStretching));
+        _longestRowSize = Math.Max(_longestRowSize, currentRowSpec.Measure(ItemSpacing, ItemsStretch, RealJustification));
 
         // Calculate final desired size
         var uvSize = new UVCoord(0, 0, Orientation)
@@ -106,13 +103,13 @@ protected override Size ArrangeOverride(Size finalSize)
 
     private void ArrangeRow(ref UVCoord pos, RowSpec row, UVCoord uvFinalSize, Queue<UIElement> childQueue)
     {
-        var spacingTotalSize = ItemSpacing * (row.ItemsCount - 1);
+        var spacingTotalSize = GetTotalSpacing(row.ItemsCount, ItemSpacing, RealJustification);
         var remainingSpace = uvFinalSize.U - row.ReservedSpace - spacingTotalSize;
         var portionSize = row.MinPortionSize;
 
         // Determine if the desired alignment is stretched.
         // Or if fixed row lengths are in use.
-        bool stretch = IsMainAxisStretch(uvFinalSize.U) || ItemJustification;
+        bool stretch = IsMainAxisStretch(uvFinalSize.U) || JustifiedSpacing;
 
         // Calculate portion size if stretching
         // Same logic applies for matching row lengths, since the size was determined during measure
@@ -124,17 +121,9 @@ private void ArrangeRow(ref UVCoord pos, RowSpec row, UVCoord uvFinalSize, Queue
         // Reset the starting U position
         pos.U = 0;
 
-        // Adjust the starting position if not stretching
-        // Also do this if there are no star-sized items in the row/column and no forced streching is in use.
-        if (!stretch || (row.PortionsSum is 0 && ItemsStretch is WrapPanelItemsStretch.None))
-        {
-            var rowSize = row.Measure(ItemSpacing, false);
-            pos.U = GetStartByAlignment(GetAlignment(), rowSize, uvFinalSize.U);
-        }
-
         // Set a flag for if the row is being forced to stretch
         // Also declare a variable for the effective items spacing. This will be adjusted if needed for justification.
-        bool forceStretch = ItemJustification && row.PortionsSum is 0 && ItemsStretch is not WrapPanelItemsStretch.None;
+        bool forceStretch = JustifiedSpacing && row.PortionsSum is 0 && ItemsStretch is not WrapPanelItemsStretch.None;
         var itemSpacing = ItemSpacing;
 
         // Setup portionSize for forced stretching
@@ -166,13 +155,33 @@ private void ArrangeRow(ref UVCoord pos, RowSpec row, UVCoord uvFinalSize, Queue
                 _ => row.MinPortionSize,
             };
         }
-        else if (ItemJustification && row.PortionsSum is 0)
+        else if (JustifiedSpacing && row.PortionsSum is 0)
         {
             // If Item Justification is enabled and there's no proportional
-            // Adjust the spacing between items to align items with the margins
-            itemSpacing = (remainingSpace + spacingTotalSize) / (row.ItemsCount - 1);
+            // Adjust the spacing between items according to the justification mode.
+            var divisbleSpace = remainingSpace + spacingTotalSize;
+            itemSpacing = RealJustification switch
+            {
+                WrapPanelItemsJustification.SpaceBetween => divisbleSpace / (row.ItemsCount - 1),
+                WrapPanelItemsJustification.SpaceAround => divisbleSpace / row.ItemsCount,    
+                WrapPanelItemsJustification.SpaceEvenly => divisbleSpace / (row.ItemsCount + 1),
+                _ => divisbleSpace / row.ItemsCount,
+            };
         }
 
+        // Adjust the starting position
+        var rowSize = row.Measure(ItemSpacing, ItemsStretch, RealJustification);
+        pos.U = RealJustification switch
+        {
+            WrapPanelItemsJustification.SpaceAround => itemSpacing / 2,
+            WrapPanelItemsJustification.SpaceBetween => 0,
+            WrapPanelItemsJustification.SpaceEvenly => itemSpacing,
+
+            WrapPanelItemsJustification.Start or
+            WrapPanelItemsJustification.Center or
+            WrapPanelItemsJustification.End or _ => GetStartByAlignment(GetJustificationAlignment(), rowSize, uvFinalSize.U),
+        };
+
         // Arrange each child in the row/column
         for (int i = 0; i < row.ItemsCount; i++)
         {
@@ -312,12 +321,70 @@ private Alignment GetOffAlignment()
         };
     }
 
+    private Alignment GetJustificationAlignment()
+    {
+        return RealJustification switch
+        {
+            WrapPanelItemsJustification.Start => Alignment.Start,
+            WrapPanelItemsJustification.Center => Alignment.Center,
+            WrapPanelItemsJustification.End => Alignment.End,
+            _ => Alignment.Stretch,
+        };
+    }
+
     /// <summary>
     /// Determine if the desired alignment is stretched.
     /// Don't stretch if infinite space is available though. Attempting to divide infinite space will result in a crash.
     /// </summary>
     private bool IsMainAxisStretch(double availableSize) => GetAlignment() is Alignment.Stretch && !double.IsInfinity(availableSize);
 
+    /// <summary>
+    /// Gets whether or not the <see cref="ItemsJustification"/> is adjusting spacing.
+    /// </summary>
+    private bool JustifiedSpacing => IsSpacingJustified(RealJustification);
+
+    /// <summary>
+    /// Gets the <see cref="ItemsJustification"/> with the automatic option converted to the actual behavior.
+    /// </summary>
+    private WrapPanelItemsJustification RealJustification => ItemsJustification switch
+    {
+        WrapPanelItemsJustification.Automatic => GetAlignment() switch
+        {
+            Alignment.Start => WrapPanelItemsJustification.Start,
+            Alignment.Center => WrapPanelItemsJustification.Center,
+            Alignment.End => WrapPanelItemsJustification.End,
+            _ => WrapPanelItemsJustification.SpaceBetween,
+        },
+        _ => ItemsJustification,
+    };
+
+    private static bool IsSpacingJustified(WrapPanelItemsJustification justification) => justification switch
+    {
+        WrapPanelItemsJustification.Start or
+        WrapPanelItemsJustification.Center or
+        WrapPanelItemsJustification.End => false,
+
+        WrapPanelItemsJustification.SpaceAround or
+        WrapPanelItemsJustification.SpaceBetween or
+        WrapPanelItemsJustification.SpaceEvenly => true,
+
+        _ => false,
+    };
+
+    private static double GetTotalSpacing(int itemCount, double itemsSpacing, WrapPanelItemsJustification justification)
+    {
+        return justification switch
+        {
+            WrapPanelItemsJustification.SpaceAround => itemCount * itemsSpacing,
+            WrapPanelItemsJustification.SpaceEvenly => (itemCount + 1) * itemsSpacing,
+
+            WrapPanelItemsJustification.Start or
+            WrapPanelItemsJustification.Center or
+            WrapPanelItemsJustification.End or
+            WrapPanelItemsJustification.SpaceBetween or _ => (itemCount - 1) * itemsSpacing,
+        };
+    }
+
     private double GetChildSize(UIElement child)
     {
         var childLayout = GetLayoutLength(child);
diff --git a/components/WrapPanel2/src/WrapPanelItemsJustification.cs b/components/WrapPanel2/src/WrapPanelItemsJustification.cs
@@ -0,0 +1,46 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace CommunityToolkit.WinUI.Controls;
+
+/// <summary>
+/// Describes how items are arranged between the margins of the main axis in the <see cref="WrapPanel2"/>.
+/// </summary>
+public enum WrapPanelItemsJustification
+{
+    /// <summary>
+    /// Items will be arranged according to the control's alignment over the main axis.
+    /// </summary>
+    Automatic,
+
+    /// <summary>
+    /// Items will be arranged starting aligned with starting margin of the line.
+    /// </summary>
+    Start,
+
+    /// <summary>
+    /// Items will be arranged in the center of the line.
+    /// </summary>
+    Center,
+
+    /// <summary>
+    /// Items will be arranged ending aligned with the ending margin of the line.
+    /// </summary>
+    End,
+
+    /// <summary>
+    /// Items will be arranged with padding on both sides of each item, and half-sized padding against the margin.
+    /// </summary>
+    SpaceAround,
+
+    /// <summary>
+    /// Items will be arranged with equal padding between all items, and no padding against the margins.
+    /// </summary>
+    SpaceBetween,
+
+    /// <summary>
+    /// Items will be arranged with padding on both sides of each item, and full-sized padding against the margin.
+    /// </summary>
+    SpaceEvenly,
+}
diff --git a/components/WrapPanel2/src/WrapPanelItemsStretch.cs b/components/WrapPanel2/src/WrapPanelItemsStretch.cs
@@ -17,7 +17,7 @@ public enum WrapPanelItemsStretch
     /// </summary>
     /// <remarks>
     /// Items with a Star-Sized <see cref="WrapPanel2.LayoutLengthProperty"/> will still stretch if the main-axis alignment
-    /// is set to stretch or if <see cref="WrapPanel2.ItemJustification"/> is enabled.
+    /// is set to stretch or if <see cref="WrapPanel2.ItemsJustification"/> is enabled.
     /// </remarks>
     None,
 
