Add Minimum and Maximum constraint properties to the PropertySizer control

Author: michael-hawker

Microsoft.Toolkit.Uwp.SampleApp/SamplePages/Sizers/PropertySizer.bind

@@ -42,8 +42,11 @@
                 <ColumnDefinition Width="Auto"/>
                 <ColumnDefinition Width="*"/>
             </Grid.ColumnDefinitions>
+            <!-- Note the use of a TwoWay binding here, this is required for this control to work. -->
             <controls:PropertySizer Binding="{Binding OpenPaneLength, ElementName=ViewPanel, Mode=TwoWay}"
                                     HorizontalAlignment="Left"
+                                    Minimum="52"
+                                    Maximum="440"
                                     Visibility="{Binding IsPaneOpen, ElementName=ViewPanel}"/>
             <!--In An Application, put your host frame here: <Frame Grid.Column="1"/>-->
             <!--Here we show the content as a border for a visual aid -->

Microsoft.Toolkit.Uwp.UI.Controls.Layout/Sizers/PropertySizer/PropertySizer.Events.cs

@@ -20,6 +20,8 @@ public partial class PropertySizer
         /// <inheritdoc/>
         protected override void OnDragStarting()
         {
+            // We grab the current size of the bound value when we start a drag
+            // and we manipulate from that set point.
             if (ReadLocalValue(BindingProperty) != DependencyProperty.UnsetValue)
             {
                 _currentSize = Binding;
@@ -29,31 +31,44 @@ protected override void OnDragStarting()
         /// <inheritdoc/>
         protected override bool OnDragHorizontal(double horizontalChange)
         {
-            horizontalChange = IsDragInverted ? -horizontalChange : horizontalChange;
-
-            // TODO: Setup a Minimum/Maximum properties to constrain bounds
-            ////if (!IsValidWidth(TargetControl, _currentSize + horizontalChange, ActualWidth))
-            ////{
-            ////    return false;
-            ////}
-
-            SetValue(BindingProperty, _currentSize + horizontalChange);
-
-            return true;
+            // We use a central function for both horizontal/vertical as
+            // a general property has no notion of direction when we
+            // manipulate it, so the logic is abstracted.
+            return ApplySizeChange(horizontalChange);
         }
 
         /// <inheritdoc/>
         protected override bool OnDragVertical(double verticalChange)
         {
-            verticalChange = IsDragInverted ? -verticalChange : verticalChange;
+            return ApplySizeChange(verticalChange);
+        }
+
+        private bool ApplySizeChange(double newSize)
+        {
+            newSize = IsDragInverted ? -newSize : newSize;
 
-            ////if (!IsValidHeight(TargetControl, _currentSize + verticalChange, ActualHeight))
-            ////{
-            ////    return false;
-            ////}
+            // We want to be checking the modified final value for bounds checks.
+            newSize += _currentSize;
 
-            SetValue(BindingProperty, _currentSize + verticalChange);
+            // Check if we hit the min/max value, as we should use that if we're on the edge
+            if (ReadLocalValue(MinimumProperty) != DependencyProperty.UnsetValue &&
+                newSize < Minimum)
+            {
+                // We use SetValue here as that'll update our bound property vs. overwriting the binding itself.
+                SetValue(BindingProperty, Minimum);
+            }
+            else if (ReadLocalValue(MaximumProperty) != DependencyProperty.UnsetValue &&
+                newSize > Maximum)
+            {
+                SetValue(BindingProperty, Maximum);
+            }
+            else
+            {
+                // Otherwise, we use the value provided.
+                SetValue(BindingProperty, newSize);
+            }
 
+            // We're always manipulating the value effectively.
             return true;
         }
     }

Microsoft.Toolkit.Uwp.UI.Controls.Layout/Sizers/PropertySizer/PropertySizer.Properties.cs

@@ -28,8 +28,11 @@ public bool IsDragInverted
             DependencyProperty.Register(nameof(IsDragInverted), typeof(bool), typeof(PropertySizer), new PropertyMetadata(false));
 
         /// <summary>
-        /// Gets or sets the binding to a <c>double</c> value that the <see cref="PropertySizer"/> is manipulating.
+        /// Gets or sets a two-way binding to a <c>double</c> value that the <see cref="PropertySizer"/> is manipulating.
         /// </summary>
+        /// <remarks>
+        /// Note that the binding should be configured to be a <c>TwoWay</c> binding in order for the control to notify the source of the changed value.
+        /// </remarks>
         /// <example>
         /// &lt;controls:PropertySizer Binding="{Binding OpenPaneLength, ElementName=ViewPanel, Mode=TwoWay}"&gt;
         /// </example>
@@ -44,5 +47,35 @@ public double Binding
         /// </summary>
         public static readonly DependencyProperty BindingProperty =
             DependencyProperty.Register(nameof(Binding), typeof(double), typeof(PropertySizer), new PropertyMetadata(null));
+
+        /// <summary>
+        /// Gets or sets the minimum allowed value for the <see cref="PropertySizer"/> to allow for the <see cref="Binding"/> value. Ignored if not provided.
+        /// </summary>
+        public double Minimum
+        {
+            get { return (double)GetValue(MinimumProperty); }
+            set { SetValue(MinimumProperty, value); }
+        }
+
+        /// <summary>
+        /// Identifies the <see cref="Minimum"/> dependency property.
+        /// </summary>
+        public static readonly DependencyProperty MinimumProperty =
+            DependencyProperty.Register(nameof(Minimum), typeof(double), typeof(PropertySizer), new PropertyMetadata(0));
+
+        /// <summary>
+        /// Gets or sets the maximum allowed value for the <see cref="PropertySizer"/> to allow for the <see cref="Binding"/> value. Ignored if not provided.
+        /// </summary>
+        public double Maximum
+        {
+            get { return (double)GetValue(MaximumProperty); }
+            set { SetValue(MaximumProperty, value); }
+        }
+
+        /// <summary>
+        /// Identifies the <see cref="Maximum"/> dependency property.
+        /// </summary>
+        public static readonly DependencyProperty MaximumProperty =
+            DependencyProperty.Register(nameof(Maximum), typeof(double), typeof(PropertySizer), new PropertyMetadata(0));
     }
 }