Index: sources/gui/qml/pages/treatment/sections/TreatmentFlowsComponent.qml
===================================================================
diff -u -r271e773cd388dd98dc1342b7865f9e3e8ba30e90 -r863764371ec0a4569403135975a0a3f44e516163
--- sources/gui/qml/pages/treatment/sections/TreatmentFlowsComponent.qml	(.../TreatmentFlowsComponent.qml)	(revision 271e773cd388dd98dc1342b7865f9e3e8ba30e90)
+++ sources/gui/qml/pages/treatment/sections/TreatmentFlowsComponent.qml	(.../TreatmentFlowsComponent.qml)	(revision 863764371ec0a4569403135975a0a3f44e516163)
@@ -16,11 +16,11 @@
     property string title               : ""
     property string unitText            : ""
     property string extraText           : ""
-    property real   value               : undefined
-    property real   precision           : 0
-    property real   minimum             : value
-    property real   maximum             : value
-    property real   step                : 1
+    property alias  value               : _rangedValue.rawValue
+    property alias  minimum             : _rangedValue.rawMin
+    property alias  maximum             : _rangedValue.rawMax
+    property alias  step                : _rangedValue.rawStep
+    property alias  precision           : _rangedValue.precision
     property bool   showButtons         : true
     property bool   buttonsEnabled      : true
     property bool   dropShadowEnabled   : true
@@ -31,60 +31,8 @@
     signal increment(real newValue)
     signal decrement(real newValue)
 
-    QtObject { id: _private
-        // fix floating-point precision issue
-        readonly property int  multiplier   : Math.pow(10, precision)
-        readonly property real stepVal      : calculatePrecisionValue(step)
-        readonly property real minVal       : minimum !== undefined ? calculatePrecisionValue(minimum) : 0
-        readonly property real maxVal       : maximum !== undefined ? calculatePrecisionValue(maximum) : 0
-        readonly property real val          : value   !== undefined ? calculatePrecisionValue(value)   : 0
-
-        readonly property bool canDecrement  : val > calculateMinimum()
-        readonly property bool canIncrement  : val < calculateMaximum()
-
-        // round the value based on the given precision (not step)
-        function calculatePrecisionValue(value) {
-            return Math.round(value * _private.multiplier) / _private.multiplier
-        }
-
-        // calculate the minimum value rounded up to the next higher step size
-        function calculateMinimum() {
-            let fixedMin    = _private.fixedValue(_private.minVal)
-            let fixedStep   = _private.fixedValue(_private.stepVal)
-            return (Math.ceil(fixedMin / fixedStep) * fixedStep) / _private.multiplier
-        }
-
-        // calculate the maximum value rounded down to the next higher step size
-        function calculateMaximum() {
-            let fixedMax    = _private.fixedValue(_private.maxVal)
-            let fixedStep   = _private.fixedValue(_private.stepVal)
-            return (Math.floor(fixedMax / fixedStep) * fixedStep) / _private.multiplier
-        }
-
-        // return a fixed point int from the inputted float (using the set precision)
-        function fixedValue(value) {
-            return Math.round(value * _private.multiplier)
-        }
-
-        function incrementedValue() {
-            let fixedVal    = _private.fixedValue(_private.val)
-            let fixedStep   = _private.fixedValue(_private.stepVal)
-            let fixedDelta  = fixedStep - (fixedVal % fixedStep)
-            return Math.max(
-                _private.minVal,
-                Math.min(_private.maxVal, (fixedVal + fixedDelta) / _private.multiplier)
-            )
-        }
-
-        function decrementedValue() {
-            let fixedVal    = _private.fixedValue(_private.val)
-            let fixedStep   = _private.fixedValue(_private.stepVal)
-            let fixedDelta  = fixedVal % fixedStep
-            return Math.min(
-                _private.maxVal,
-                Math.max(_private.minVal, (fixedVal - (fixedDelta > 0 ? fixedDelta : fixedStep)) / _private.multiplier)
-            )
-        }
+    RangedValue { id: _rangedValue
+        objectName: "_rangedValue"
     }
 
     Text { id: _title
@@ -163,17 +111,17 @@
             ArrowButton {id : _upArrowIcon
                 objectName  : "upArrowIcon"
                 upArrow     : true
-                enabled     : buttonsEnabled && _private.canIncrement
+                enabled     : buttonsEnabled && _rangedValue.canIncrement
 
-                onClicked   : { _root.increment(_private.incrementedValue()) }
+                onClicked   : { _root.increment(_rangedValue.incrementedValue()) }
             }
 
             ArrowButton {id : _downArrowIcon
                 objectName  : "downArrowIcon"
                 downArrow   : true
-                enabled     : buttonsEnabled && _private.canDecrement
+                enabled     : buttonsEnabled && _rangedValue.canDecrement
 
-                onClicked   : { _root.decrement(_private.decrementedValue()) }
+                onClicked   : { _root.decrement(_rangedValue.decrementedValue()) }
             }
         }
     }