Merge branch 'main' into fix_WrapLayoutSample

Author: Avid29

components/Collections/samples/AdvancedCollectionViewSample.xaml.cs

@@ -48,7 +48,7 @@ private void Setup()
         // right list
         AdvancedCollectionView acv = new(EmployeeCollection);
         acv.Filter = x => !int.TryParse(((Employee)x).Name, out _);
-        acv.SortDescriptions.Add(new(nameof(Employee.Name), SortDirection.Ascending));
+        acv.SortDescriptions.Add(new SortDescription<Employee>(nameof(Employee.Name), SortDirection.Ascending));
 
         CollectionView = acv;
     }

components/Collections/src/AdvancedCollectionView/AdvancedCollectionView.cs

@@ -13,9 +13,6 @@ namespace CommunityToolkit.WinUI.Collections;
 /// <summary>
 /// A collection view implementation that supports filtering, sorting and incremental loading
 /// </summary>
-#if NET8_0_OR_GREATER
-[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Item sorting uses reflection to get property types and may not be AOT compatible.")]
-#endif
 public partial class AdvancedCollectionView : IAdvancedCollectionView, INotifyPropertyChanged, ISupportIncrementalLoading, IComparer<object>
 {
     private readonly List<object> _view;
@@ -383,7 +380,7 @@ public Predicate<object> Filter
     int IComparer<object>.Compare(object x, object y)
 #pragma warning restore CA1033 // Interface methods should be callable by child types
     {
-        if (!_sortProperties.Any())
+        if (_sortProperties.Count == 0)
         {
             var listType = _source?.GetType();
             Type type;
@@ -401,7 +398,7 @@ int IComparer<object>.Compare(object x, object y)
             {
                 if (!string.IsNullOrEmpty(sd.PropertyName))
                 {
-                    _sortProperties[sd.PropertyName] = type.GetProperty(sd.PropertyName);
+                    _sortProperties[sd.PropertyName] = sd.GetProperty(type);
                 }
             }
         }
@@ -419,8 +416,8 @@ int IComparer<object>.Compare(object x, object y)
             {
                 var pi = _sortProperties[sd.PropertyName];
 
-                cx = pi.GetValue(x!);
-                cy = pi.GetValue(y!);
+                cx = pi.GetValue(x);
+                cy = pi.GetValue(y);
             }
 
             var cmp = sd.Comparer.Compare(cx, cy);

components/Collections/src/AdvancedCollectionView/SortDescription.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 
 namespace CommunityToolkit.WinUI.Collections;
 
@@ -14,7 +15,7 @@ public class SortDescription
     /// <summary>
     /// Gets the name of property to sort on
     /// </summary>
-    public string PropertyName { get; }
+    public string? PropertyName { get; }
 
     /// <summary>
     /// Gets the direction of sort
@@ -33,8 +34,10 @@ public class SortDescription
     /// <param name="direction">Direction of sort</param>
     /// <param name="comparer">Comparer to use. If null, will use default comparer</param>
     public SortDescription(SortDirection direction, IComparer? comparer = null)
-        : this(null!, direction, comparer!)
     {
+        PropertyName = null;
+        Direction = direction;
+        Comparer = comparer ?? ObjectComparer.Instance;
     }
 
     /// <summary>
@@ -43,13 +46,23 @@ public SortDescription(SortDirection direction, IComparer? comparer = null)
     /// <param name="propertyName">Name of property to sort on</param>
     /// <param name="direction">Direction of sort</param>
     /// <param name="comparer">Comparer to use. If null, will use default comparer</param>
+#if NET8_0_OR_GREATER
+    [RequiresUnreferencedCode("Item sorting with the property name uses reflection to get the property and is not trim-safe. Either use SortDescription<T> to preserve the required metadata, or use the other constructor without a property name.")]
+#endif
     public SortDescription(string propertyName, SortDirection direction, IComparer? comparer = null)
     {
         PropertyName = propertyName;
         Direction = direction;
         Comparer = comparer ?? ObjectComparer.Instance;
     }
 
+#if NET8_0_OR_GREATER
+    [UnconditionalSuppressMessage("Trimming", "IL2070:'this' argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The parameter of method does not have matching annotations.",
+        Justification = "The path which does reflection is only triggered if the user uses the constructor with RequiresUnreferencedCode, which will inform them of the risk.")]
+#endif
+    internal virtual PropertyInfo? GetProperty(Type type)
+        => PropertyName != null ? type.GetProperty(PropertyName) : null;
+
     private class ObjectComparer : IComparer
     {
         public static readonly IComparer Instance = new ObjectComparer();

components/Collections/src/AdvancedCollectionView/SortDescription{T}.cs

@@ -0,0 +1,39 @@
+// 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.
+
+using System.Collections;
+using System.Diagnostics.CodeAnalysis;
+
+namespace CommunityToolkit.WinUI.Collections;
+
+/// <summary>
+/// A generic version of <see cref="SortDescription"/> which preserves the required metadata for reflection-based sorting.
+/// </summary>
+/// <typeparam name="T">The type to sort</typeparam>
+public sealed class SortDescription<
+#if NET8_0_OR_GREATER
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)]
+#endif
+    T> : SortDescription
+{
+    private readonly PropertyInfo _prop;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SortDescription{T}"/> class.
+    /// </summary>
+    /// <param name="propertyName">Name of property to sort on</param>
+    /// <param name="direction">Direction of sort</param>
+    /// <param name="comparer">Comparer to use. If null, will use default comparer</param>
+#if NET8_0_OR_GREATER
+    [UnconditionalSuppressMessage("Trimming", "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code",
+        Justification = "This class preserves metadata and ensures at runtime that the received type is compatible.")]
+#endif
+    public SortDescription(string propertyName, SortDirection direction, IComparer? comparer = null) : base(propertyName, direction, comparer)
+    {
+        _prop = typeof(T).GetProperty(propertyName) ?? throw new ArgumentException($"Could not find property {propertyName}");
+    }
+
+    internal override PropertyInfo? GetProperty(Type type) =>
+        (_prop.DeclaringType is not null && _prop.DeclaringType.IsAssignableFrom(type)) ? _prop : throw new ArgumentException("This instance of SortDescription is not compatible with the desired type");
+}

components/RangeSelector/samples/RangeSelector.md

@@ -16,6 +16,22 @@ A `RangeSelector` is pretty similar to a regular `Slider`, and shares some of it
 
 > [!Sample RangeSelectorSample]
 
+> [!NOTE]
+> Use 'VerticalAlignment="Stretch"' When 'Orientation="Vertical"'
+
+Like this:
+
+```xaml
+<controls:RangeSelector x:Name="rangeSelector"
+                                VerticalAlignment="Stretch"
+                                Maximum="100"
+                                Minimum="0"
+                                Orientation="Vertical"
+                                RangeEnd="100"
+                                RangeStart="0"
+                                StepFrequency="1" />
+```
+
 > [!NOTE]
 > If you are using a RangeSelector within a ScrollViewer you'll need to add some codes. This is because by default, the ScrollViewer will block the thumbs of the RangeSelector to capture the pointer.
 

components/RangeSelector/samples/RangeSelectorSample.xaml

@@ -12,11 +12,13 @@
           MinHeight="86"
           MaxWidth="560"
           HorizontalAlignment="Stretch">
+        <!--  Use 'VerticalAlignment="Stretch"' When 'Orientation="Vertical"'  -->
         <controls:RangeSelector x:Name="rangeSelector"
                                 VerticalAlignment="Center"
                                 IsEnabled="{x:Bind Enable, Mode=OneWay}"
                                 Maximum="{x:Bind Maximum, Mode=OneWay}"
                                 Minimum="{x:Bind Minimum, Mode=OneWay}"
+                                Orientation="{x:Bind OrientationMode, Mode=OneWay}"
                                 RangeEnd="100"
                                 RangeStart="0"
                                 StepFrequency="{x:Bind StepFrequency, Mode=OneWay}" />

components/RangeSelector/samples/RangeSelectorSample.xaml.cs

@@ -9,6 +9,7 @@ namespace RangeSelectorExperiment.Samples;
 [ToolkitSampleNumericOption("Minimum", 0, 0, 100, 1, false, Title = "Minimum")]
 [ToolkitSampleNumericOption("Maximum", 100, 0, 100, 1, false, Title = "Maximum")]
 [ToolkitSampleNumericOption("StepFrequency", 1, 0, 10, 1, false, Title = "StepFrequency")]
+[ToolkitSampleMultiChoiceOption("OrientationMode", "Horizontal", "Vertical", Title = "Orientation")]
 [ToolkitSampleBoolOption("Enable", true, Title = "IsEnabled")]
 
 [ToolkitSample(id: nameof(RangeSelectorSample), "RangeSelector", description: $"A sample for showing how to create and use a {nameof(RangeSelector)} control.")]

components/RangeSelector/src/Dependencies.props

@@ -12,6 +12,7 @@
     <!-- WinUI 2 / UWP -->
     <ItemGroup Condition="'$(IsUwp)' == 'true'">
         <!-- <PackageReference Include="Microsoft.Toolkit.Uwp.UI.Controls.Primitives" Version="7.1.2"/> -->
+        <PackageReference Include="Microsoft.Bcl.HashCode" Version="1.1.1" />
     </ItemGroup>
 
     <!-- WinUI 2 / Uno -->

components/RangeSelector/src/RangeSelector.Helpers.UVCoord.cs

@@ -0,0 +1,152 @@
+// 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>
+/// A struct representing a coordinate in UV adjusted space.
+/// </summary>
+[DebuggerDisplay("({U}u,{V}v)")]
+public struct UVCoord: IEquatable<UVCoord>
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="UVCoord"/> struct.
+    /// </summary>
+    public UVCoord(Orientation orientation)
+    {
+        Orientation = orientation;
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="UVCoord"/> struct.
+    /// </summary>
+    public UVCoord(double x, double y, Orientation orientation)
+    {
+        X = x;
+        Y = y;
+        Orientation = orientation;
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="UVCoord"/> struct.
+    /// </summary>
+    public UVCoord(Point point, Orientation orientation) : this(point.X, point.Y, orientation)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="UVCoord"/> struct.
+    /// </summary>
+    public UVCoord(Size size, Orientation orientation) : this(size.Width, size.Height, orientation)
+    {
+    }
+
+    /// <summary>
+    /// Gets or sets the X coordinate.
+    /// </summary>
+    public double X { readonly get; set; }
+
+    /// <summary>
+    /// Gets or sets the Y coordinate.
+    /// </summary>
+    public double Y { readonly get; set; }
+
+    /// <summary>
+    /// Gets or sets the orientation for translation between the XY and UV coordinate systems.
+    /// </summary>
+    public Orientation Orientation { get; set; }
+
+    /// <summary>
+    /// Gets or sets the U coordinate.
+    /// </summary>
+    public double U
+    {
+        readonly get => Orientation is Orientation.Horizontal ? X : Y;
+        set
+        {
+            if (Orientation is Orientation.Horizontal)
+            {
+                X = value;
+            }
+            else
+            {
+                Y = value;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets the V coordinate.
+    /// </summary>
+    public double V
+    {
+        readonly get => Orientation is Orientation.Vertical ? X : Y;
+        set
+        {
+            if (Orientation is Orientation.Vertical)
+            {
+                X = value;
+            }
+            else
+            {
+                Y = value;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Implicitly casts a <see cref="UVCoord"/> to a <see cref="Point"/>.
+    /// </summary>
+    public static implicit operator Point(UVCoord uv) => new(uv.X, uv.Y);
+
+    /// <summary>
+    /// Implicitly casts a <see cref="UVCoord"/> to a <see cref="Size"/>.
+    /// </summary>
+    public static implicit operator Size(UVCoord uv) => new(uv.X, uv.Y);
+
+    /// <inheritdoc/>
+    public static UVCoord operator +(UVCoord addend1, UVCoord addend2)
+    {
+        if (addend1.Orientation != addend2.Orientation)
+        {
+            throw new InvalidOperationException($"Cannot add {nameof(UVCoord)} with mismatched {nameof(Orientation)}.");
+        }
+
+        var xSum = addend1.X + addend2.X;
+        var ySum = addend1.Y + addend2.Y;
+        var orientation = addend1.Orientation;
+        return new UVCoord(xSum, ySum, orientation);
+    }
+
+    /// <inheritdoc/>
+    public static bool operator ==(UVCoord coord1, UVCoord coord2)
+    {
+        return coord1.U == coord2.U && coord1.V == coord2.V;
+    }
+
+
+    /// <inheritdoc/>
+    public static bool operator !=(UVCoord measure1, UVCoord measure2)
+    {
+        return !(measure1 == measure2);
+    }
+
+    /// <inheritdoc/>
+    public override bool Equals(object? obj)
+    {
+        return obj is UVCoord other && Equals(other);
+    }
+
+    /// <inheritdoc/>
+    public bool Equals(UVCoord other)
+    {
+        return this == other;
+    }
+
+    /// <inheritdoc/>
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(U, V);
+    }
+}