update Modifier.zoom with ZoomState

Author: SmartToolFactory

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

@@ -1,14 +1,12 @@
 package com.smarttoolfactory.image.zoom
 
-import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.VectorConverter
-import androidx.compose.animation.core.spring
 import androidx.compose.foundation.gestures.detectTapGestures
-import androidx.compose.runtime.*
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.composed
 import androidx.compose.ui.draw.clipToBounds
 import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.GraphicsLayerScope
 import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.input.pointer.pointerInput
 import com.smarttoolfactory.gesture.detectTransformGestures
@@ -18,9 +16,6 @@ import kotlinx.coroutines.launch
  * Modifier that zooms in or out of Composable set to.
  * @param keys are used for [Modifier.pointerInput] to restart closure when any keys assigned
  * change
- * @param initialZoom initial value of zoom
- * @param minZoom minimum zoom value
- * @param maxZoom maximum zoom value
  * @param clip when set to true clips to parent bounds. Anything outside parent bounds is not
  * drawn
  * @param limitPan limits pan to bounds of parent Composable. Using this flag prevents creating
@@ -39,75 +34,44 @@ import kotlinx.coroutines.launch
  */
 fun Modifier.zoom(
     vararg keys: Any?,
-    initialZoom: Float = 1f,
-    minZoom: Float = 1f,
-    maxZoom: Float = 5f,
     clip: Boolean = true,
     limitPan: Boolean = true,
     consume: Boolean = true,
     zoomEnabled: Boolean = true,
     panEnabled: Boolean = true,
     rotationEnabled: Boolean = false,
+    zoomState: ZoomState,
     onGestureStart: (ZoomData) -> Unit = {},
     onGesture: (ZoomData) -> Unit = {},
     onGestureEnd: (ZoomData) -> Unit = {},
 ) = composed(
     factory = {
-
         val coroutineScope = rememberCoroutineScope()
-        val zoomMin = minZoom.coerceAtLeast(.5f)
-        val zoomMax = maxZoom.coerceAtLeast(1f)
-        val zoomInitial = initialZoom.coerceIn(zoomMin, zoomMax)
-
-        require(zoomMax >= zoomMin)
-
-        val animatablePan = remember {
-            Animatable(Offset.Zero, Offset.VectorConverter)
-        }
-        val animatableZoom = remember { Animatable(zoomInitial) }
-        val animatableRotation = remember { Animatable(0f) }
-
-        var zoomLevel by remember { mutableStateOf(ZoomLevel.Min) }
-
         val boundPan = limitPan && !rotationEnabled
         val clipToBounds = (clip || boundPan)
 
-
         val transformModifier = Modifier.pointerInput(keys) {
             detectTransformGestures(
                 consume = consume,
                 onGestureStart = {
-                    onGestureStart(
-                        ZoomData(
-                            zoom = animatableZoom.value,
-                            pan = animatablePan.value,
-                            rotation = animatableRotation.value
-                        )
-                    )
+                    onGestureStart(zoomState.zoomData)
                 },
                 onGestureEnd = {
-                    onGestureEnd(
-                        ZoomData(
-                            zoom = animatableZoom.value,
-                            pan = animatablePan.value,
-                            rotation = animatableRotation.value
-                        )
-                    )
+                    onGestureEnd(zoomState.zoomData)
                 },
-                onGesture = { centroid, gesturePan, gestureZoom, gestureRotate,
-                              _,
-                              _ ->
+                onGesture = { _, gesturePan, gestureZoom, gestureRotate, _, _ ->
+
+                    var zoom = zoomState.zoom
+                    val offset = zoomState.pan
 
-                    var zoom = animatableZoom.value
-                    val offset = animatablePan.value
                     val rotation = if (rotationEnabled) {
-                        animatableRotation.value + gestureRotate
+                        zoomState.rotation + gestureRotate
                     } else {
                         0f
                     }
 
                     if (zoomEnabled) {
-                        zoom = (zoom * gestureZoom).coerceIn(zoomMin, zoomMax)
+                        zoom = (zoom * gestureZoom).coerceIn(zoomState.zoomMin, zoomState.zoomMax)
                     }
 
                     val newOffset = offset + gesturePan.times(zoom)
@@ -117,16 +81,15 @@ fun Modifier.zoom(
                     val maxY = (size.height * (zoom - 1) / 2f)
                         .coerceAtLeast(0f)
 
-
                     if (zoomEnabled) {
                         coroutineScope.launch {
-                            animatableZoom.snapTo(zoom)
+                            zoomState.snapZoomTo(zoom)
                         }
                     }
 
                     if (panEnabled) {
                         coroutineScope.launch {
-                            animatablePan.snapTo(
+                            zoomState.snapPanTo(
                                 if (boundPan) {
                                     Offset(
                                         newOffset.x.coerceIn(-maxX, maxX),
@@ -141,17 +104,11 @@ fun Modifier.zoom(
 
                     if (rotationEnabled) {
                         coroutineScope.launch {
-                            animatableRotation.snapTo(rotation)
+                            zoomState.snapRotationTo(rotation)
                         }
                     }
 
-                    onGesture(
-                        ZoomData(
-                            zoom = animatableZoom.value,
-                            pan = animatablePan.value,
-                            rotation = animatableRotation.value
-                        )
-                    )
+                    onGesture(zoomState.zoomData)
                 }
             )
         }
@@ -161,49 +118,31 @@ fun Modifier.zoom(
                 onDoubleTap = {
 
                     val (newZoomLevel, newZoom) = calculateZoom(
-                        zoomLevel = zoomLevel,
-                        initial = zoomInitial,
-                        min = minZoom,
-                        max = maxZoom
+                        zoomLevel = zoomState.zoomLevel,
+                        initial = zoomState.zoomInitial,
+                        min = zoomState.zoomMin,
+                        max = zoomState.zoomMax
                     )
 
-                    zoomLevel = newZoomLevel
+                    zoomState.zoomLevel = newZoomLevel
 
                     coroutineScope.launch {
-                        animatablePan.animateTo(Offset.Zero, spring())
+                        zoomState.animatePanTo(Offset.Zero)
                     }
+
                     coroutineScope.launch {
-                        animatableZoom.animateTo(newZoom, spring())
+                        zoomState.animateZoomTo(newZoom)
                     }
+
                     coroutineScope.launch {
-                        animatableRotation.animateTo(0f, spring())
+                        zoomState.animateRotationTo(zoomState.rotationInitial)
                     }
                 }
             )
         }
 
         val graphicsModifier = Modifier.graphicsLayer {
-            val zoom = animatableZoom.value
-
-            // Set zoom
-            scaleX = zoom
-            scaleY = zoom
-
-            // Set pan
-            val translationX = animatablePan.value.x
-            val translationY = animatablePan.value.y
-            this.translationX = translationX
-            this.translationY = translationY
-
-            // Set rotation
-            rotationZ = animatableRotation.value
-//                    TransformOrigin(0f, 0f).also { transformOrigin = it }
-            onGesture(
-                ZoomData(
-                    zoom = animatableZoom.value,
-                    pan = animatablePan.value,
-                )
-            )
+            this.update(zoomState)
         }
 
         this.then(
@@ -213,10 +152,19 @@ fun Modifier.zoom(
                 .then(graphicsModifier)
 
         )
-
     },
     inspectorInfo = {
-
+        name = "zoom"
+        properties["keys"] = keys
+        properties["clip"] = clip
+        properties["limitPan"] = limitPan
+        properties["consume"] = consume
+        properties["zoomEnabled"] = zoomEnabled
+        properties["rotationEnabled"] = rotationEnabled
+        properties["zoomState"] = zoomState
+        properties["onGestureStart"] = onGestureStart
+        properties["onGesture"] = onGesture
+        properties["onGestureEnd"] = onGestureEnd
     }
 )
 
@@ -228,28 +176,40 @@ fun Modifier.zoom(
  * drawn
  * @param limitPan limits pan to bounds of parent Composable. Using this flag prevents creating
  * empty space on sides or edges of parent.
- * @param minZoom minimum zoom value
- * @param maxZoom maximum zoom value
  */
 fun Modifier.zoom(
     vararg keys: Any?,
-    initialZoom: Float = 1f,
-    minZoom: Float = 1f,
-    maxZoom: Float = 5f,
-    rotate: Boolean = false,
+    zoomState: ZoomState,
+    rotationEnabled: Boolean = false,
     clip: Boolean = true,
-    limitPan: Boolean = true,
-
-    ) = zoom(
+    limitPan: Boolean = true
+) = zoom(
     keys = keys,
-    initialZoom = initialZoom,
-    minZoom = minZoom,
-    maxZoom = maxZoom,
     clip = clip,
     limitPan = limitPan,
-    rotationEnabled = rotate,
+    rotationEnabled = rotationEnabled,
     consume = true,
+    zoomState = zoomState,
     onGestureStart = {},
     onGestureEnd = {},
     onGesture = {}
-)
+)
+
+private fun GraphicsLayerScope.update(zoomState: ZoomState) {
+
+    // Set zoom
+    val zoom = zoomState.zoom
+    this.scaleX = zoom
+    this.scaleY = zoom
+
+    // Set pan
+    val pan = zoomState.pan
+    val translationX = pan.x
+    val translationY = pan.y
+    this.translationX = translationX
+    this.translationY = translationY
+
+    // Set rotation
+    this.rotationZ = zoomState.rotation
+}
+