Update RangeMin and RangeMax to RangeStart and RangeEnd

michael-hawker · Rosuavio · commit d6fcdfc02167 · 2021-03-08T15:30:58.000-05:00
These properties and their descriptions were confusing (and abbreviated) which made it difficult to understand how they differed from the Minimum/Maximum value properties. This clearly now separates which properties are being selected by the user. Their comments have been updated as well. It also aligns with the new Range struct field names in .NET: Start/End. original author: @michael-hawker
diff --git a/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/RangeSelector/RangeSelectorCode.bind b/Microsoft.Toolkit.Uwp.SampleApp/SamplePages/RangeSelector/RangeSelectorCode.bind
@@ -21,7 +21,7 @@
       <TextBlock Grid.Column="0"
                  HorizontalAlignment="Left"
                  VerticalAlignment="Center"
-                 Text="{Binding RangeMin, ElementName=RangeSelectorControl, Converter={StaticResource StringFormatConverter}, ConverterParameter='{}{0:0.##}'}" />
+                 Text="{Binding RangeStart, ElementName=RangeSelectorControl, Converter={StaticResource StringFormatConverter}, ConverterParameter='{}{0:0.##}'}" />
       <controls:RangeSelector x:Name="RangeSelectorControl"
                               Grid.Column="1"
                               Minimum="@[Minimum:Slider:0:0-100]@"
@@ -30,7 +30,7 @@
       <TextBlock Grid.Column="2"
                  HorizontalAlignment="Right"
                  VerticalAlignment="Center"
-                 Text="{Binding RangeMax, ElementName=RangeSelectorControl, Converter={StaticResource StringFormatConverter}, ConverterParameter='{}{0:0.##}'}" />
+                 Text="{Binding RangeEnd, ElementName=RangeSelectorControl, Converter={StaticResource StringFormatConverter}, ConverterParameter='{}{0:0.##}'}" />
     </Grid>
   </Grid>
 </Page>
diff --git a/Microsoft.Toolkit.Uwp.UI.Controls.Input/RangeSelector/RangeSelector.Input.Drag.cs b/Microsoft.Toolkit.Uwp.UI.Controls.Input/RangeSelector/RangeSelector.Input.Drag.cs
@@ -19,23 +19,23 @@ private void MinThumb_DragDelta(object sender, DragDeltaEventArgs e)
         {
             _absolutePosition += e.HorizontalChange;
 
-            RangeMin = DragThumb(_minThumb, 0, Canvas.GetLeft(_maxThumb), _absolutePosition);
+            RangeStart = DragThumb(_minThumb, 0, Canvas.GetLeft(_maxThumb), _absolutePosition);
 
             if (_toolTipText != null)
             {
-                UpdateToolTipText(this, _toolTipText, RangeMin);
+                UpdateToolTipText(this, _toolTipText, RangeStart);
             }
         }
 
         private void MaxThumb_DragDelta(object sender, DragDeltaEventArgs e)
         {
             _absolutePosition += e.HorizontalChange;
 
-            RangeMax = DragThumb(_maxThumb, Canvas.GetLeft(_minThumb), DragWidth(), _absolutePosition);
+            RangeEnd = DragThumb(_maxThumb, Canvas.GetLeft(_minThumb), DragWidth(), _absolutePosition);
 
             if (_toolTipText != null)
             {
-                UpdateToolTipText(this, _toolTipText, RangeMax);
+                UpdateToolTipText(this, _toolTipText, RangeEnd);
             }
         }
 
@@ -54,7 +54,7 @@ private void MaxThumb_DragStarted(object sender, DragStartedEventArgs e)
         private void Thumb_DragCompleted(object sender, DragCompletedEventArgs e)
         {
             OnThumbDragCompleted(e);
-            OnValueChanged(sender.Equals(_minThumb) ? new RangeChangedEventArgs(_oldValue, RangeMin, RangeSelectorProperty.MinimumValue) : new RangeChangedEventArgs(_oldValue, RangeMax, RangeSelectorProperty.MaximumValue));
+            OnValueChanged(sender.Equals(_minThumb) ? new RangeChangedEventArgs(_oldValue, RangeStart, RangeSelectorProperty.MinimumValue) : new RangeChangedEventArgs(_oldValue, RangeEnd, RangeSelectorProperty.MaximumValue));
             SyncThumbs();
 
             if (_toolTip != null)
@@ -97,7 +97,7 @@ private void Thumb_DragStarted(Thumb thumb)
             _absolutePosition = Canvas.GetLeft(thumb);
             Canvas.SetZIndex(thumb, 10);
             Canvas.SetZIndex(otherThumb, 0);
-            _oldValue = RangeMin;
+            _oldValue = RangeStart;
 
             if (_toolTipText != null && _toolTip != null)
             {
@@ -107,7 +107,7 @@ private void Thumb_DragStarted(Thumb thumb)
                 var ttWidth = _toolTip.ActualWidth / 2;
                 Canvas.SetLeft(_toolTip, thumbCenter - ttWidth);
 
-                UpdateToolTipText(this, _toolTipText, useMin ? RangeMin : RangeMax);
+                UpdateToolTipText(this, _toolTipText, useMin ? RangeStart : RangeEnd);
             }
 
             VisualStateManager.GoToState(this, useMin ? "MinPressed" : "MaxPressed", true);
diff --git a/Microsoft.Toolkit.Uwp.UI.Controls.Input/RangeSelector/RangeSelector.Input.Key.cs b/Microsoft.Toolkit.Uwp.UI.Controls.Input/RangeSelector/RangeSelector.Input.Key.cs
@@ -22,7 +22,7 @@ private void MinThumb_KeyDown(object sender, KeyRoutedEventArgs e)
             switch (e.Key)
             {
                 case VirtualKey.Left:
-                    RangeMin -= StepFrequency;
+                    RangeStart -= StepFrequency;
                     SyncThumbs(fromMinKeyDown: true);
                     if (_toolTip != null)
                     {
@@ -32,7 +32,7 @@ private void MinThumb_KeyDown(object sender, KeyRoutedEventArgs e)
                     e.Handled = true;
                     break;
                 case VirtualKey.Right:
-                    RangeMin += StepFrequency;
+                    RangeStart += StepFrequency;
                     SyncThumbs(fromMinKeyDown: true);
                     if (_toolTip != null)
                     {
@@ -49,7 +49,7 @@ private void MaxThumb_KeyDown(object sender, KeyRoutedEventArgs e)
             switch (e.Key)
             {
                 case VirtualKey.Left:
-                    RangeMax -= StepFrequency;
+                    RangeEnd -= StepFrequency;
                     SyncThumbs(fromMaxKeyDown: true);
                     if (_toolTip != null)
                     {
@@ -59,7 +59,7 @@ private void MaxThumb_KeyDown(object sender, KeyRoutedEventArgs e)
                     e.Handled = true;
                     break;
                 case VirtualKey.Right:
-                    RangeMax += StepFrequency;
+                    RangeEnd += StepFrequency;
                     SyncThumbs(fromMaxKeyDown: true);
                     if (_toolTip != null)
                     {
diff --git a/Microsoft.Toolkit.Uwp.UI.Controls.Input/RangeSelector/RangeSelector.Input.Pointer.cs b/Microsoft.Toolkit.Uwp.UI.Controls.Input/RangeSelector/RangeSelector.Input.Pointer.cs
@@ -33,13 +33,13 @@ private void ContainerCanvas_PointerExited(object sender, PointerRoutedEventArgs
             {
                 _pointerManipulatingMin = false;
                 _containerCanvas.IsHitTestVisible = true;
-                OnValueChanged(new RangeChangedEventArgs(RangeMin, normalizedPosition, RangeSelectorProperty.MinimumValue));
+                OnValueChanged(new RangeChangedEventArgs(RangeStart, normalizedPosition, RangeSelectorProperty.MinimumValue));
             }
             else if (_pointerManipulatingMax)
             {
                 _pointerManipulatingMax = false;
                 _containerCanvas.IsHitTestVisible = true;
-                OnValueChanged(new RangeChangedEventArgs(RangeMax, normalizedPosition, RangeSelectorProperty.MaximumValue));
+                OnValueChanged(new RangeChangedEventArgs(RangeEnd, normalizedPosition, RangeSelectorProperty.MaximumValue));
             }
 
             if (_toolTip != null)
@@ -59,13 +59,13 @@ private void ContainerCanvas_PointerReleased(object sender, PointerRoutedEventAr
             {
                 _pointerManipulatingMin = false;
                 _containerCanvas.IsHitTestVisible = true;
-                OnValueChanged(new RangeChangedEventArgs(RangeMin, normalizedPosition, RangeSelectorProperty.MinimumValue));
+                OnValueChanged(new RangeChangedEventArgs(RangeStart, normalizedPosition, RangeSelectorProperty.MinimumValue));
             }
             else if (_pointerManipulatingMax)
             {
                 _pointerManipulatingMax = false;
                 _containerCanvas.IsHitTestVisible = true;
-                OnValueChanged(new RangeChangedEventArgs(RangeMax, normalizedPosition, RangeSelectorProperty.MaximumValue));
+                OnValueChanged(new RangeChangedEventArgs(RangeEnd, normalizedPosition, RangeSelectorProperty.MaximumValue));
             }
 
             SyncThumbs();
@@ -81,34 +81,34 @@ private void ContainerCanvas_PointerMoved(object sender, PointerRoutedEventArgs
             var position = e.GetCurrentPoint(_containerCanvas).Position.X;
             var normalizedPosition = ((position / DragWidth()) * (Maximum - Minimum)) + Minimum;
 
-            if (_pointerManipulatingMin && normalizedPosition < RangeMax)
+            if (_pointerManipulatingMin && normalizedPosition < RangeEnd)
             {
-                RangeMin = DragThumb(_minThumb, 0, Canvas.GetLeft(_maxThumb), position);
-                UpdateToolTipText(this, _toolTipText, RangeMin);
+                RangeStart = DragThumb(_minThumb, 0, Canvas.GetLeft(_maxThumb), position);
+                UpdateToolTipText(this, _toolTipText, RangeStart);
             }
-            else if (_pointerManipulatingMax && normalizedPosition > RangeMin)
+            else if (_pointerManipulatingMax && normalizedPosition > RangeStart)
             {
-                RangeMax = DragThumb(_maxThumb, Canvas.GetLeft(_minThumb), DragWidth(), position);
-                UpdateToolTipText(this, _toolTipText, RangeMax);
+                RangeEnd = DragThumb(_maxThumb, Canvas.GetLeft(_minThumb), DragWidth(), position);
+                UpdateToolTipText(this, _toolTipText, RangeEnd);
             }
         }
 
         private void ContainerCanvas_PointerPressed(object sender, PointerRoutedEventArgs e)
         {
             var position = e.GetCurrentPoint(_containerCanvas).Position.X;
             var normalizedPosition = position * Math.Abs(Maximum - Minimum) / DragWidth();
-            double upperValueDiff = Math.Abs(RangeMax - normalizedPosition);
-            double lowerValueDiff = Math.Abs(RangeMin - normalizedPosition);
+            double upperValueDiff = Math.Abs(RangeEnd - normalizedPosition);
+            double lowerValueDiff = Math.Abs(RangeStart - normalizedPosition);
 
             if (upperValueDiff < lowerValueDiff)
             {
-                RangeMax = normalizedPosition;
+                RangeEnd = normalizedPosition;
                 _pointerManipulatingMax = true;
                 Thumb_DragStarted(_maxThumb);
             }
             else
             {
-                RangeMin = normalizedPosition;
+                RangeStart = normalizedPosition;
                 _pointerManipulatingMin = true;
                 Thumb_DragStarted(_minThumb);
             }
diff --git a/Microsoft.Toolkit.Uwp.UI.Controls.Input/RangeSelector/RangeSelector.Properties.cs b/Microsoft.Toolkit.Uwp.UI.Controls.Input/RangeSelector/RangeSelector.Properties.cs
@@ -13,7 +13,7 @@ namespace Microsoft.Toolkit.Uwp.UI.Controls
     public partial class RangeSelector : Control
     {
         /// <summary>
-        /// Identifies the Minimum dependency property.
+        /// Identifies the <see cref="Minimum"/> property.
         /// </summary>
         public static readonly DependencyProperty MinimumProperty =
             DependencyProperty.Register(
@@ -23,7 +23,7 @@ public partial class RangeSelector : Control
                 new PropertyMetadata(DefaultMinimum, MinimumChangedCallback));
 
         /// <summary>
-        /// Identifies the Maximum dependency property.
+        /// Identifies the <see cref="Maximum"/> property.
         /// </summary>
         public static readonly DependencyProperty MaximumProperty =
             DependencyProperty.Register(
@@ -33,27 +33,27 @@ public partial class RangeSelector : Control
                 new PropertyMetadata(DefaultMaximum, MaximumChangedCallback));
 
         /// <summary>
-        /// Identifies the RangeMin dependency property.
+        /// Identifies the <see cref="RangeStart"/> property.
         /// </summary>
-        public static readonly DependencyProperty RangeMinProperty =
+        public static readonly DependencyProperty RangeStartProperty =
             DependencyProperty.Register(
-                nameof(RangeMin),
+                nameof(RangeStart),
                 typeof(double),
                 typeof(RangeSelector),
                 new PropertyMetadata(DefaultMinimum, RangeMinChangedCallback));
 
         /// <summary>
-        /// Identifies the RangeMax dependency property.
+        /// Identifies the <see cref="RangeEnd"/> property.
         /// </summary>
-        public static readonly DependencyProperty RangeMaxProperty =
+        public static readonly DependencyProperty RangeEndProperty =
             DependencyProperty.Register(
-                nameof(RangeMax),
+                nameof(RangeEnd),
                 typeof(double),
                 typeof(RangeSelector),
                 new PropertyMetadata(DefaultMaximum, RangeMaxChangedCallback));
 
         /// <summary>
-        /// Identifies the StepFrequency dependency property.
+        /// Identifies the <see cref="StepFrequency"/> property.
         /// </summary>
         public static readonly DependencyProperty StepFrequencyProperty =
             DependencyProperty.Register(
@@ -63,7 +63,7 @@ public partial class RangeSelector : Control
                 new PropertyMetadata(DefaultStepFrequency));
 
         /// <summary>
-        /// Gets or sets the minimum value of the range.
+        /// Gets or sets the absolute minimum value of the range.
         /// </summary>
         /// <value>
         /// The minimum.
@@ -75,7 +75,7 @@ public double Minimum
         }
 
         /// <summary>
-        /// Gets or sets the maximum value of the range.
+        /// Gets or sets the absolute maximum value of the range.
         /// </summary>
         /// <value>
         /// The maximum.
@@ -87,27 +87,27 @@ public double Maximum
         }
 
         /// <summary>
-        /// Gets or sets the current lower limit value of the range.
+        /// Gets or sets the current selected lower limit value of the range, modifiable by the user.
         /// </summary>
         /// <value>
         /// The current lower limit.
         /// </value>
-        public double RangeMin
+        public double RangeStart
         {
-            get => (double)GetValue(RangeMinProperty);
-            set => SetValue(RangeMinProperty, value);
+            get => (double)GetValue(RangeStartProperty);
+            set => SetValue(RangeStartProperty, value);
         }
 
         /// <summary>
-        /// Gets or sets the current upper limit value of the range.
+        /// Gets or sets the current selected upper limit value of the range, modifiable by the user.
         /// </summary>
         /// <value>
         /// The current upper limit.
         /// </value>
-        public double RangeMax
+        public double RangeEnd
         {
-            get => (double)GetValue(RangeMaxProperty);
-            set => SetValue(RangeMaxProperty, value);
+            get => (double)GetValue(RangeEndProperty);
+            set => SetValue(RangeEndProperty, value);
         }
 
         /// <summary>
@@ -139,14 +139,14 @@ private static void MinimumChangedCallback(DependencyObject d, DependencyPropert
                 rangeSelector.Maximum = newValue + Epsilon;
             }
 
-            if (rangeSelector.RangeMin < newValue)
+            if (rangeSelector.RangeStart < newValue)
             {
-                rangeSelector.RangeMin = newValue;
+                rangeSelector.RangeStart = newValue;
             }
 
-            if (rangeSelector.RangeMax < newValue)
+            if (rangeSelector.RangeEnd < newValue)
             {
-                rangeSelector.RangeMax = newValue;
+                rangeSelector.RangeEnd = newValue;
             }
 
             if (newValue != oldValue)
@@ -172,14 +172,14 @@ private static void MaximumChangedCallback(DependencyObject d, DependencyPropert
                 rangeSelector.Minimum = newValue - Epsilon;
             }
 
-            if (rangeSelector.RangeMax > newValue)
+            if (rangeSelector.RangeEnd > newValue)
             {
-                rangeSelector.RangeMax = newValue;
+                rangeSelector.RangeEnd = newValue;
             }
 
-            if (rangeSelector.RangeMin > newValue)
+            if (rangeSelector.RangeStart > newValue)
             {
-                rangeSelector.RangeMin = newValue;
+                rangeSelector.RangeStart = newValue;
             }
 
             if (newValue != oldValue)
@@ -211,19 +211,19 @@ private static void RangeMinChangedCallback(DependencyObject d, DependencyProper
             {
                 if (newValue < rangeSelector.Minimum)
                 {
-                    rangeSelector.RangeMin = rangeSelector.Minimum;
+                    rangeSelector.RangeStart = rangeSelector.Minimum;
                 }
                 else if (newValue > rangeSelector.Maximum)
                 {
-                    rangeSelector.RangeMin = rangeSelector.Maximum;
+                    rangeSelector.RangeStart = rangeSelector.Maximum;
                 }
 
                 rangeSelector.SyncActiveRectangle();
 
                 // If the new value is greater than the old max, move the max also
-                if (newValue > rangeSelector.RangeMax)
+                if (newValue > rangeSelector.RangeEnd)
                 {
-                    rangeSelector.RangeMax = newValue;
+                    rangeSelector.RangeEnd = newValue;
                 }
             }
 
@@ -253,19 +253,19 @@ private static void RangeMaxChangedCallback(DependencyObject d, DependencyProper
             {
                 if (newValue < rangeSelector.Minimum)
                 {
-                    rangeSelector.RangeMax = rangeSelector.Minimum;
+                    rangeSelector.RangeEnd = rangeSelector.Minimum;
                 }
                 else if (newValue > rangeSelector.Maximum)
                 {
-                    rangeSelector.RangeMax = rangeSelector.Maximum;
+                    rangeSelector.RangeEnd = rangeSelector.Maximum;
                 }
 
                 rangeSelector.SyncActiveRectangle();
 
                 // If the new max is less than the old minimum then move the minimum
-                if (newValue < rangeSelector.RangeMin)
+                if (newValue < rangeSelector.RangeStart)
                 {
-                    rangeSelector.RangeMin = newValue;
+                    rangeSelector.RangeStart = newValue;
                 }
             }
 
diff --git a/Microsoft.Toolkit.Uwp.UI.Controls.Input/RangeSelector/RangeSelector.cs b/Microsoft.Toolkit.Uwp.UI.Controls.Input/RangeSelector/RangeSelector.cs

Original file line number	Diff line number	Diff line change
`@@ -19,23 +19,23 @@ private void MinThumb_DragDelta(object sender, DragDeltaEventArgs e)`
`19`	`19`	`{`
`20`	`20`	`_absolutePosition += e.HorizontalChange;`
`21`	`21`
`22`		`- RangeMin = DragThumb(_minThumb, 0, Canvas.GetLeft(_maxThumb), _absolutePosition);`
	`22`	`+ RangeStart = DragThumb(_minThumb, 0, Canvas.GetLeft(_maxThumb), _absolutePosition);`
`23`	`23`
`24`	`24`	`if (_toolTipText != null)`
`25`	`25`	`{`
`26`		`- UpdateToolTipText(this, _toolTipText, RangeMin);`
	`26`	`+ UpdateToolTipText(this, _toolTipText, RangeStart);`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`private void MaxThumb_DragDelta(object sender, DragDeltaEventArgs e)`
`31`	`31`	`{`
`32`	`32`	`_absolutePosition += e.HorizontalChange;`
`33`	`33`
`34`		`- RangeMax = DragThumb(_maxThumb, Canvas.GetLeft(_minThumb), DragWidth(), _absolutePosition);`
	`34`	`+ RangeEnd = DragThumb(_maxThumb, Canvas.GetLeft(_minThumb), DragWidth(), _absolutePosition);`
`35`	`35`
`36`	`36`	`if (_toolTipText != null)`
`37`	`37`	`{`
`38`		`- UpdateToolTipText(this, _toolTipText, RangeMax);`
	`38`	`+ UpdateToolTipText(this, _toolTipText, RangeEnd);`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`@@ -54,7 +54,7 @@ private void MaxThumb_DragStarted(object sender, DragStartedEventArgs e)`
`54`	`54`	`private void Thumb_DragCompleted(object sender, DragCompletedEventArgs e)`
`55`	`55`	`{`
`56`	`56`	`OnThumbDragCompleted(e);`
`57`		`- OnValueChanged(sender.Equals(_minThumb) ? new RangeChangedEventArgs(_oldValue, RangeMin, RangeSelectorProperty.MinimumValue) : new RangeChangedEventArgs(_oldValue, RangeMax, RangeSelectorProperty.MaximumValue));`
	`57`	`+ OnValueChanged(sender.Equals(_minThumb) ? new RangeChangedEventArgs(_oldValue, RangeStart, RangeSelectorProperty.MinimumValue) : new RangeChangedEventArgs(_oldValue, RangeEnd, RangeSelectorProperty.MaximumValue));`
`58`	`58`	`SyncThumbs();`
`59`	`59`
`60`	`60`	`if (_toolTip != null)`
`@@ -97,7 +97,7 @@ private void Thumb_DragStarted(Thumb thumb)`
`97`	`97`	`_absolutePosition = Canvas.GetLeft(thumb);`
`98`	`98`	`Canvas.SetZIndex(thumb, 10);`
`99`	`99`	`Canvas.SetZIndex(otherThumb, 0);`
`100`		`- _oldValue = RangeMin;`
	`100`	`+ _oldValue = RangeStart;`
`101`	`101`
`102`	`102`	`if (_toolTipText != null && _toolTip != null)`
`103`	`103`	`{`
`@@ -107,7 +107,7 @@ private void Thumb_DragStarted(Thumb thumb)`
`107`	`107`	`var ttWidth = _toolTip.ActualWidth / 2;`
`108`	`108`	`Canvas.SetLeft(_toolTip, thumbCenter - ttWidth);`
`109`	`109`
`110`		`- UpdateToolTipText(this, _toolTipText, useMin ? RangeMin : RangeMax);`
	`110`	`+ UpdateToolTipText(this, _toolTipText, useMin ? RangeStart : RangeEnd);`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`VisualStateManager.GoToState(this, useMin ? "MinPressed" : "MaxPressed", true);`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ private void MinThumb_KeyDown(object sender, KeyRoutedEventArgs e)`
`22`	`22`	`switch (e.Key)`
`23`	`23`	`{`
`24`	`24`	`case VirtualKey.Left:`
`25`		`- RangeMin -= StepFrequency;`
	`25`	`+ RangeStart -= StepFrequency;`
`26`	`26`	`SyncThumbs(fromMinKeyDown: true);`
`27`	`27`	`if (_toolTip != null)`
`28`	`28`	`{`
`@@ -32,7 +32,7 @@ private void MinThumb_KeyDown(object sender, KeyRoutedEventArgs e)`
`32`	`32`	`e.Handled = true;`
`33`	`33`	`break;`
`34`	`34`	`case VirtualKey.Right:`
`35`		`- RangeMin += StepFrequency;`
	`35`	`+ RangeStart += StepFrequency;`
`36`	`36`	`SyncThumbs(fromMinKeyDown: true);`
`37`	`37`	`if (_toolTip != null)`
`38`	`38`	`{`
`@@ -49,7 +49,7 @@ private void MaxThumb_KeyDown(object sender, KeyRoutedEventArgs e)`
`49`	`49`	`switch (e.Key)`
`50`	`50`	`{`
`51`	`51`	`case VirtualKey.Left:`
`52`		`- RangeMax -= StepFrequency;`
	`52`	`+ RangeEnd -= StepFrequency;`
`53`	`53`	`SyncThumbs(fromMaxKeyDown: true);`
`54`	`54`	`if (_toolTip != null)`
`55`	`55`	`{`
`@@ -59,7 +59,7 @@ private void MaxThumb_KeyDown(object sender, KeyRoutedEventArgs e)`
`59`	`59`	`e.Handled = true;`
`60`	`60`	`break;`
`61`	`61`	`case VirtualKey.Right:`
`62`		`- RangeMax += StepFrequency;`
	`62`	`+ RangeEnd += StepFrequency;`
`63`	`63`	`SyncThumbs(fromMaxKeyDown: true);`
`64`	`64`	`if (_toolTip != null)`
`65`	`65`	`{`
Original file line number	Diff line number	Diff line change
`@@ -33,13 +33,13 @@ private void ContainerCanvas_PointerExited(object sender, PointerRoutedEventArgs`
`33`	`33`	`{`
`34`	`34`	`_pointerManipulatingMin = false;`
`35`	`35`	`_containerCanvas.IsHitTestVisible = true;`
`36`		`- OnValueChanged(new RangeChangedEventArgs(RangeMin, normalizedPosition, RangeSelectorProperty.MinimumValue));`
	`36`	`+ OnValueChanged(new RangeChangedEventArgs(RangeStart, normalizedPosition, RangeSelectorProperty.MinimumValue));`
`37`	`37`	`}`
`38`	`38`	`else if (_pointerManipulatingMax)`
`39`	`39`	`{`
`40`	`40`	`_pointerManipulatingMax = false;`
`41`	`41`	`_containerCanvas.IsHitTestVisible = true;`
`42`		`- OnValueChanged(new RangeChangedEventArgs(RangeMax, normalizedPosition, RangeSelectorProperty.MaximumValue));`
	`42`	`+ OnValueChanged(new RangeChangedEventArgs(RangeEnd, normalizedPosition, RangeSelectorProperty.MaximumValue));`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`if (_toolTip != null)`
`@@ -59,13 +59,13 @@ private void ContainerCanvas_PointerReleased(object sender, PointerRoutedEventAr`
`59`	`59`	`{`
`60`	`60`	`_pointerManipulatingMin = false;`
`61`	`61`	`_containerCanvas.IsHitTestVisible = true;`
`62`		`- OnValueChanged(new RangeChangedEventArgs(RangeMin, normalizedPosition, RangeSelectorProperty.MinimumValue));`
	`62`	`+ OnValueChanged(new RangeChangedEventArgs(RangeStart, normalizedPosition, RangeSelectorProperty.MinimumValue));`
`63`	`63`	`}`
`64`	`64`	`else if (_pointerManipulatingMax)`
`65`	`65`	`{`
`66`	`66`	`_pointerManipulatingMax = false;`
`67`	`67`	`_containerCanvas.IsHitTestVisible = true;`
`68`		`- OnValueChanged(new RangeChangedEventArgs(RangeMax, normalizedPosition, RangeSelectorProperty.MaximumValue));`
	`68`	`+ OnValueChanged(new RangeChangedEventArgs(RangeEnd, normalizedPosition, RangeSelectorProperty.MaximumValue));`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`SyncThumbs();`
`@@ -81,34 +81,34 @@ private void ContainerCanvas_PointerMoved(object sender, PointerRoutedEventArgs`
`81`	`81`	`var position = e.GetCurrentPoint(_containerCanvas).Position.X;`
`82`	`82`	`var normalizedPosition = ((position / DragWidth()) * (Maximum - Minimum)) + Minimum;`
`83`	`83`
`84`		`- if (_pointerManipulatingMin && normalizedPosition < RangeMax)`
	`84`	`+ if (_pointerManipulatingMin && normalizedPosition < RangeEnd)`
`85`	`85`	`{`
`86`		`- RangeMin = DragThumb(_minThumb, 0, Canvas.GetLeft(_maxThumb), position);`
`87`		`- UpdateToolTipText(this, _toolTipText, RangeMin);`
	`86`	`+ RangeStart = DragThumb(_minThumb, 0, Canvas.GetLeft(_maxThumb), position);`
	`87`	`+ UpdateToolTipText(this, _toolTipText, RangeStart);`
`88`	`88`	`}`
`89`		`- else if (_pointerManipulatingMax && normalizedPosition > RangeMin)`
	`89`	`+ else if (_pointerManipulatingMax && normalizedPosition > RangeStart)`
`90`	`90`	`{`
`91`		`- RangeMax = DragThumb(_maxThumb, Canvas.GetLeft(_minThumb), DragWidth(), position);`
`92`		`- UpdateToolTipText(this, _toolTipText, RangeMax);`
	`91`	`+ RangeEnd = DragThumb(_maxThumb, Canvas.GetLeft(_minThumb), DragWidth(), position);`
	`92`	`+ UpdateToolTipText(this, _toolTipText, RangeEnd);`
`93`	`93`	`}`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`private void ContainerCanvas_PointerPressed(object sender, PointerRoutedEventArgs e)`
`97`	`97`	`{`
`98`	`98`	`var position = e.GetCurrentPoint(_containerCanvas).Position.X;`
`99`	`99`	`var normalizedPosition = position * Math.Abs(Maximum - Minimum) / DragWidth();`
`100`		`- double upperValueDiff = Math.Abs(RangeMax - normalizedPosition);`
`101`		`- double lowerValueDiff = Math.Abs(RangeMin - normalizedPosition);`
	`100`	`+ double upperValueDiff = Math.Abs(RangeEnd - normalizedPosition);`
	`101`	`+ double lowerValueDiff = Math.Abs(RangeStart - normalizedPosition);`
`102`	`102`
`103`	`103`	`if (upperValueDiff < lowerValueDiff)`
`104`	`104`	`{`
`105`		`- RangeMax = normalizedPosition;`
	`105`	`+ RangeEnd = normalizedPosition;`
`106`	`106`	`_pointerManipulatingMax = true;`
`107`	`107`	`Thumb_DragStarted(_maxThumb);`
`108`	`108`	`}`
`109`	`109`	`else`
`110`	`110`	`{`
`111`		`- RangeMin = normalizedPosition;`
	`111`	`+ RangeStart = normalizedPosition;`
`112`	`112`	`_pointerManipulatingMin = true;`
`113`	`113`	`Thumb_DragStarted(_minThumb);`
`114`	`114`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ namespace Microsoft.Toolkit.Uwp.UI.Controls`
`13`	`13`	`public partial class RangeSelector : Control`
`14`	`14`	`{`
`15`	`15`	`/// <summary>`
`16`		`- /// Identifies the Minimum dependency property.`
	`16`	`+ /// Identifies the <see cref="Minimum"/> property.`
`17`	`17`	`/// </summary>`
`18`	`18`	`public static readonly DependencyProperty MinimumProperty =`
`19`	`19`	`DependencyProperty.Register(`
`@@ -23,7 +23,7 @@ public partial class RangeSelector : Control`
`23`	`23`	`new PropertyMetadata(DefaultMinimum, MinimumChangedCallback));`
`24`	`24`
`25`	`25`	`/// <summary>`
`26`		`- /// Identifies the Maximum dependency property.`
	`26`	`+ /// Identifies the <see cref="Maximum"/> property.`
`27`	`27`	`/// </summary>`
`28`	`28`	`public static readonly DependencyProperty MaximumProperty =`
`29`	`29`	`DependencyProperty.Register(`
`@@ -33,27 +33,27 @@ public partial class RangeSelector : Control`
`33`	`33`	`new PropertyMetadata(DefaultMaximum, MaximumChangedCallback));`
`34`	`34`
`35`	`35`	`/// <summary>`
`36`		`- /// Identifies the RangeMin dependency property.`
	`36`	`+ /// Identifies the <see cref="RangeStart"/> property.`
`37`	`37`	`/// </summary>`
`38`		`- public static readonly DependencyProperty RangeMinProperty =`
	`38`	`+ public static readonly DependencyProperty RangeStartProperty =`
`39`	`39`	`DependencyProperty.Register(`
`40`		`- nameof(RangeMin),`
	`40`	`+ nameof(RangeStart),`
`41`	`41`	`typeof(double),`
`42`	`42`	`typeof(RangeSelector),`
`43`	`43`	`new PropertyMetadata(DefaultMinimum, RangeMinChangedCallback));`
`44`	`44`
`45`	`45`	`/// <summary>`
`46`		`- /// Identifies the RangeMax dependency property.`
	`46`	`+ /// Identifies the <see cref="RangeEnd"/> property.`
`47`	`47`	`/// </summary>`
`48`		`- public static readonly DependencyProperty RangeMaxProperty =`
	`48`	`+ public static readonly DependencyProperty RangeEndProperty =`
`49`	`49`	`DependencyProperty.Register(`
`50`		`- nameof(RangeMax),`
	`50`	`+ nameof(RangeEnd),`
`51`	`51`	`typeof(double),`
`52`	`52`	`typeof(RangeSelector),`
`53`	`53`	`new PropertyMetadata(DefaultMaximum, RangeMaxChangedCallback));`
`54`	`54`
`55`	`55`	`/// <summary>`
`56`		`- /// Identifies the StepFrequency dependency property.`
	`56`	`+ /// Identifies the <see cref="StepFrequency"/> property.`
`57`	`57`	`/// </summary>`
`58`	`58`	`public static readonly DependencyProperty StepFrequencyProperty =`
`59`	`59`	`DependencyProperty.Register(`
`@@ -63,7 +63,7 @@ public partial class RangeSelector : Control`
`63`	`63`	`new PropertyMetadata(DefaultStepFrequency));`
`64`	`64`
`65`	`65`	`/// <summary>`
`66`		`- /// Gets or sets the minimum value of the range.`
	`66`	`+ /// Gets or sets the absolute minimum value of the range.`
`67`	`67`	`/// </summary>`
`68`	`68`	`/// <value>`
`69`	`69`	`/// The minimum.`
`@@ -75,7 +75,7 @@ public double Minimum`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`/// <summary>`
`78`		`- /// Gets or sets the maximum value of the range.`
	`78`	`+ /// Gets or sets the absolute maximum value of the range.`
`79`	`79`	`/// </summary>`
`80`	`80`	`/// <value>`
`81`	`81`	`/// The maximum.`
`@@ -87,27 +87,27 @@ public double Maximum`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`/// <summary>`
`90`		`- /// Gets or sets the current lower limit value of the range.`
	`90`	`+ /// Gets or sets the current selected lower limit value of the range, modifiable by the user.`
`91`	`91`	`/// </summary>`
`92`	`92`	`/// <value>`
`93`	`93`	`/// The current lower limit.`
`94`	`94`	`/// </value>`
`95`		`- public double RangeMin`
	`95`	`+ public double RangeStart`
`96`	`96`	`{`
`97`		`- get => (double)GetValue(RangeMinProperty);`
`98`		`- set => SetValue(RangeMinProperty, value);`
	`97`	`+ get => (double)GetValue(RangeStartProperty);`
	`98`	`+ set => SetValue(RangeStartProperty, value);`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`/// <summary>`
`102`		`- /// Gets or sets the current upper limit value of the range.`
	`102`	`+ /// Gets or sets the current selected upper limit value of the range, modifiable by the user.`
`103`	`103`	`/// </summary>`
`104`	`104`	`/// <value>`
`105`	`105`	`/// The current upper limit.`
`106`	`106`	`/// </value>`
`107`		`- public double RangeMax`
	`107`	`+ public double RangeEnd`
`108`	`108`	`{`
`109`		`- get => (double)GetValue(RangeMaxProperty);`
`110`		`- set => SetValue(RangeMaxProperty, value);`
	`109`	`+ get => (double)GetValue(RangeEndProperty);`
	`110`	`+ set => SetValue(RangeEndProperty, value);`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`/// <summary>`
`@@ -139,14 +139,14 @@ private static void MinimumChangedCallback(DependencyObject d, DependencyPropert`
`139`	`139`	`rangeSelector.Maximum = newValue + Epsilon;`
`140`	`140`	`}`
`141`	`141`
`142`		`- if (rangeSelector.RangeMin < newValue)`
	`142`	`+ if (rangeSelector.RangeStart < newValue)`
`143`	`143`	`{`
`144`		`- rangeSelector.RangeMin = newValue;`
	`144`	`+ rangeSelector.RangeStart = newValue;`
`145`	`145`	`}`
`146`	`146`
`147`		`- if (rangeSelector.RangeMax < newValue)`
	`147`	`+ if (rangeSelector.RangeEnd < newValue)`
`148`	`148`	`{`
`149`		`- rangeSelector.RangeMax = newValue;`
	`149`	`+ rangeSelector.RangeEnd = newValue;`
`150`	`150`	`}`
`151`	`151`
`152`	`152`	`if (newValue != oldValue)`
`@@ -172,14 +172,14 @@ private static void MaximumChangedCallback(DependencyObject d, DependencyPropert`
`172`	`172`	`rangeSelector.Minimum = newValue - Epsilon;`
`173`	`173`	`}`
`174`	`174`
`175`		`- if (rangeSelector.RangeMax > newValue)`
	`175`	`+ if (rangeSelector.RangeEnd > newValue)`
`176`	`176`	`{`
`177`		`- rangeSelector.RangeMax = newValue;`
	`177`	`+ rangeSelector.RangeEnd = newValue;`
`178`	`178`	`}`
`179`	`179`
`180`		`- if (rangeSelector.RangeMin > newValue)`
	`180`	`+ if (rangeSelector.RangeStart > newValue)`
`181`	`181`	`{`
`182`		`- rangeSelector.RangeMin = newValue;`
	`182`	`+ rangeSelector.RangeStart = newValue;`
`183`	`183`	`}`
`184`	`184`
`185`	`185`	`if (newValue != oldValue)`
`@@ -211,19 +211,19 @@ private static void RangeMinChangedCallback(DependencyObject d, DependencyProper`
`211`	`211`	`{`
`212`	`212`	`if (newValue < rangeSelector.Minimum)`
`213`	`213`	`{`
`214`		`- rangeSelector.RangeMin = rangeSelector.Minimum;`
	`214`	`+ rangeSelector.RangeStart = rangeSelector.Minimum;`
`215`	`215`	`}`
`216`	`216`	`else if (newValue > rangeSelector.Maximum)`
`217`	`217`	`{`
`218`		`- rangeSelector.RangeMin = rangeSelector.Maximum;`
	`218`	`+ rangeSelector.RangeStart = rangeSelector.Maximum;`
`219`	`219`	`}`
`220`	`220`
`221`	`221`	`rangeSelector.SyncActiveRectangle();`
`222`	`222`
`223`	`223`	`// If the new value is greater than the old max, move the max also`
`224`		`- if (newValue > rangeSelector.RangeMax)`
	`224`	`+ if (newValue > rangeSelector.RangeEnd)`
`225`	`225`	`{`
`226`		`- rangeSelector.RangeMax = newValue;`
	`226`	`+ rangeSelector.RangeEnd = newValue;`
`227`	`227`	`}`
`228`	`228`	`}`
`229`	`229`
`@@ -253,19 +253,19 @@ private static void RangeMaxChangedCallback(DependencyObject d, DependencyProper`
`253`	`253`	`{`
`254`	`254`	`if (newValue < rangeSelector.Minimum)`
`255`	`255`	`{`
`256`		`- rangeSelector.RangeMax = rangeSelector.Minimum;`
	`256`	`+ rangeSelector.RangeEnd = rangeSelector.Minimum;`
`257`	`257`	`}`
`258`	`258`	`else if (newValue > rangeSelector.Maximum)`
`259`	`259`	`{`
`260`		`- rangeSelector.RangeMax = rangeSelector.Maximum;`
	`260`	`+ rangeSelector.RangeEnd = rangeSelector.Maximum;`
`261`	`261`	`}`
`262`	`262`
`263`	`263`	`rangeSelector.SyncActiveRectangle();`
`264`	`264`
`265`	`265`	`// If the new max is less than the old minimum then move the minimum`
`266`		`- if (newValue < rangeSelector.RangeMin)`
	`266`	`+ if (newValue < rangeSelector.RangeStart)`
`267`	`267`	`{`
`268`		`- rangeSelector.RangeMin = newValue;`
	`268`	`+ rangeSelector.RangeStart = newValue;`
`269`	`269`	`}`
`270`	`270`	`}`
`271`	`271`