change pan from Offset to separate x,y axes

Fling gesture stops if one of the x or y values of Offset reach lower or upper bound to prevent that create 2 separate Animatables to have fling gesture individually.

Author: SmartToolFactory

image/src/main/java/com/smarttoolfactory/image/zoom/EnhancedZoomStateImpl.kt

@@ -11,6 +11,7 @@ import androidx.compose.ui.unit.IntSize
 import com.smarttoolfactory.image.util.coerceIn
 import com.smarttoolfactory.image.util.getCropRect
 import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.launch
 
 /**
  *  * State of the enhanced zoom that uses animations and fling
@@ -72,7 +73,7 @@ open class EnhancedZoomState constructor(
     val enhancedZoomData: EnhancedZoomData
         get() = EnhancedZoomData(
             zoom = animatableZoom.targetValue,
-            pan = animatablePan.targetValue,
+            pan = Offset(animatablePanX.targetValue, animatablePanY.targetValue),
             rotation = animatableRotation.targetValue,
             imageRegion = rectDraw,
             visibleRegion = calculateRectBounds()
@@ -83,7 +84,8 @@ open class EnhancedZoomState constructor(
         val width = size.width
         val height = size.height
         val zoom = animatableZoom.targetValue
-        val pan = animatablePan.targetValue
+        val panX = animatablePanX.targetValue
+        val panY = animatablePanY.targetValue
 
         // Offset for interpolating offset from (imageWidth/2,-imageWidth/2) interval
         // to (0, imageWidth) interval when
@@ -93,9 +95,9 @@ open class EnhancedZoomState constructor(
 
         val bounds = getBounds()
 
-        val offsetX = (horizontalCenterOffset - pan.x.coerceIn(-bounds.x, bounds.x))
+        val offsetX = (horizontalCenterOffset - panX.coerceIn(-bounds.x, bounds.x))
             .coerceAtLeast(0f) / zoom
-        val offsetY = (verticalCenterOffset - pan.y.coerceIn(-bounds.y, bounds.y))
+        val offsetY = (verticalCenterOffset - panY.coerceIn(-bounds.y, bounds.y))
             .coerceAtLeast(0f) / zoom
 
         val offset = Offset(offsetX, offsetY)
@@ -203,16 +205,27 @@ open class BaseEnhancedZoomState constructor(
      * Create a fling gesture when user removes finger from scree to have continuous movement
      * until [velocityTracker] speed reached to lower bound
      */
-    private suspend fun fling() {
+    private suspend fun fling() = coroutineScope {
         val velocityTracker = velocityTracker.calculateVelocity()
         val velocity = Offset(velocityTracker.x, velocityTracker.y)
 
-        animatablePan.animateDecay(
-            velocity,
-            exponentialDecay(
-                absVelocityThreshold = 20f
+        launch {
+            animatablePanX.animateDecay(
+                velocity.x,
+                exponentialDecay(
+                    absVelocityThreshold = 20f
+                )
             )
-        )
+        }
+
+        launch {
+            animatablePanY.animateDecay(
+                velocity.y,
+                exponentialDecay(
+                    absVelocityThreshold = 20f
+                )
+            )
+        }
     }
 
     private fun resetTracking() {

image/src/main/java/com/smarttoolfactory/image/zoom/ZoomStateImpl.kt

@@ -1,7 +1,6 @@
 package com.smarttoolfactory.image.zoom
 
 import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.VectorConverter
 import androidx.compose.runtime.Stable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.geometry.Offset
@@ -38,7 +37,8 @@ open class ZoomState(
     internal val zoomInitial = initialZoom.coerceIn(zoomMin, zoomMax)
     internal val rotationInitial = initialRotation % 360
 
-    internal val animatablePan = Animatable(Offset.Zero, Offset.VectorConverter)
+    internal val animatablePanX = Animatable(0f)
+    internal val animatablePanY = Animatable(0f)
     internal val animatableZoom = Animatable(zoomInitial)
     internal val animatableRotation = Animatable(rotationInitial)
 
@@ -49,7 +49,7 @@ open class ZoomState(
     }
 
     val pan: Offset
-        get() = animatablePan.value
+        get() = Offset(animatablePanX.value, animatablePanY.value)
 
     val zoom: Float
         get() = animatableZoom.value
@@ -61,7 +61,7 @@ open class ZoomState(
         get() = animatableZoom.isRunning
 
     val isPanning: Boolean
-        get() = animatablePan.isRunning
+        get() = animatablePanX.isRunning || animatablePanY.isRunning
 
     val isRotating: Boolean
         get() = animatableRotation.isRunning
@@ -70,7 +70,8 @@ open class ZoomState(
         get() = isZooming || isPanning || isRotating
 
     internal open fun updateBounds(lowerBound: Offset?, upperBound: Offset?) {
-        animatablePan.updateBounds(lowerBound, upperBound)
+        animatablePanX.updateBounds(lowerBound?.x, upperBound?.x)
+        animatablePanY.updateBounds(lowerBound?.y, upperBound?.y)
     }
 
     /**
@@ -86,7 +87,7 @@ open class ZoomState(
     /**
      * Get bounds of Composables that can be panned based on zoom level using [size]
      */
-    protected fun getBounds(): Offset {
+    protected open fun getBounds(): Offset {
         return getBounds(size)
     }
 
@@ -114,7 +115,8 @@ open class ZoomState(
                 val bound = getBounds(size)
                 updateBounds(bound.times(-1f), bound)
             }
-            snapPanTo(newPan)
+            snapPanXto(newPan.x)
+            snapPanYto(newPan.y)
         }
     }
 
@@ -126,14 +128,21 @@ open class ZoomState(
         zoom: Float = 1f,
         rotation: Float = 0f
     ) = coroutineScope {
-        launch { animatePanTo(pan) }
+        launch { animatePanXto(pan.x) }
+        launch { animatePanYto(pan.y) }
         launch { animateZoomTo(zoom) }
         launch { animateRotationTo(rotation) }
     }
 
-    internal suspend fun animatePanTo(pan: Offset) {
+    internal suspend fun animatePanXto(panX: Float) {
         if (pannable) {
-            animatablePan.animateTo(pan)
+            animatablePanX.animateTo(panX)
+        }
+    }
+
+    internal suspend fun animatePanYto(panY: Float) {
+        if (pannable) {
+            animatablePanY.animateTo(panY)
         }
     }
 
@@ -149,9 +158,15 @@ open class ZoomState(
         }
     }
 
-    internal suspend fun snapPanTo(offset: Offset) {
+    internal suspend fun snapPanXto(panX:Float) {
+        if (pannable) {
+            animatablePanX.snapTo(panX)
+        }
+    }
+
+    internal suspend fun snapPanYto(panY:Float) {
         if (pannable) {
-            animatablePan.snapTo(offset)
+            animatablePanY.snapTo(panY)
         }
     }