Merged PR 14420380: Update experimental FlowLayout properties to align to released LinedFlowLayout, see discussion #10858

Syncing content from committish 938d1114eaf090e2abc6e187f789c756957701b0

Author: reunion-maestro-bot

src/controls/dev/AnnotatedScrollBar/TestUI/AnnotatedScrollBarSummaryPage.xaml

@@ -66,7 +66,7 @@
                     HorizontalAlignment="Right">
                     <controls:ItemsRepeater.Layout>
                         <controls:FlowLayout/>
-                        <!--<controls:FlowLayout MinColumnSpacing="10" MinRowSpacing="20"/>-->
+                        <!--<controls:FlowLayout MinItemSpacing="10" LineSpacing="20"/>-->
                     </controls:ItemsRepeater.Layout>
                 </controls:ItemsRepeater>
             </controls:ScrollView>

src/controls/dev/Generated/FlowLayout.properties.cpp

@@ -14,8 +14,8 @@ namespace winrt::Microsoft::UI::Xaml::Controls
 #include "FlowLayout.g.cpp"
 
 GlobalDependencyProperty FlowLayoutProperties::s_LineAlignmentProperty{ nullptr };
-GlobalDependencyProperty FlowLayoutProperties::s_MinColumnSpacingProperty{ nullptr };
-GlobalDependencyProperty FlowLayoutProperties::s_MinRowSpacingProperty{ nullptr };
+GlobalDependencyProperty FlowLayoutProperties::s_LineSpacingProperty{ nullptr };
+GlobalDependencyProperty FlowLayoutProperties::s_MinItemSpacingProperty{ nullptr };
 GlobalDependencyProperty FlowLayoutProperties::s_OrientationProperty{ nullptr };
 
 FlowLayoutProperties::FlowLayoutProperties()
@@ -36,27 +36,27 @@ void FlowLayoutProperties::EnsureProperties()
                 ValueHelper<winrt::FlowLayoutLineAlignment>::BoxValueIfNecessary(winrt::FlowLayoutLineAlignment::Start),
                 winrt::PropertyChangedCallback(&OnLineAlignmentPropertyChanged));
     }
-    if (!s_MinColumnSpacingProperty)
+    if (!s_LineSpacingProperty)
     {
-        s_MinColumnSpacingProperty =
+        s_LineSpacingProperty =
             InitializeDependencyProperty(
-                L"MinColumnSpacing",
+                L"LineSpacing",
                 winrt::name_of<double>(),
                 winrt::name_of<winrt::FlowLayout>(),
                 false /* isAttached */,
                 ValueHelper<double>::BoxValueIfNecessary(0.0),
-                winrt::PropertyChangedCallback(&OnMinColumnSpacingPropertyChanged));
+                winrt::PropertyChangedCallback(&OnLineSpacingPropertyChanged));
     }
-    if (!s_MinRowSpacingProperty)
+    if (!s_MinItemSpacingProperty)
     {
-        s_MinRowSpacingProperty =
+        s_MinItemSpacingProperty =
             InitializeDependencyProperty(
-                L"MinRowSpacing",
+                L"MinItemSpacing",
                 winrt::name_of<double>(),
                 winrt::name_of<winrt::FlowLayout>(),
                 false /* isAttached */,
                 ValueHelper<double>::BoxValueIfNecessary(0.0),
-                winrt::PropertyChangedCallback(&OnMinRowSpacingPropertyChanged));
+                winrt::PropertyChangedCallback(&OnMinItemSpacingPropertyChanged));
     }
     if (!s_OrientationProperty)
     {
@@ -74,8 +74,8 @@ void FlowLayoutProperties::EnsureProperties()
 void FlowLayoutProperties::ClearProperties()
 {
     s_LineAlignmentProperty = nullptr;
-    s_MinColumnSpacingProperty = nullptr;
-    s_MinRowSpacingProperty = nullptr;
+    s_LineSpacingProperty = nullptr;
+    s_MinItemSpacingProperty = nullptr;
     s_OrientationProperty = nullptr;
 }
 
@@ -87,15 +87,15 @@ void FlowLayoutProperties::OnLineAlignmentPropertyChanged(
     winrt::get_self<FlowLayout>(owner)->OnPropertyChanged(args);
 }
 
-void FlowLayoutProperties::OnMinColumnSpacingPropertyChanged(
+void FlowLayoutProperties::OnLineSpacingPropertyChanged(
     winrt::DependencyObject const& sender,
     winrt::DependencyPropertyChangedEventArgs const& args)
 {
     auto owner = sender.as<winrt::FlowLayout>();
     winrt::get_self<FlowLayout>(owner)->OnPropertyChanged(args);
 }
 
-void FlowLayoutProperties::OnMinRowSpacingPropertyChanged(
+void FlowLayoutProperties::OnMinItemSpacingPropertyChanged(
     winrt::DependencyObject const& sender,
     winrt::DependencyPropertyChangedEventArgs const& args)
 {
@@ -124,30 +124,30 @@ winrt::FlowLayoutLineAlignment FlowLayoutProperties::LineAlignment()
     return ValueHelper<winrt::FlowLayoutLineAlignment>::CastOrUnbox(static_cast<FlowLayout*>(this)->GetValue(s_LineAlignmentProperty));
 }
 
-void FlowLayoutProperties::MinColumnSpacing(double value)
+void FlowLayoutProperties::LineSpacing(double value)
 {
     [[gsl::suppress(con)]]
     {
-    static_cast<FlowLayout*>(this)->SetValue(s_MinColumnSpacingProperty, ValueHelper<double>::BoxValueIfNecessary(value));
+    static_cast<FlowLayout*>(this)->SetValue(s_LineSpacingProperty, ValueHelper<double>::BoxValueIfNecessary(value));
     }
 }
 
-double FlowLayoutProperties::MinColumnSpacing()
+double FlowLayoutProperties::LineSpacing()
 {
-    return ValueHelper<double>::CastOrUnbox(static_cast<FlowLayout*>(this)->GetValue(s_MinColumnSpacingProperty));
+    return ValueHelper<double>::CastOrUnbox(static_cast<FlowLayout*>(this)->GetValue(s_LineSpacingProperty));
 }
 
-void FlowLayoutProperties::MinRowSpacing(double value)
+void FlowLayoutProperties::MinItemSpacing(double value)
 {
     [[gsl::suppress(con)]]
     {
-    static_cast<FlowLayout*>(this)->SetValue(s_MinRowSpacingProperty, ValueHelper<double>::BoxValueIfNecessary(value));
+    static_cast<FlowLayout*>(this)->SetValue(s_MinItemSpacingProperty, ValueHelper<double>::BoxValueIfNecessary(value));
     }
 }
 
-double FlowLayoutProperties::MinRowSpacing()
+double FlowLayoutProperties::MinItemSpacing()
 {
-    return ValueHelper<double>::CastOrUnbox(static_cast<FlowLayout*>(this)->GetValue(s_MinRowSpacingProperty));
+    return ValueHelper<double>::CastOrUnbox(static_cast<FlowLayout*>(this)->GetValue(s_MinItemSpacingProperty));
 }
 
 void FlowLayoutProperties::Orientation(winrt::Orientation const& value)

src/controls/dev/Generated/FlowLayout.properties.h

@@ -12,23 +12,23 @@ class FlowLayoutProperties
     void LineAlignment(winrt::FlowLayoutLineAlignment const& value);
     winrt::FlowLayoutLineAlignment LineAlignment();
 
-    void MinColumnSpacing(double value);
-    double MinColumnSpacing();
+    void LineSpacing(double value);
+    double LineSpacing();
 
-    void MinRowSpacing(double value);
-    double MinRowSpacing();
+    void MinItemSpacing(double value);
+    double MinItemSpacing();
 
     void Orientation(winrt::Orientation const& value);
     winrt::Orientation Orientation();
 
     static winrt::DependencyProperty LineAlignmentProperty() { return s_LineAlignmentProperty; }
-    static winrt::DependencyProperty MinColumnSpacingProperty() { return s_MinColumnSpacingProperty; }
-    static winrt::DependencyProperty MinRowSpacingProperty() { return s_MinRowSpacingProperty; }
+    static winrt::DependencyProperty LineSpacingProperty() { return s_LineSpacingProperty; }
+    static winrt::DependencyProperty MinItemSpacingProperty() { return s_MinItemSpacingProperty; }
     static winrt::DependencyProperty OrientationProperty() { return s_OrientationProperty; }
 
     static GlobalDependencyProperty s_LineAlignmentProperty;
-    static GlobalDependencyProperty s_MinColumnSpacingProperty;
-    static GlobalDependencyProperty s_MinRowSpacingProperty;
+    static GlobalDependencyProperty s_LineSpacingProperty;
+    static GlobalDependencyProperty s_MinItemSpacingProperty;
     static GlobalDependencyProperty s_OrientationProperty;
 
     static void EnsureProperties();
@@ -38,11 +38,11 @@ class FlowLayoutProperties
         winrt::DependencyObject const& sender,
         winrt::DependencyPropertyChangedEventArgs const& args);
 
-    static void OnMinColumnSpacingPropertyChanged(
+    static void OnLineSpacingPropertyChanged(
         winrt::DependencyObject const& sender,
         winrt::DependencyPropertyChangedEventArgs const& args);
 
-    static void OnMinRowSpacingPropertyChanged(
+    static void OnMinItemSpacingPropertyChanged(
         winrt::DependencyObject const& sender,
         winrt::DependencyPropertyChangedEventArgs const& args);
 

src/controls/dev/ItemsView/TestUI/ItemsViewSummaryPage.xaml

@@ -185,8 +185,8 @@
 
         <FlowLayout x:Key="flowLayout"
             Orientation="Vertical"
-            MinColumnSpacing="10"
-            MinRowSpacing="10"/>
+            MinItemSpacing="10"
+            LineSpacing="10"/>
 
         <UniformGridLayout x:Key="uniformGridLayout"
             MaximumRowsOrColumns="4"

src/controls/dev/Repeater/APITests/FlowLayoutTests.cs

@@ -665,8 +665,8 @@ public void ValidateFlowLayout()
 
                         minItemSpacing = 10;
                         lineSpacing = 10;
-                        ((FlowLayout)panel.Layout).MinRowSpacing = minItemSpacing;
-                        ((FlowLayout)panel.Layout).MinColumnSpacing = lineSpacing;
+                        ((FlowLayout)panel.Layout).MinItemSpacing = minItemSpacing;
+                        ((FlowLayout)panel.Layout).LineSpacing = lineSpacing;
                         Content.UpdateLayout();
                         ValidateFlowLayoutChildrenLayoutBounds(om, (i) => panel.Children[i], minItemSpacing, lineSpacing, panel.Children.Count, panel.DesiredSize);
                     }
@@ -729,8 +729,8 @@ public void ValidateFlowLayoutVaryingHeights()
 
                     minItemSpacing = 10;
                     lineSpacing = 10;
-                    ((FlowLayout)panel.Layout).MinRowSpacing = minItemSpacing;
-                    ((FlowLayout)panel.Layout).MinColumnSpacing = lineSpacing;
+                    ((FlowLayout)panel.Layout).MinItemSpacing = minItemSpacing;
+                    ((FlowLayout)panel.Layout).LineSpacing = lineSpacing;
                     Content.UpdateLayout();
                     Log.Comment("Validate with spacing");
                     ValidateFlowLayoutChildrenLayoutBounds(
@@ -1123,7 +1123,7 @@ public void ValidateLayoutWithInfiniteMeasureSizeInNonVirtualizingDirection()
                     {
                         new StackLayout { Spacing = 10, Orientation = scrollOrientation.ToLayoutOrientation() },
                         new UniformGridLayout { MinItemHeight = 40, MinItemWidth = 40, MinColumnSpacing = 10, MinRowSpacing = 10, Orientation = scrollOrientation.ToOrthogonalLayoutOrientation() },
-                        new FlowLayout { MinColumnSpacing = 10, MinRowSpacing = 10, Orientation = scrollOrientation.ToOrthogonalLayoutOrientation() }
+                        new FlowLayout { MinItemSpacing = 10, LineSpacing = 10, Orientation = scrollOrientation.ToOrthogonalLayoutOrientation() }
                     };
 
                     var verifyDesiredSize = new Action<Size, Size>((expected, actual) =>
@@ -1166,7 +1166,7 @@ public void ValidateIntersectionWithRealizationWindow()
                     {
                         new StackLayout { Spacing = 10, Orientation = scrollOrientation.ToLayoutOrientation() },
                         new UniformGridLayout { MinItemHeight = 40, MinItemWidth = 40, MinColumnSpacing = 10, MinRowSpacing = 10, Orientation = scrollOrientation.ToOrthogonalLayoutOrientation() },
-                        new FlowLayout { MinColumnSpacing = 10, MinRowSpacing = 10, Orientation = scrollOrientation.ToOrthogonalLayoutOrientation() }
+                        new FlowLayout { MinItemSpacing = 10, LineSpacing = 10, Orientation = scrollOrientation.ToOrthogonalLayoutOrientation() }
                     };
                 });
                 return layouts;
@@ -1719,12 +1719,11 @@ private void ValidateLayoutEstimations(ScrollOrientation scrollOrientation, Layo
 
                     case LayoutChoice.Flow:
                         {
-                            var minRowSpacing = om.ScrollOrientation == ScrollOrientation.Vertical ? lineSpacing : 0;
-                            var minColumnSpacing = om.ScrollOrientation == ScrollOrientation.Horizontal ? lineSpacing : 0;
                             layout = new FlowLayoutDerived()
                             {
-                                MinRowSpacing = minRowSpacing,
-                                MinColumnSpacing = minColumnSpacing,
+                                // Only apply spacing between lines (major direction) for this test.
+                                MinItemSpacing = 0,
+                                LineSpacing = lineSpacing,
                                 OnLineArrangedFunc = (int startIndex, int countInLine, double lineSize, VirtualizingLayoutContext context) =>
                                 {
                                     Verify.AreEqual(0, startIndex % 4);

src/controls/dev/Repeater/FlowLayout.cpp

@@ -59,8 +59,8 @@ winrt::Size FlowLayout::MeasureOverride(
         availableSize,
         context,
         true, /* isWrapping*/
-        MinItemSpacing(),
-        LineSpacing(),
+        m_minItemSpacing,
+        m_lineSpacing,
         std::numeric_limits<unsigned int>::max() /* maxItemsPerLine */,
         OrientationBasedMeasures::GetScrollOrientation(),
         true /* isVirtualizationEnabled */,
@@ -134,7 +134,7 @@ winrt::FlowLayoutAnchorInfo FlowLayout::GetAnchorForRealizationRect(
         const auto lastExtent = flowState->FlowAlgorithm().LastExtent();
 
         double averageItemsPerLine = 0;
-        const double averageLineSize = GetAverageLineInfo(availableSize, context, flowState, averageItemsPerLine) + LineSpacing();
+        const double averageLineSize = GetAverageLineInfo(availableSize, context, flowState, averageItemsPerLine) + m_lineSpacing;
         MUX_ASSERT(averageItemsPerLine != 0);
 
         const double extentMajorSize = MajorSize(lastExtent) == 0 ? (itemsCount / averageItemsPerLine) * averageLineSize : MajorSize(lastExtent);
@@ -170,7 +170,7 @@ winrt::FlowLayoutAnchorInfo FlowLayout::GetAnchorForTargetElement(
         const auto state = context.LayoutState();
         auto flowState = GetAsFlowState(state);
         double averageItemsPerLine = 0;
-        const double averageLineSize = GetAverageLineInfo(availableSize, context, flowState, averageItemsPerLine) + LineSpacing();
+        const double averageLineSize = GetAverageLineInfo(availableSize, context, flowState, averageItemsPerLine) + m_lineSpacing;
         const int lineIndex = (int)(targetIndex / averageItemsPerLine);
         offset = lineIndex * averageLineSize + MajorStart(flowState->FlowAlgorithm().LastExtent());
     }
@@ -200,7 +200,7 @@ winrt::Rect FlowLayout::GetExtent(
         const auto state = context.LayoutState();
         const auto flowState = GetAsFlowState(state);
         double averageItemsPerLine = 0;
-        const double averageLineSize = GetAverageLineInfo(availableSize, context, flowState, averageItemsPerLine) + LineSpacing();
+        const double averageLineSize = GetAverageLineInfo(availableSize, context, flowState, averageItemsPerLine) + m_lineSpacing;
 
         MUX_ASSERT(averageItemsPerLine != 0);
         if (firstRealized)
@@ -224,18 +224,16 @@ winrt::Rect FlowLayout::GetExtent(
         }
         else
         {
-            const auto lineSpacing = LineSpacing();
-            const auto minItemSpacing = MinItemSpacing();
             // We dont have anything realized. make an educated guess.
             const int numLines = (int)std::ceil(itemsCount / averageItemsPerLine);
             extent =
                 std::isfinite(availableSizeMinor) ?
-                MinorMajorRect(0, 0, availableSizeMinor, std::max(0.0f, static_cast<float>(numLines * averageLineSize - lineSpacing))) :
+                MinorMajorRect(0, 0, availableSizeMinor, std::max(0.0f, static_cast<float>(numLines * averageLineSize - m_lineSpacing))) :
                 MinorMajorRect(
                     0,
                     0,
-                    std::max(0.0f, static_cast<float>((Minor(flowState->SpecialElementDesiredSize()) + minItemSpacing) * itemsCount - minItemSpacing)),
-                    std::max(0.0f, static_cast<float>(averageLineSize - lineSpacing)));
+                    std::max(0.0f, static_cast<float>((Minor(flowState->SpecialElementDesiredSize()) + m_minItemSpacing) * itemsCount - m_minItemSpacing)),
+                    std::max(0.0f, static_cast<float>(averageLineSize - m_lineSpacing)));
             ITEMSREPEATER_TRACE_VERBOSE_DBG(nullptr, TRACE_MSG_METH_IND_STR_STR, METH_NAME, this,
                 winrt::get_self<VirtualizingLayoutContext>(context)->Indent(), LayoutId().data(),
                 L"Estimating extent with no realized elements.");
@@ -421,13 +419,13 @@ void FlowLayout::OnPropertyChanged(const winrt::DependencyPropertyChangedEventAr
 
         UpdateIndexBasedLayoutOrientation(orientation);
     }
-    else if (property == s_MinColumnSpacingProperty)
+    else if (property == s_MinItemSpacingProperty)
     {
-        m_minColumnSpacing = unbox_value<double>(args.NewValue());
+        m_minItemSpacing = unbox_value<double>(args.NewValue());
     }
-    else if (property == s_MinRowSpacingProperty)
+    else if (property == s_LineSpacingProperty)
     {
-        m_minRowSpacing = unbox_value<double>(args.NewValue());
+        m_lineSpacing = unbox_value<double>(args.NewValue());
     }
     else if (property == s_LineAlignmentProperty)
     {

src/controls/dev/Repeater/FlowLayout.h

@@ -166,22 +166,12 @@ class FlowLayout :
         return MajorEnd(realizationWindow) >= MajorStart(extent) && MajorStart(realizationWindow) <= MajorEnd(extent);
     }
 
-    double LineSpacing()
-    {
-        return GetScrollOrientation() == ScrollOrientation::Vertical ? m_minRowSpacing : m_minColumnSpacing;
-    }
-
-    double MinItemSpacing()
-    {
-        return GetScrollOrientation() == ScrollOrientation::Vertical ? m_minColumnSpacing : m_minRowSpacing;
-    }
-
     void UpdateIndexBasedLayoutOrientation(
         const winrt::Orientation& orientation);
 
     // Fields
-    double m_minRowSpacing{};
-    double m_minColumnSpacing{};
+    double m_lineSpacing{};
+    double m_minItemSpacing{};
     winrt::FlowLayoutLineAlignment m_lineAlignment{ winrt::FlowLayoutLineAlignment::Start };
 
     // !!! WARNING !!!

src/controls/dev/Repeater/ItemsRepeater.idl

@@ -516,15 +516,15 @@ unsealed runtimeclass FlowLayout : VirtualizingLayout
     [MUX_DEFAULT_VALUE("winrt::Orientation::Horizontal")]
     Microsoft.UI.Xaml.Controls.Orientation Orientation { get; set; };
     [MUX_DEFAULT_VALUE("0.0")]
-    Double MinRowSpacing { get; set; };
+    Double LineSpacing { get; set; };
     [MUX_DEFAULT_VALUE("0.0")]
-    Double MinColumnSpacing { get; set; };
+    Double MinItemSpacing { get; set; };
     [MUX_DEFAULT_VALUE("winrt::FlowLayoutLineAlignment::Start")]
     FlowLayoutLineAlignment LineAlignment { get; set; };
 
     static Microsoft.UI.Xaml.DependencyProperty OrientationProperty { get; };
-    static Microsoft.UI.Xaml.DependencyProperty MinRowSpacingProperty { get; };
-    static Microsoft.UI.Xaml.DependencyProperty MinColumnSpacingProperty { get; };
+    static Microsoft.UI.Xaml.DependencyProperty LineSpacingProperty { get; };
+    static Microsoft.UI.Xaml.DependencyProperty MinItemSpacingProperty { get; };
     static Microsoft.UI.Xaml.DependencyProperty LineAlignmentProperty { get; };
 
     overridable Windows.Foundation.Size GetMeasureSize(Int32 index, Windows.Foundation.Size availableSize);

src/controls/dev/Repeater/TestUI/RepeaterTestUIPage.xaml

@@ -6,11 +6,11 @@
 
     <LayoutPanel Background="{ThemeResource ApplicationPageBackgroundThemeBrush}" HorizontalAlignment="Center" VerticalAlignment="Center">
         <LayoutPanel.Layout>
-            <FlowLayout Orientation="Vertical" MinColumnSpacing="5" MinRowSpacing="5"/>
+            <FlowLayout Orientation="Vertical" MinItemSpacing="5" LineSpacing="5"/>
         </LayoutPanel.Layout>
 
         <LayoutPanel.Resources>
-            <FlowLayout x:Key="flow" MinRowSpacing="5" MinColumnSpacing="5"/>
+            <FlowLayout x:Key="flow" LineSpacing="5" MinItemSpacing="5"/>
             <StackLayout x:Key="stack" Spacing="5"/>
         </LayoutPanel.Resources>
 
@@ -43,9 +43,9 @@
         <StackPanel>
             <TextBlock Text="Built in layouts" Style="{StaticResource SubheaderTextBlockStyle}"/>
             <StackPanel>
-                <TextBlock>ItemSpacing</TextBlock>
+                <TextBlock>MinItemSpacing</TextBlock>
                 <TextBox x:Name="itemSpacing" Text="10"/>
-                <TextBlock>MinColumnSpacing</TextBlock>
+                <TextBlock>LineSpacing</TextBlock>
                 <TextBox x:Name="lineSpacing" Text="10"/>
                 <TextBlock>LineAlignment</TextBlock>
                 <TextBlock>(Start/Center/End/SpaceEvenly/SpaceAround/SpaceBetween)</TextBlock>