add double tap and conditional enable for zoom

zoomOnDoubleTap param for Modifier.enhanced and Modifier.animatedZoom adds option to implement three levels of zoom on double tap

onGestureStart param for Modifier.enhanced and Modifier.animatedZoom adds option to enable pan conditionally

Author: SmartToolFactory

image/src/main/java/com/smarttoolfactory/image/util/ZoomUtil.kt

@@ -18,7 +18,7 @@ internal fun calculateZoom(
     val newZoom: Float
 
     when (zoomLevel) {
-        ZoomLevel.Initial -> {
+        ZoomLevel.Mid -> {
             newZoomLevel = ZoomLevel.Max
             newZoom = max.coerceAtMost(3f)
         }
@@ -27,13 +27,25 @@ internal fun calculateZoom(
             newZoom = if (min == initial) (min + max.coerceAtMost(3f)) / 2 else min
         }
         else -> {
-            newZoomLevel = ZoomLevel.Initial
+            newZoomLevel = ZoomLevel.Mid
             newZoom = initial.coerceAtMost(2f)
         }
     }
     return Pair(newZoomLevel, newZoom)
 }
 
+internal fun getNextZoomLevel(zoomLevel: ZoomLevel): ZoomLevel = when (zoomLevel) {
+    ZoomLevel.Mid -> {
+        ZoomLevel.Max
+    }
+    ZoomLevel.Max -> {
+        ZoomLevel.Min
+    }
+    else -> {
+        ZoomLevel.Mid
+    }
+}
+
 /**
  * Update graphic layer with [zoomState]
  */

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

@@ -6,6 +6,7 @@ import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.layout.Measurable
 import androidx.compose.ui.layout.Placeable
@@ -19,13 +20,42 @@ import com.smarttoolfactory.image.SlotsEnum
 
 /**
  * Layout that can zoom, rotate, pan its content with fling and moving back to bounds animation.
+ * @param clip when set to true clips to parent bounds. Anything outside parent bounds is not
+ * drawn
+ * @param minZoom minimum zoom value
+ * @param maxZoom maximum zoom value
+ * @param fling when set to true dragging pointer builds up velocity. When last
+ * pointer leaves Composable a movement invoked against friction till velocity drops below
+ * to threshold
+ * @param moveToBounds when set to true if image zoom is lower than initial zoom or
+ * panned out of image boundaries moves back to bounds with animation.
+ * @param zoomable when set to true zoom is enabled
+ * @param pannable when set to true pan is enabled
+ * @param rotatable when set to true rotation is enabled
+ * @param limitPan limits pan to bounds of parent Composable. Using this flag prevents creating
+ * empty space on sides or edges of parent
+ * @param zoomOnDoubleTap lambda that returns current [ZoomLevel] and based on current level
+ * enables developer to define zoom on double tap gesture
+ * @param enabled lambda can be used selectively enable or disable pan and intercepting with
+ * scroll, drag or lists or pagers using current zoom, pan or rotation values
  */
 @Composable
 fun AnimatedZoomLayout(
     modifier: Modifier = Modifier,
+    clip: Boolean = true,
+    initialZoom: Float = 1f,
+    minZoom: Float = 1f,
+    maxZoom: Float = 3f,
+    fling: Boolean = true,
+    moveToBounds: Boolean = false,
+    zoomable: Boolean = true,
+    pannable: Boolean = true,
+    rotatable: Boolean = false,
+    limitPan: Boolean = true,
+    enabled: (Float, Offset, Float) -> Boolean = DefaultEnabled,
+    zoomOnDoubleTap: (ZoomLevel) -> Float = DefaultOnDoubleTap,
     content: @Composable () -> Unit
 ) {
-
     AnimatedZoomSubcomposeLayout(
         modifier = modifier,
         mainContent = { content() }
@@ -35,9 +65,19 @@ fun AnimatedZoomLayout(
                 .fillMaxSize()
                 .border(5.dp, Color.Red)
                 .animatedZoom(
+                    enabled = enabled,
+                    clip = clip,
+                    zoomOnDoubleTap = zoomOnDoubleTap,
                     animatedZoomState = rememberAnimatedZoomState(
-                        minZoom = .5f,
-                        maxZoom = 30f,
+                        minZoom = minZoom,
+                        maxZoom = maxZoom,
+                        initialZoom = initialZoom,
+                        fling = fling,
+                        moveToBounds = moveToBounds,
+                        zoomable = zoomable,
+                        pannable = pannable,
+                        rotatable = rotatable,
+                        limitPan = limitPan,
                         contentSize = it
                     ),
                 ),

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

@@ -5,45 +5,57 @@ 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.graphicsLayer
 import androidx.compose.ui.input.pointer.pointerInput
 import com.smarttoolfactory.gesture.detectTransformGestures
+import com.smarttoolfactory.image.util.getNextZoomLevel
 import com.smarttoolfactory.image.util.update
 import kotlinx.coroutines.launch
 
 /**
-* Modifier that zooms in or out of Composable set to. This zoom modifier has option
-* to move back to bounds with an animation or option to have fling gesture when user removes
-* from screen while velocity is higher than threshold to have smooth touch effect.
-*
-* @param key is used for [Modifier.pointerInput] to restart closure when any keys assigned
-* change
-* @param consume flag to prevent other gestures such as scroll, drag or transform to get
-* @param clip when set to true clips to parent bounds. Anything outside parent bounds is not
-* drawn
-* empty space on sides or edges of parent.
-* [EnhancedZoomData]  of this modifier
-*/
+ * Modifier that zooms in or out of Composable set to. This zoom modifier has option
+ * to move back to bounds with an animation or option to have fling gesture when user removes
+ * from screen while velocity is higher than threshold to have smooth touch effect.
+ *
+ * @param key is used for [Modifier.pointerInput] to restart closure when any keys assigned
+ * change
+ * @param clip when set to true clips to parent bounds. Anything outside parent bounds is not
+ * drawn
+ * @param animatedZoomState State of the zoom that contains option to set initial, min, max zoom,
+ * enabling rotation, pan or zoom
+ * @param zoomOnDoubleTap lambda that returns current [ZoomLevel] and based on current level
+ * enables developer to define zoom on double tap gesture
+ * @param enabled lambda can be used selectively enable or disable pan and intercepting with
+ * scroll, drag or lists or pagers using current zoom, pan or rotation values
+ */
 fun Modifier.animatedZoom(
     key: Any? = Unit,
-    consume: Boolean = true,
     clip: Boolean = true,
     animatedZoomState: AnimatedZoomState,
+    enabled: (Float, Offset, Float) -> Boolean = DefaultEnabled,
+    zoomOnDoubleTap: (ZoomLevel) -> Float = animatedZoomState.DefaultOnDoubleTap,
 ) = composed(
 
     factory = {
 
         val coroutineScope = rememberCoroutineScope()
 
+        // Current Zoom level
+        var zoomLevel = ZoomLevel.Min
+
+        // Whether panning should be limited to bounds of gesture area or not
         val boundPan = animatedZoomState.limitPan && !animatedZoomState.rotatable
+
+        // If we bound to touch area or clip is true Modifier.clipToBounds is used
         val clipToBounds = (clip || boundPan)
 
         val transformModifier = Modifier.pointerInput(key) {
             // Pass size of this Composable this Modifier is attached for constraining operations
             // inside this bounds
             animatedZoomState.size = this.size
             detectTransformGestures(
-                consume = consume,
+                consume = false,
                 onGestureEnd = {
                     coroutineScope.launch {
                         animatedZoomState.onGestureEnd {
@@ -52,15 +64,24 @@ fun Modifier.animatedZoom(
                 },
                 onGesture = { centroid, pan, zoom, rotate, mainPointer, pointerList ->
 
+                    val currentZoom = animatedZoomState.zoom
+                    val currentPan = animatedZoomState.pan
+                    val currentRotation = animatedZoomState.rotation
+                    val gestureEnabled = enabled(currentZoom, currentPan, currentRotation)
+
                     coroutineScope.launch {
                         animatedZoomState.onGesture(
                             centroid = centroid,
-                            pan = pan,
+                            pan = if (gestureEnabled) pan else Offset.Zero,
                             zoom = zoom,
                             rotation = rotate,
                             mainPointer = mainPointer,
                             changes = pointerList
                         )
+
+                        if (gestureEnabled) {
+                            mainPointer.consume()
+                        }
                     }
                 }
             )
@@ -73,7 +94,9 @@ fun Modifier.animatedZoom(
             detectTapGestures(
                 onDoubleTap = {
                     coroutineScope.launch {
-                        animatedZoomState.onDoubleTap {}
+                        val newZoom = zoomOnDoubleTap(zoomLevel)
+                        zoomLevel = getNextZoomLevel(zoomLevel)
+                        animatedZoomState.onDoubleTap(zoom = newZoom) {}
                     }
                 }
             )

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

@@ -40,8 +40,6 @@ open class AnimatedZoomState constructor(
 
         val maxX = ((contentWidth * zoom - size.width) / 2f).coerceAtLeast(0f)
         val maxY = ((contentHeight * zoom - size.height) / 2f).coerceAtLeast(0f)
-
-        println("🎾 GetBounds zoom:$zoom, size: $size, maxX: $maxX, maxY: $maxY")
         return Offset(maxX, maxY)
     }
 }