Merge pull request #19 from monstar-lab-oss/feat/slider_distribution

Feat/slider distribution

Author: levinzonr

.gitignore

@@ -8,6 +8,9 @@
 /.idea/workspace.xml
 /.idea/navEditor.xml
 /.idea/assetWizardSettings.xml
+/.idea/misc.xml
+/.idea/deploymentTargetDropDown.xml
+/.idea/deploymentTargetSelector.xml
 .DS_Store
 /build
 /captures

.idea/deploymentTargetSelector.xml

@@ -39,7 +39,8 @@ import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import io.monstarlab.mosaic.slider.Slider
 import io.monstarlab.mosaic.slider.SliderColors
-import io.monstarlab.mosaic.slider.SliderValueDistribution
+import io.monstarlab.mosaic.slider.distribution.CheckPointsValueDistribution
+import io.monstarlab.mosaic.slider.distribution.SliderValueDistribution
 import kotlin.math.roundToInt
 import androidx.compose.material3.Slider as MaterialSlider
 
@@ -66,7 +67,6 @@ fun MosaicSliderDemo() {
         var enabled by remember { mutableStateOf(true) }
         var isCustom by remember { mutableStateOf(false) }
         var linearDistribution by remember { mutableStateOf(false) }
-
         var sliderValue by remember { mutableFloatStateOf(500f) }
 
         MaterialSlider(
@@ -83,8 +83,15 @@ fun MosaicSliderDemo() {
             Modifier
         }
 
-        val parabolic: SliderValueDistribution = remember {
-            SliderValueDistribution.parabolic(a = 0.005f)
+        val fragmentedDistribution: SliderValueDistribution = remember {
+            CheckPointsValueDistribution(
+                listOf(
+                    0f to 0f,
+                    0.2f to 500f,
+                    0.4f to 800f,
+                    1f to 1000f,
+                ),
+            )
         }
 
         Slider(
@@ -94,10 +101,11 @@ fun MosaicSliderDemo() {
             enabled = enabled,
             colors = colors,
             range = 0f..1000f,
+            disabledRange = 50f..300f,
             valueDistribution = if (linearDistribution) {
                 SliderValueDistribution.Linear
             } else {
-                parabolic
+                fragmentedDistribution
             },
             thumb = {
                 if (isCustom) {

demo/src/main/java/io/monstarlab/mosaic/features/SliderDemo.kt

@@ -7,3 +7,15 @@ internal fun scale(a1: Float, b1: Float, x1: Float, a2: Float, b2: Float) =
 
 internal fun calcFraction(a: Float, b: Float, pos: Float) =
     (if (b - a == 0f) 0f else (pos - a) / (b - a)).coerceIn(0f, 1f)
+
+internal fun Float.valueToFraction(rangeStart: Float, rangeEnd: Float) =
+    calcFraction(rangeStart, rangeEnd, this)
+
+internal fun Float.valueToFraction(range: ClosedFloatingPointRange<Float>) =
+    valueToFraction(range.start, range.endInclusive)
+
+internal fun Float.fractionToValue(rangeStart: Float, rangeEnd: Float): Float =
+    scale(0f, 1f, this.coerceIn(0f, 1f), rangeStart, rangeEnd)
+
+internal fun Float.fractionToValue(range: ClosedFloatingPointRange<Float>): Float =
+    scale(0f, 1f, this, range.start, range.endInclusive)

slider/src/main/java/io/monstarlab/mosaic/slider/MathUtils.kt

@@ -46,7 +46,7 @@ internal fun Modifier.sliderSemantics(state: SliderState, enabled: Boolean): Mod
         if (!enabled) disabled()
         setProgress(
             action = { targetValue ->
-                val coercedValue = state.coerceValue(targetValue)
+                val coercedValue = state.coerceUserValue(targetValue)
                 // This is to keep it consistent with AbsSeekbar.java: return false if no
                 // change from current.
                 if (coercedValue == state.value) {

slider/src/main/java/io/monstarlab/mosaic/slider/Modifiers.kt

@@ -15,6 +15,7 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalLayoutDirection
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.LayoutDirection
+import io.monstarlab.mosaic.slider.distribution.SliderValueDistribution
 
 /**
  * A composable function that creates a slider UI component.
@@ -99,7 +100,7 @@ public fun Slider(
         thumb = thumb,
         track = {
             SliderTrack(
-                progress = state.valueAsFraction,
+                progress = state.offsetAsFraction,
                 colors = colors,
                 disabledRange = state.disabledRangeAsFractions,
                 enabled = enabled,

slider/src/main/java/io/monstarlab/mosaic/slider/Slider.kt

@@ -46,7 +46,7 @@ public fun SliderLayout(
         state.updateDimensions(sliderWidth.toFloat(), thumbPlaceable.width.toFloat())
 
         val trackOffsetX = thumbPlaceable.width / 2
-        val thumbOffsetX = ((trackPlaceable.width) * state.valueAsFraction).roundToInt()
+        val thumbOffsetX = ((trackPlaceable.width) * state.offsetAsFraction).roundToInt()
         val trackOffsetY = (sliderHeight - trackPlaceable.height) / 2
         val thumbOffsetY = (sliderHeight - thumbPlaceable.height) / 2
 

slider/src/main/java/io/monstarlab/mosaic/slider/SliderLayout.kt

@@ -11,6 +11,7 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.geometry.Offset
+import io.monstarlab.mosaic.slider.distribution.SliderValueDistribution
 import kotlinx.coroutines.coroutineScope
 
 /**
@@ -56,18 +57,19 @@ public class SliderState(
     public var value: Float
         get() = valueState
         set(value) {
-            valueState = coerceValue(value)
+            valueState = coerceUserValue(value)
         }
 
     /**
      * Internal value returned as fraction, used for displaying and specifying
      * the "real" position of the thumb
      */
-    internal val valueAsFraction: Float
-        get() {
-            val inverted = valueDistribution.inverse(value)
-            val invertedRange = valueDistribution.inverse(range)
-            return calcFraction(invertedRange.start, invertedRange.endInclusive, inverted)
+    internal val offsetAsFraction: Float
+        get() = if (totalWidth == 0f) {
+            0f
+        } else {
+            val valueFraction = value.valueToFraction(range)
+            valueDistribution.inverse(valueFraction).coerceIn(0f, 1f)
         }
 
     internal val disabledRangeAsFractions: ClosedFloatingPointRange<Float>
@@ -115,35 +117,33 @@ public class SliderState(
      * Scales offset in to the value that user should see
      */
     private fun scaleToUserValue(offset: Float): Float {
-        val invertedRange = valueDistribution.inverse(range)
-        val value = scale(0f, totalWidth, offset, invertedRange.start, invertedRange.endInclusive)
-        return coerceValue(valueDistribution.interpolate(value))
+        val coercedValue = (offset / totalWidth).coerceIn(0f..1f)
+        val value = valueDistribution.interpolate(coercedValue)
+            .fractionToValue(range)
+        return coerceUserValue(value)
     }
 
     /**
      * Converts value of the user into the raw offset on the track
      */
     private fun scaleToOffset(value: Float): Float {
-        val coerced = coerceValue(value)
-        val invertedRange = valueDistribution.inverse(range)
-        val invertedValue = valueDistribution.inverse(coerced)
-        return scale(
-            invertedRange.start,
-            invertedRange.endInclusive,
-            invertedValue,
-            0f,
-            totalWidth,
-        )
+        val valueAsFraction = coerceUserValue(value).valueToFraction(range)
+        return valueDistribution
+            .inverse(valueAsFraction)
+            .fractionToValue(0f, totalWidth)
     }
 
-    internal fun coerceValue(value: Float): Float {
+    internal fun coerceUserValue(value: Float): Float {
         return value
             .coerceIn(range)
             .coerceIntoDisabledRange()
     }
 
     private fun Float.coerceIntoDisabledRange(): Float {
-        if (disabledRange.isEmpty()) return this
+        if (disabledRange.isEmpty() || !disabledRange.contains(this)) {
+            return this
+        }
+
         // check if disabled range is on the left or right
         return if (disabledRange.start == range.start) {
             coerceAtLeast(disabledRange.endInclusive)
@@ -156,17 +156,9 @@ public class SliderState(
         subrange: ClosedFloatingPointRange<Float>,
     ): ClosedFloatingPointRange<Float> {
         if (subrange.isEmpty()) return subrange
-        val interpolatedRange = valueDistribution.interpolate(range)
-        val interpolatedSubrange = valueDistribution.interpolate(subrange)
-        return calcFraction(
-            interpolatedRange.start,
-            interpolatedRange.endInclusive,
-            interpolatedSubrange.start,
-        )..calcFraction(
-            interpolatedRange.start,
-            interpolatedRange.endInclusive,
-            interpolatedSubrange.endInclusive,
-        )
+        val start = valueDistribution.inverse(subrange.start.valueToFraction(range))
+        val end = valueDistribution.inverse(subrange.endInclusive.valueToFraction(range))
+        return start..end
     }
 }
 

slider/src/main/java/io/monstarlab/mosaic/slider/SliderState.kt

@@ -0,0 +1,63 @@
+package io.monstarlab.mosaic.slider.distribution
+
+import io.monstarlab.mosaic.slider.valueToFraction
+
+public class CheckPointsValueDistribution(
+    valuesMap: List<Pair<Float, Float>>,
+) :
+    SliderValueDistribution {
+
+    private var equations: List<RangedLinearEquation>
+
+    init {
+        require(valuesMap.isNotEmpty()) {
+            "Values map can't be empty"
+        }
+
+        val offsetRange = valuesMap.minOf { it.first }..valuesMap.maxOf { it.first }
+        val valueRange = valuesMap.minOf { it.second }..valuesMap.maxOf { it.second }
+        val zipped = valuesMap.sortedBy { it.first }
+            .zipWithNext()
+        // make sure all values are increasing, otherwise throw an exception
+        zipped.firstOrNull { it.first.second >= it.second.second }
+            ?.let {
+                throw DecreasingValueException(it.first)
+            }
+        equations = zipped.map {
+            val x1Fraction = it.first.first.valueToFraction(offsetRange)
+            val x2Fraction = it.second.first.valueToFraction(offsetRange)
+            val y1Fraction = it.first.second.valueToFraction(valueRange)
+            val y2Fraction = it.second.second.valueToFraction(valueRange)
+            val equation = LinearEquation.fromTwoPoints(
+                x1 = x1Fraction,
+                x2 = x2Fraction,
+                y1 = y1Fraction,
+                y2 = y2Fraction,
+            )
+            RangedLinearEquation(
+                equation = equation,
+                offsetRange = x1Fraction..x2Fraction,
+                valueRange = y1Fraction..y2Fraction,
+            )
+        }
+    }
+
+    override fun interpolate(value: Float): Float {
+        val equation = equations.firstOrNull { it.offsetRange.contains(value) }?.equation
+        checkNotNull(equation) { "No equation found for value $value during interpolate" }
+        return equation.valueFromOffset(value)
+    }
+
+    override fun inverse(value: Float): Float {
+        val equation = equations.firstOrNull { it.valueRange.contains(value) }?.equation
+        checkNotNull(equation) { "No equation found for value $value during inverse" }
+        return equation.offsetFromValue(value)
+    }
+
+    public class DecreasingValueException(progressValuePair: Pair<Float, Float>) :
+        IllegalStateException(
+            "Values must be always increasing with increasing progress," +
+                " item at progress ${progressValuePair.first}  with value " +
+                "${progressValuePair.second} is breaking this rule ",
+        )
+}