Fix: Slider default step causes crash on Windows OS (callstack#260)

* Calculate stepFrequency for default step

The default value of step is set to zero for all platforms.
On Windows OS this approach causes the slider XAML resolution to be at
the level of infinite. Further it causes the application to crash
whenever user tries to move the slider.

To fix that this commit implements the step calculation done when
noticing the default value of <Slider/> to be zero (or zero set by user)
and return the percentage value of Slider's range (from min to max).

* Update README with default step for Windows

Due to changing the behavior of Slider's step for Windows the README
required an update. The description of default step approach mentiones
only the range calculation without the implementation details.

* Change min and max values to doubles

The integer type was previously used for the min and max values of the
Slider on Windows.
This was however changed in the delivery of:
https://github.com/callstack/react-native-slider/pull/259/files
but was partially inverted as the result of rebasing the conflicting
changes.
As the int->double change is good to have and should be kept, this
commit fixes the merge mistake by changing the integer type to double.

Author: BartoszKlonowski

README.md

@@ -178,6 +178,8 @@ Callback continuously called while the user is dragging the slider.
 
 Step value of the slider. The value should be between 0 and (maximumValue - minimumValue). Default value is 0.
 
+On Windows OS the default value is 1% of slider's range (from `minimumValue` to `maximumValue`).
+
 | Type   | Required |
 | ------ | -------- |
 | number | No       |

src/windows/SliderWindows/SliderView.cpp

@@ -96,11 +96,9 @@ namespace winrt::SliderWindows::implementation {
                 if (propertyValue.IsNull()) {
                     this->ClearValue(xaml::Controls::Slider::StepFrequencyProperty());
                 }
-                else if (propertyValue.AsDouble() != 0) {
-                    this->StepFrequency(propertyValue.AsDouble());
-                }
                 else {
-                    this->StepFrequency(c_stepDefault);
+                    auto&& step = CalculateStepFrequencyPercentageValue(propertyValue.AsDouble());
+                    this->StepFrequency(step);
                 }
             }
             else if (propertyName == "inverted") {
@@ -237,4 +235,13 @@ namespace winrt::SliderWindows::implementation {
                 });
         }
     }
+
+    const double SliderView::CalculateStepFrequencyPercentageValue(const double& stepPropertyValue) const noexcept {
+        if (stepPropertyValue != 0) {
+            return stepPropertyValue;
+        }
+        else {
+            return (m_maxValue - m_minValue) / 100.f;
+        }
+    }
 }

src/windows/SliderWindows/SliderView.h

@@ -34,9 +34,11 @@ namespace winrt::SliderWindows::implementation {
         void OnManipulationCompletedHandler(
             winrt::Windows::Foundation::IInspectable const& sender,
             xaml::Input::ManipulationCompletedRoutedEventArgs const& args);
-        
-        double m_value, m_maxValue, m_minValue;
-        const double c_stepDefault = 0.1;
+
+        const double CalculateStepFrequencyPercentageValue(const double& stepPropertyValue) const noexcept;
+
+        double m_maxValue, m_minValue;
+        double m_value;
     };
 }