[RFC PATCH yew-widget-toolkit 1/2] widget: form: number: round floats to nearest step value

[Christoph Heiss <c.heiss@proxmox.com>]

E.g. previously, for an input like

    Number::new()
        .name("some-float")
        .min(0.)
        .step(0.1)
        .submit_empty(false)
        .value(0.2)

and pressing the "range-up" button on the input would result in
0.30000000000000004 - which is rather undesirable.

Fix it by multiplying, rounding and then dividing the number again by
some fixed multiplier - in this case, 100_000 was chosen. Should cover
all realistic cases, as it handles up to five fractional digits, which
for UI purposes should (hopefully!) be plenty enough. And if really
needed, could be increased.

Signed-off-by: Christoph Heiss <c.heiss@proxmox.com>
---
Marked RFC as it may not be necessarily the *best* solution, but by far
the *simplest*. Happy about other solution suggestions, of course.

I also considered other solutions like e.g. doing the rounding
(implicitly) when formatting the number as string above with
`dom::format_float()` - but that solution seemed more like papering over
the symptoms than fixing the root cause.

 src/widget/form/number.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/widget/form/number.rs b/src/widget/form/number.rs
index e5c849c..6db7063 100644
--- a/src/widget/form/number.rs
+++ b/src/widget/form/number.rs
@@ -68,10 +68,14 @@ impl NumberTypeInfo for f64 {
         crate::dom::format_float(*self)
     }
     fn step_up(&self, step: Option<Self>) -> Self {
-        self + step.unwrap_or(1.0)
+        // Do a little dance here to round to the nearest step value, by multiplying,
+        // rounding to the nearest integer and dividing again
+        ((self + step.unwrap_or(1.0)) * 1e5).round() / 1e5
     }
     fn step_down(&self, step: Option<Self>) -> Self {
-        self - step.unwrap_or(1.0)
+        // Do a little dance here to round to the nearest step value, by multiplying,
+        // rounding to the nearest integer and dividing again
+        ((self - step.unwrap_or(1.0)) * 1e5).round() / 1e5
     }
     fn clamp_value(&self, min: Option<Self>, max: Option<Self>) -> Self {
         self.clamp(min.unwrap_or(f64::MIN), max.unwrap_or(f64::MAX))
-- 
2.53.0