move update transform logic to ZoomState

SmartToolFactory · SmartToolFactory · commit a6e9f47d8ae9 · 2022-07-14T13:28:43.000+03:00
diff --git a/image/src/main/java/com/smarttoolfactory/image/zoom/ZoomState.kt b/image/src/main/java/com/smarttoolfactory/image/zoom/ZoomState.kt
@@ -7,26 +7,139 @@ import androidx.compose.runtime.Immutable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.unit.IntSize
 import kotlinx.coroutines.coroutineScope
 
+
+
+/**
+ * * Create and [remember] the [ZoomState] based on the currently appropriate transform
+ * configuration to allow changing pan, zoom, and rotation.
+ *
+ *  [key1] is used to reset remember block to initial calculations. This can be used
+ * when image, contentScale or any property changes which requires values to be reset to initial
+ * values
+ *
+ * @param initialZoom zoom set initially
+ * @param initialRotation rotation set initially
+ * @param minZoom minimum zoom value this Composable can possess
+ * @param maxZoom maximum zoom value this Composable can possess
+ * @param limitPan limits pan to bounds of parent Composable. Using this flag prevents creating
+ * empty space on sides or edges of parent
+ * @param zoomEnabled when set to true zoom is enabled
+ * @param panEnabled when set to true pan is enabled
+ * @param rotationEnabled when set to true rotation is enabled
+ */
+@Composable
+fun rememberZoomState(
+    initialZoom: Float = 1f,
+    initialRotation: Float = 0f,
+    minZoom: Float = 1f,
+    maxZoom: Float = 5f,
+    zoomEnabled: Boolean = true,
+    panEnabled: Boolean = true,
+    rotationEnabled: Boolean = false,
+    limitPan: Boolean = false,
+    key1: Any? = Unit
+): ZoomState {
+    return remember(key1) {
+        ZoomState(
+            initialZoom = initialZoom,
+            initialRotation = initialRotation,
+            minZoom = minZoom,
+            maxZoom = maxZoom,
+            zoomEnabled = zoomEnabled,
+            panEnabled = panEnabled,
+            rotationEnabled = rotationEnabled,
+            limitPan = limitPan
+        )
+    }
+}
+
 /**
  * * Create and [remember] the [ZoomState] based on the currently appropriate transform
  * configuration to allow changing pan, zoom, and rotation.
  *
+ *  [key1] or [key2] are used to reset remember block to initial calculations. This can be used
+ * when image, contentScale or any property changes which requires values to be reset to initial
+ * values
+ *
+ * @param initialZoom zoom set initially
+ * @param initialRotation rotation set initially
+ * @param minZoom minimum zoom value this Composable can possess
+ * @param maxZoom maximum zoom value this Composable can possess
+ * @param limitPan limits pan to bounds of parent Composable. Using this flag prevents creating
+ * empty space on sides or edges of parent
+ * @param zoomEnabled when set to true zoom is enabled
+ * @param panEnabled when set to true pan is enabled
+ * @param rotationEnabled when set to true rotation is enabled
  */
 @Composable
 fun rememberZoomState(
     initialZoom: Float = 1f,
     initialRotation: Float = 0f,
     minZoom: Float = 1f,
-    maxZoom: Float = 5f
+    maxZoom: Float = 5f,
+    zoomEnabled: Boolean = true,
+    panEnabled: Boolean = true,
+    rotationEnabled: Boolean = false,
+    limitPan: Boolean = false,
+    key1: Any?,
+    key2: Any?,
 ): ZoomState {
-    return remember {
+    return remember(key1, key2) {
         ZoomState(
             initialZoom = initialZoom,
             initialRotation = initialRotation,
             minZoom = minZoom,
-            maxZoom = maxZoom
+            maxZoom = maxZoom,
+            zoomEnabled = zoomEnabled,
+            panEnabled = panEnabled,
+            rotationEnabled = rotationEnabled,
+            limitPan = limitPan
+        )
+    }
+}
+
+/**
+ * * Create and [remember] the [ZoomState] based on the currently appropriate transform
+ * configuration to allow changing pan, zoom, and rotation.
+ *
+ * @param initialZoom zoom set initially
+ * @param initialRotation rotation set initially
+ * @param minZoom minimum zoom value this Composable can possess
+ * @param maxZoom maximum zoom value this Composable can possess
+ * @param limitPan limits pan to bounds of parent Composable. Using this flag prevents creating
+ * empty space on sides or edges of parent
+ * @param zoomEnabled when set to true zoom is enabled
+ * @param panEnabled when set to true pan is enabled
+ * @param rotationEnabled when set to true rotation is enabled
+ * @param keys are used to reset remember block to initial calculations. This can be used
+ * when image, contentScale or any property changes which requires values to be reset to initial
+ * values
+ */
+@Composable
+fun rememberZoomState(
+    initialZoom: Float = 1f,
+    initialRotation: Float = 0f,
+    minZoom: Float = 1f,
+    maxZoom: Float = 5f,
+    zoomEnabled: Boolean = true,
+    panEnabled: Boolean = true,
+    rotationEnabled: Boolean = false,
+    limitPan: Boolean = false,
+    vararg keys: Any?
+    ): ZoomState {
+    return remember(keys) {
+        ZoomState(
+            initialZoom = initialZoom,
+            initialRotation = initialRotation,
+            minZoom = minZoom,
+            maxZoom = maxZoom,
+            zoomEnabled = zoomEnabled,
+            panEnabled = panEnabled,
+            rotationEnabled = rotationEnabled,
+            limitPan = limitPan
         )
     }
 }
@@ -35,13 +148,23 @@ fun rememberZoomState(
  *  * State of the zoom. Allows the developer to change zoom, pan,  translate,
  *  or get current state by
  * calling methods on this object. To be hosted and passed to [Modifier.zoom]
+ * @param limitPan limits pan to bounds of parent Composable. Using this flag prevents creating
+ * empty space on sides or edges of parent.
+
+ * @param zoomEnabled when set to true zoom is enabled
+ * @param panEnabled when set to true pan is enabled
+ * @param rotationEnabled when set to true rotation is enabled
  */
 @Immutable
 open class ZoomState internal constructor(
     initialZoom: Float = 1f,
     initialRotation: Float = 0f,
     minZoom: Float = 1f,
-    maxZoom: Float = 5f
+    maxZoom: Float = 5f,
+    private val zoomEnabled: Boolean = true,
+    private val panEnabled: Boolean = true,
+    internal val rotationEnabled: Boolean = true,
+    internal val limitPan: Boolean = false
 ) {
 
     internal val zoomMin = minZoom.coerceAtLeast(.5f)
@@ -74,11 +197,51 @@ open class ZoomState internal constructor(
         )
 
 
-    fun boundPan(maxX: Float, maxY: Float) {
-        animatablePan.updateBounds(
-            Offset(-maxX, -maxY),
-            Offset(maxX, maxY)
-        )
+    open fun boundPan(lowerBound:Offset, upperBound:Offset) {
+        animatablePan.updateBounds(lowerBound, upperBound)
+    }
+
+    internal open suspend fun updateZoomState(
+        size: IntSize,
+        gesturePan: Offset,
+        gestureZoom: Float,
+        gestureRotate: Float,
+    ) {
+        var zoom = zoom
+
+        val boundPan = limitPan && !rotationEnabled
+
+        val rotation = if (rotationEnabled) {
+            rotation + gestureRotate
+        } else {
+            0f
+        }
+
+        if (panEnabled) {
+            val offset = pan
+            var newOffset = offset + gesturePan.times(zoom)
+
+            if (boundPan) {
+                val maxX = (size.width * (zoom - 1) / 2f)
+                    .coerceAtLeast(0f)
+                val maxY = (size.height * (zoom - 1) / 2f)
+                    .coerceAtLeast(0f)
+                newOffset = Offset(
+                    newOffset.x.coerceIn(-maxX, maxX),
+                    newOffset.y.coerceIn(-maxY, maxY)
+                )
+            }
+            snapPanTo(newOffset)
+        }
+
+        if (zoomEnabled) {
+            zoom = (zoom * gestureZoom).coerceIn(zoomMin, zoomMax)
+            snapZoomTo(zoom)
+        }
+
+        if (rotationEnabled) {
+            snapRotationTo(rotation)
+        }
     }
 
     internal suspend fun animatePanTo(pan: Offset) = coroutineScope {
@@ -94,14 +257,20 @@ open class ZoomState internal constructor(
     }
 
     internal suspend fun snapPanTo(offset: Offset) = coroutineScope {
-        animatablePan.snapTo(offset)
+        if (panEnabled) {
+            animatablePan.snapTo(offset)
+        }
     }
 
     internal suspend fun snapZoomTo(zoom: Float) = coroutineScope {
-        animatableZoom.snapTo(zoom)
+        if (zoomEnabled) {
+            animatableZoom.snapTo(zoom)
+        }
     }
 
     internal suspend fun snapRotationTo(rotation: Float) = coroutineScope {
-        animatableRotation.snapTo(rotation)
+        if (rotationEnabled) {
+            animatableRotation.snapTo(rotation)
+        }
     }
 }
diff --git a/image/src/main/java/com/smarttoolfactory/image/zoom/ZoomUtil.kt b/image/src/main/java/com/smarttoolfactory/image/zoom/ZoomUtil.kt
@@ -1,6 +1,9 @@
 package com.smarttoolfactory.image.zoom
 
-fun calculateZoom(
+/**
+ * Calculate zoom level and zoom value when user double taps
+ */
+internal fun calculateZoom(
     zoomLevel: ZoomLevel,
     initial: Float,
     min: Float,
@@ -13,15 +16,15 @@ fun calculateZoom(
     when (zoomLevel) {
         ZoomLevel.Initial -> {
             newZoomLevel = ZoomLevel.Max
-            newZoom = max
+            newZoom = max.coerceAtMost(3f)
         }
         ZoomLevel.Max -> {
             newZoomLevel = ZoomLevel.Min
-            newZoom = if(min == initial) (min +max)/2 else min
+            newZoom = if (min == initial) (min + max.coerceAtMost(3f)) / 2 else min
         }
         else -> {
             newZoomLevel = ZoomLevel.Initial
-            newZoom = initial
+            newZoom = initial.coerceAtMost(2f)
         }
     }
     return Pair(newZoomLevel, newZoom)
