Merge branch 'master' into feature/parameterless-throw-helpers2

Author: Rosuavio

Microsoft.Toolkit.Uwp.SampleApp/SamplePages/WrapPanel/WrapPanel.bind

@@ -49,6 +49,16 @@
                               HorizontalSpacing="@[HorizontalSpacing:Slider:5:0-200]@" />
         </ItemsPanelTemplate>
       </ItemsControl.ItemsPanel>
+      <ListView.ItemContainerStyle>
+        <Style TargetType="ListViewItem">
+          <!-- Change those values to change the WrapPanel's children alignment -->
+          <Setter Property="VerticalContentAlignment" Value="Center" />
+          <Setter Property="HorizontalContentAlignment" Value="Center" />
+          <Setter Property="Padding" Value="0" />
+          <Setter Property="MinWidth" Value="0" />
+          <Setter Property="MinHeight" Value="0" />
+        </Style>
+      </ListView.ItemContainerStyle>
     </ListView>
   </Grid>
 </Page>

Microsoft.Toolkit.Uwp.SampleApp/SamplePages/WrapPanel/WrapPanelPage.xaml.cs

@@ -64,8 +64,8 @@ private void AddButton_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e)
             {
                 Category = "Remove",
                 Thumbnail = "ms-appx:///Assets/Photos/BigFourSummerHeat.jpg",
-                Width = Rand.Next(120, 180),
-                Height = Rand.Next(80, 130)
+                Width = Rand.Next(60, 180),
+                Height = Rand.Next(40, 140)
             });
         }
 

Microsoft.Toolkit.Uwp.UI.Controls/RadialGauge/RadialGauge.cs

@@ -469,6 +469,11 @@ protected override void OnValueChanged(double oldValue, double newValue)
         {
             OnValueChanged(this);
             base.OnValueChanged(oldValue, newValue);
+            if (AutomationPeer.ListenerExists(AutomationEvents.LiveRegionChanged))
+            {
+                var peer = FrameworkElementAutomationPeer.FromElement(this) as RadialGaugeAutomationPeer;
+                peer?.RaiseValueChangedEvent(oldValue, newValue);
+            }
         }
 
         private static void OnValueChanged(DependencyObject d)

Microsoft.Toolkit.Uwp.UI.Controls/RadialGauge/RadialGaugeAutomationPeer.cs

@@ -3,6 +3,8 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Collections.Generic;
+using Windows.Foundation;
+using Windows.UI.Xaml.Automation;
 using Windows.UI.Xaml.Automation.Peers;
 using Windows.UI.Xaml.Automation.Provider;
 
@@ -12,7 +14,7 @@ namespace Microsoft.Toolkit.Uwp.UI.Controls
     /// Exposes <see cref="RadialGauge"/> to Microsoft UI Automation.
     /// </summary>
     public class RadialGaugeAutomationPeer :
-        FrameworkElementAutomationPeer,
+        RangeBaseAutomationPeer,
         IRangeValueProvider
     {
         /// <summary>
@@ -25,25 +27,25 @@ public RadialGaugeAutomationPeer(RadialGauge owner)
         }
 
         /// <inheritdoc/>
-        public bool IsReadOnly => !((RadialGauge)Owner).IsInteractive;
+        public new bool IsReadOnly => !((RadialGauge)Owner).IsInteractive;
 
         /// <inheritdoc/>
-        public double LargeChange => ((RadialGauge)Owner).StepSize;
+        public new double LargeChange => ((RadialGauge)Owner).StepSize;
 
         /// <inheritdoc/>
-        public double Maximum => ((RadialGauge)Owner).Maximum;
+        public new double Maximum => ((RadialGauge)Owner).Maximum;
 
         /// <inheritdoc/>
-        public double Minimum => ((RadialGauge)Owner).Minimum;
+        public new double Minimum => ((RadialGauge)Owner).Minimum;
 
         /// <inheritdoc/>
-        public double SmallChange => ((RadialGauge)Owner).StepSize;
+        public new double SmallChange => ((RadialGauge)Owner).StepSize;
 
         /// <inheritdoc/>
-        public double Value => ((RadialGauge)Owner).Value;
+        public new double Value => ((RadialGauge)Owner).Value;
 
         /// <inheritdoc/>
-        public void SetValue(double value)
+        public new void SetValue(double value)
         {
             ((RadialGauge)Owner).Value = value;
         }
@@ -58,7 +60,7 @@ protected override IList<AutomationPeer> GetChildrenCore()
         protected override string GetNameCore()
         {
             var gauge = (RadialGauge)Owner;
-            return "radial gauge. " + (string.IsNullOrWhiteSpace(gauge.Unit) ? "no unit specified. " : "unit " + gauge.Unit + ". ");
+            return "radial gauge. " + (string.IsNullOrWhiteSpace(gauge.Unit) ? "no unit specified, " : "unit " + gauge.Unit + ", ") + Value;
         }
 
         /// <inheritdoc/>
@@ -78,5 +80,15 @@ protected override AutomationControlType GetAutomationControlTypeCore()
         {
             return AutomationControlType.Custom;
         }
+
+        /// <summary>
+        /// Raises the property changed event for this AutomationPeer for the provided identifier.
+        /// </summary>
+        /// <param name="oldValue">Old value</param>
+        /// <param name="newValue">New value</param>
+        public void RaiseValueChangedEvent(double oldValue, double newValue)
+        {
+            RaisePropertyChangedEvent(RangeValuePatternIdentifiers.ValueProperty, PropertyValue.CreateDouble(oldValue), PropertyValue.CreateDouble(newValue));
+        }
     }
 }

Microsoft.Toolkit.Uwp.UI.Controls/WrapPanel/WrapPanel.Data.cs

@@ -2,6 +2,10 @@
 // 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;
+using System.Collections.Generic;
+using Microsoft.Toolkit.Diagnostics;
+using Windows.Foundation;
 using Windows.UI.Xaml.Controls;
 
 namespace Microsoft.Toolkit.Uwp.UI.Controls
@@ -14,12 +18,17 @@ public partial class WrapPanel
         [System.Diagnostics.DebuggerDisplay("U = {U} V = {V}")]
         private struct UvMeasure
         {
-            internal static readonly UvMeasure Zero = default(UvMeasure);
+            internal static UvMeasure Zero => default;
 
             internal double U { get; set; }
 
             internal double V { get; set; }
 
+            public UvMeasure(Orientation orientation, Size size)
+                : this(orientation, size.Width, size.Height)
+            {
+            }
+
             public UvMeasure(Orientation orientation, double width, double height)
             {
                 if (orientation == Orientation.Horizontal)
@@ -33,6 +42,56 @@ public UvMeasure(Orientation orientation, double width, double height)
                     V = width;
                 }
             }
+
+            public UvMeasure Add(double u, double v)
+                => new UvMeasure { U = U + u, V = V + v };
+
+            public UvMeasure Add(UvMeasure measure)
+                => Add(measure.U, measure.V);
+
+            public Size ToSize(Orientation orientation)
+                => orientation == Orientation.Horizontal ? new Size(U, V) : new Size(V, U);
+        }
+
+        private struct UvRect
+        {
+            public UvMeasure Position { get; set; }
+
+            public UvMeasure Size { get; set; }
+
+            public Rect ToRect(Orientation orientation) => orientation switch
+            {
+                Orientation.Vertical => new Rect(Position.V, Position.U, Size.V, Size.U),
+                Orientation.Horizontal => new Rect(Position.U, Position.V, Size.U, Size.V),
+                _ => ThrowHelper.ThrowNotSupportedException<Rect>("unsupported orientation"),
+            };
+        }
+
+        private struct Row
+        {
+            public Row(List<UvRect> childrenRects, UvMeasure size)
+            {
+                ChildrenRects = childrenRects;
+                Size = size;
+            }
+
+            public List<UvRect> ChildrenRects { get; }
+
+            public UvMeasure Size { get; set; }
+
+            public UvRect Rect => ChildrenRects.Count > 0 ?
+                new UvRect { Position = ChildrenRects[0].Position, Size = Size } :
+                new UvRect { Position = UvMeasure.Zero, Size = Size };
+
+            public void Add(UvMeasure position, UvMeasure size)
+            {
+                ChildrenRects.Add(new UvRect { Position = position, Size = size });
+                Size = new UvMeasure
+                {
+                    U = position.U + size.U,
+                    V = Math.Max(Size.V, size.V),
+                };
+            }
         }
     }
 }