Syncing content from committish 4e2e9e3b88c957dc7b253be9db4366f44f5068ed

Author: reunion-maestro-bot

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

@@ -13,10 +13,12 @@ namespace winrt::Microsoft::UI::Xaml::Controls
 
 #include "TitleBar.g.cpp"
 
+GlobalDependencyProperty TitleBarProperties::s_AutoRefreshDragRegionsProperty{ nullptr };
 GlobalDependencyProperty TitleBarProperties::s_ContentProperty{ nullptr };
 GlobalDependencyProperty TitleBarProperties::s_IconSourceProperty{ nullptr };
 GlobalDependencyProperty TitleBarProperties::s_IsBackButtonEnabledProperty{ nullptr };
 GlobalDependencyProperty TitleBarProperties::s_IsBackButtonVisibleProperty{ nullptr };
+GlobalDependencyProperty TitleBarProperties::s_IsDragRegionProperty{ nullptr };
 GlobalDependencyProperty TitleBarProperties::s_IsPaneToggleButtonVisibleProperty{ nullptr };
 GlobalDependencyProperty TitleBarProperties::s_LeftHeaderProperty{ nullptr };
 GlobalDependencyProperty TitleBarProperties::s_RightHeaderProperty{ nullptr };
@@ -33,6 +35,17 @@ TitleBarProperties::TitleBarProperties()
 
 void TitleBarProperties::EnsureProperties()
 {
+    if (!s_AutoRefreshDragRegionsProperty)
+    {
+        s_AutoRefreshDragRegionsProperty =
+            InitializeDependencyProperty(
+                L"AutoRefreshDragRegions",
+                winrt::name_of<bool>(),
+                winrt::name_of<winrt::TitleBar>(),
+                false /* isAttached */,
+                ValueHelper<bool>::BoxValueIfNecessary(false),
+                winrt::PropertyChangedCallback(&OnAutoRefreshDragRegionsPropertyChanged));
+    }
     if (!s_ContentProperty)
     {
         s_ContentProperty =
@@ -77,6 +90,17 @@ void TitleBarProperties::EnsureProperties()
                 ValueHelper<bool>::BoxValueIfNecessary(false),
                 winrt::PropertyChangedCallback(&OnIsBackButtonVisiblePropertyChanged));
     }
+    if (!s_IsDragRegionProperty)
+    {
+        s_IsDragRegionProperty =
+            InitializeDependencyProperty(
+                L"IsDragRegion",
+                winrt::name_of<winrt::IReference<bool>>(),
+                winrt::name_of<winrt::TitleBar>(),
+                true /* isAttached */,
+                ValueHelper<winrt::IReference<bool>>::BoxedDefaultValue(),
+                &TitleBar::OnIsDragRegionPropertyChanged);
+    }
     if (!s_IsPaneToggleButtonVisibleProperty)
     {
         s_IsPaneToggleButtonVisibleProperty =
@@ -147,10 +171,12 @@ void TitleBarProperties::EnsureProperties()
 
 void TitleBarProperties::ClearProperties()
 {
+    s_AutoRefreshDragRegionsProperty = nullptr;
     s_ContentProperty = nullptr;
     s_IconSourceProperty = nullptr;
     s_IsBackButtonEnabledProperty = nullptr;
     s_IsBackButtonVisibleProperty = nullptr;
+    s_IsDragRegionProperty = nullptr;
     s_IsPaneToggleButtonVisibleProperty = nullptr;
     s_LeftHeaderProperty = nullptr;
     s_RightHeaderProperty = nullptr;
@@ -159,6 +185,14 @@ void TitleBarProperties::ClearProperties()
     s_TitleProperty = nullptr;
 }
 
+void TitleBarProperties::OnAutoRefreshDragRegionsPropertyChanged(
+    winrt::DependencyObject const& sender,
+    winrt::DependencyPropertyChangedEventArgs const& args)
+{
+    auto owner = sender.as<winrt::TitleBar>();
+    winrt::get_self<TitleBar>(owner)->OnPropertyChanged(args);
+}
+
 void TitleBarProperties::OnContentPropertyChanged(
     winrt::DependencyObject const& sender,
     winrt::DependencyPropertyChangedEventArgs const& args)
@@ -239,6 +273,19 @@ void TitleBarProperties::OnTitlePropertyChanged(
     winrt::get_self<TitleBar>(owner)->OnPropertyChanged(args);
 }
 
+void TitleBarProperties::AutoRefreshDragRegions(bool value)
+{
+    [[gsl::suppress(con)]]
+    {
+    static_cast<TitleBar*>(this)->SetValue(s_AutoRefreshDragRegionsProperty, ValueHelper<bool>::BoxValueIfNecessary(value));
+    }
+}
+
+bool TitleBarProperties::AutoRefreshDragRegions()
+{
+    return ValueHelper<bool>::CastOrUnbox(static_cast<TitleBar*>(this)->GetValue(s_AutoRefreshDragRegionsProperty));
+}
+
 void TitleBarProperties::Content(winrt::UIElement const& value)
 {
     [[gsl::suppress(con)]]
@@ -291,6 +338,17 @@ bool TitleBarProperties::IsBackButtonVisible()
     return ValueHelper<bool>::CastOrUnbox(static_cast<TitleBar*>(this)->GetValue(s_IsBackButtonVisibleProperty));
 }
 
+
+void TitleBarProperties::SetIsDragRegion(winrt::UIElement const& target, winrt::IReference<bool> const& value)
+{
+    target.SetValue(s_IsDragRegionProperty, ValueHelper<winrt::IReference<bool>>::BoxValueIfNecessary(value));
+}
+
+winrt::IReference<bool> TitleBarProperties::GetIsDragRegion(winrt::UIElement const& target)
+{
+    return ValueHelper<winrt::IReference<bool>>::CastOrUnbox(target.GetValue(s_IsDragRegionProperty));
+}
+
 void TitleBarProperties::IsPaneToggleButtonVisible(bool value)
 {
     [[gsl::suppress(con)]]

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

@@ -9,6 +9,9 @@ class TitleBarProperties
 public:
     TitleBarProperties();
 
+    void AutoRefreshDragRegions(bool value);
+    bool AutoRefreshDragRegions();
+
     void Content(winrt::UIElement const& value);
     winrt::UIElement Content();
 
@@ -21,6 +24,9 @@ class TitleBarProperties
     void IsBackButtonVisible(bool value);
     bool IsBackButtonVisible();
 
+    static void SetIsDragRegion(winrt::UIElement const& target, winrt::IReference<bool> const& value);
+    static winrt::IReference<bool> GetIsDragRegion(winrt::UIElement const& target);
+
     void IsPaneToggleButtonVisible(bool value);
     bool IsPaneToggleButtonVisible();
 
@@ -39,21 +45,25 @@ class TitleBarProperties
     void Title(winrt::hstring const& value);
     winrt::hstring Title();
 
+    static winrt::DependencyProperty AutoRefreshDragRegionsProperty() { return s_AutoRefreshDragRegionsProperty; }
     static winrt::DependencyProperty ContentProperty() { return s_ContentProperty; }
     static winrt::DependencyProperty IconSourceProperty() { return s_IconSourceProperty; }
     static winrt::DependencyProperty IsBackButtonEnabledProperty() { return s_IsBackButtonEnabledProperty; }
     static winrt::DependencyProperty IsBackButtonVisibleProperty() { return s_IsBackButtonVisibleProperty; }
+    static winrt::DependencyProperty IsDragRegionProperty() { return s_IsDragRegionProperty; }
     static winrt::DependencyProperty IsPaneToggleButtonVisibleProperty() { return s_IsPaneToggleButtonVisibleProperty; }
     static winrt::DependencyProperty LeftHeaderProperty() { return s_LeftHeaderProperty; }
     static winrt::DependencyProperty RightHeaderProperty() { return s_RightHeaderProperty; }
     static winrt::DependencyProperty SubtitleProperty() { return s_SubtitleProperty; }
     static winrt::DependencyProperty TemplateSettingsProperty() { return s_TemplateSettingsProperty; }
     static winrt::DependencyProperty TitleProperty() { return s_TitleProperty; }
 
+    static GlobalDependencyProperty s_AutoRefreshDragRegionsProperty;
     static GlobalDependencyProperty s_ContentProperty;
     static GlobalDependencyProperty s_IconSourceProperty;
     static GlobalDependencyProperty s_IsBackButtonEnabledProperty;
     static GlobalDependencyProperty s_IsBackButtonVisibleProperty;
+    static GlobalDependencyProperty s_IsDragRegionProperty;
     static GlobalDependencyProperty s_IsPaneToggleButtonVisibleProperty;
     static GlobalDependencyProperty s_LeftHeaderProperty;
     static GlobalDependencyProperty s_RightHeaderProperty;
@@ -72,6 +82,10 @@ class TitleBarProperties
     static void EnsureProperties();
     static void ClearProperties();
 
+    static void OnAutoRefreshDragRegionsPropertyChanged(
+        winrt::DependencyObject const& sender,
+        winrt::DependencyPropertyChangedEventArgs const& args);
+
     static void OnContentPropertyChanged(
         winrt::DependencyObject const& sender,
         winrt::DependencyPropertyChangedEventArgs const& args);

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

@@ -1232,6 +1232,42 @@ public void ValidateIntersectionWithRealizationWindow()
             }
         }
 
+        [TestMethod]
+        public void ValidateUniformGridWithAvailableWidthNarrowerThanOneItem()
+        {
+            // Watson #61810783: when a UniformGridLayout receives a finite available minor
+            // size that is narrower than one item's minor stride, GetItemsPerLine used to
+            // return 0, causing a divide-by-zero in GetMajorSize during anchor evaluation.
+            // Verify that the layout pass completes without crashing and produces a sane
+            // (>= 1 item per line) layout instead.
+            RunOnUIThread.Execute(() =>
+            {
+                var repeater = new ItemsRepeater()
+                {
+                    ItemsSource = Enumerable.Range(0, 6).Select(i => i.ToString()).ToList(),
+                    Layout = new UniformGridLayout()
+                    {
+                        Orientation = Orientation.Horizontal,
+                        MinItemWidth = 100,
+                        MinItemHeight = 50
+                    },
+                };
+
+                // Constrain the repeater to a width narrower than MinItemWidth.
+                var host = new Grid() { Width = 5, Height = 200 };
+                host.Children.Add(repeater);
+
+                Content = host;
+                Content.UpdateLayout();
+
+                // The fix should produce a non-crashing layout. We don't validate exact
+                // dimensions because the policy when a single item is wider than the
+                // available width is "still lay out one item per line", which produces a
+                // non-zero major extent.
+                Verify.IsTrue(repeater.DesiredSize.Height >= 0);
+            });
+        }
+
         [TestMethod]
         public void ValidateUniformGridWithNoItems()
         {

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

@@ -755,5 +755,132 @@ public void BringIntoViewOfExistingItemsDoesNotChangeScrollOffset()
             });
         }
 
+        // Verifies that an ItemsRepeater using a DataTemplate can be garbage
+        // collected after elements are recycled to the RecyclePool and the
+        // repeater is removed from the tree. The recycling step is critical —
+        // it creates the RecyclePool on the DataTemplate and populates it,
+        // which forms the reference cycle that must be breakable by the tracker.
+        [TestMethod]
+        public void VerifyRepeaterWithRecycledElementsDoesNotLeak()
+        {
+            WeakReference repeaterWeakRef = null;
+            var data = new ObservableCollection<string>(
+                Enumerable.Range(0, 5).Select(i => string.Format("Item #{0}", i)));
+
+            RunOnUIThread.Execute(() =>
+            {
+                var repeater = new ItemsRepeater()
+                {
+                    ItemsSource = data,
+                    ItemTemplate = CreateDataTemplateWithContent(@"<TextBlock Text='{Binding}' Height='50' />"),
+                };
+                repeaterWeakRef = new WeakReference(repeater);
+                Content = repeater;
+            });
+
+            IdleSynchronizer.Wait();
+
+            RunOnUIThread.Execute(() =>
+            {
+                // Verify elements are realized, then clear the data source to
+                // force all elements into the RecyclePool on the DataTemplate.
+                Verify.IsNotNull(repeaterWeakRef.Target);
+                var repeater = (ItemsRepeater)repeaterWeakRef.Target;
+                Verify.IsNotNull(repeater.TryGetElement(0), "Element 0 should be realized.");
+                data.Clear();
+            });
+
+            IdleSynchronizer.Wait();
+
+            RunOnUIThread.Execute(() =>
+            {
+                // Remove from tree. The RecyclePool now holds recycled elements
+                // that reference the DataTemplate and the repeater (as owner).
+                Content = null;
+            });
+
+            IdleSynchronizer.Wait();
+
+            // Force GC — the tracker_ref on ItemTemplateWrapper's DataTemplate
+            // makes the reference visible to the XAML reference tracker, which
+            // detects the RecyclePool cycle and breaks it during collection.
+            for (int i = 0; i < 5 && repeaterWeakRef.IsAlive; i++)
+            {
+                GC.Collect();
+                GC.WaitForPendingFinalizers();
+                IdleSynchronizer.Wait();
+            }
+
+            Verify.IsFalse(repeaterWeakRef.IsAlive,
+                "ItemsRepeater should be collected after recycling elements and removal.");
+        }
+
+        // Verifies that an ItemsRepeater using a RecyclingElementFactory (the
+        // DataTemplateSelector equivalent) can be garbage collected after
+        // elements are recycled and the repeater is removed from the tree.
+        [TestMethod]
+        public void VerifyRepeaterWithRecyclingElementFactoryDoesNotLeak()
+        {
+            WeakReference repeaterWeakRef = null;
+            var data = new ObservableCollection<int>(Enumerable.Range(0, 6));
+
+            RunOnUIThread.Execute(() =>
+            {
+                var elementFactory = new RecyclingElementFactory()
+                {
+                    RecyclePool = new RecyclePool(),
+                };
+                elementFactory.Templates["even"] = (DataTemplate)XamlReader.Load(
+                    @"<DataTemplate xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'>
+                        <TextBlock Text='even' Height='50' />
+                    </DataTemplate>");
+                elementFactory.Templates["odd"] = (DataTemplate)XamlReader.Load(
+                    @"<DataTemplate xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'>
+                        <TextBlock Text='odd' Height='50' />
+                    </DataTemplate>");
+
+                elementFactory.SelectTemplateKey +=
+                    delegate (RecyclingElementFactory sender, SelectTemplateEventArgs args)
+                    {
+                        args.TemplateKey = ((int)args.DataContext % 2 == 0) ? "even" : "odd";
+                    };
+
+                var repeater = new ItemsRepeater()
+                {
+                    ItemsSource = data,
+                    ItemTemplate = elementFactory,
+                };
+                repeaterWeakRef = new WeakReference(repeater);
+                Content = repeater;
+            });
+
+            IdleSynchronizer.Wait();
+
+            RunOnUIThread.Execute(() =>
+            {
+                // Clear items to force elements into the RecyclePool, then remove.
+                data.Clear();
+            });
+
+            IdleSynchronizer.Wait();
+
+            RunOnUIThread.Execute(() =>
+            {
+                Content = null;
+            });
+
+            IdleSynchronizer.Wait();
+
+            for (int i = 0; i < 5 && repeaterWeakRef.IsAlive; i++)
+            {
+                GC.Collect();
+                GC.WaitForPendingFinalizers();
+                IdleSynchronizer.Wait();
+            }
+
+            Verify.IsFalse(repeaterWeakRef.IsAlive,
+                "ItemsRepeater with RecyclingElementFactory should be collected after recycling and removal.");
+        }
+
     }
 }