Added minimum dimension crop property

Author: Nimrodda

cropper/src/main/java/com/smarttoolfactory/cropper/settings/CropDefaults.kt

@@ -39,7 +39,8 @@ object CropDefaults {
         zoomable: Boolean = true,
         rotatable: Boolean = false,
         fixedAspectRatio: Boolean = false,
-        requiredSize: IntSize? = null
+        requiredSize: IntSize? = null,
+        minDimension: IntSize? = null,
     ): CropProperties {
         return CropProperties(
             cropType = cropType,
@@ -54,7 +55,8 @@ object CropDefaults {
             zoomable = zoomable,
             rotatable = rotatable,
             fixedAspectRatio = fixedAspectRatio,
-            requiredSize = requiredSize
+            requiredSize = requiredSize,
+            minDimension = minDimension,
         )
     }
 
@@ -100,7 +102,8 @@ data class CropProperties internal constructor(
     val zoomable: Boolean,
     val maxZoom: Float,
     val fixedAspectRatio: Boolean = false,
-    val requiredSize: IntSize? = null
+    val requiredSize: IntSize? = null,
+    val minDimension: IntSize? = null,
 )
 
 /**

cropper/src/main/java/com/smarttoolfactory/cropper/state/CropState.kt

@@ -29,7 +29,6 @@ fun rememberCropState(
 
     // Properties of crop state
     val handleSize = cropProperties.handleSize
-    val minOverlaySize = handleSize * 2
     val cropType = cropProperties.cropType
     val aspectRatio = cropProperties.aspectRatio
     val overlayRatio = cropProperties.overlayRatio
@@ -39,6 +38,7 @@ fun rememberCropState(
     val pannable = cropProperties.pannable
     val rotatable = cropProperties.rotatable
     val fixedAspectRatio = cropProperties.fixedAspectRatio
+    val minDimension = cropProperties.minDimension
 
     return remember(*keys) {
         when (cropType) {
@@ -67,13 +67,13 @@ fun rememberCropState(
                     overlayRatio = overlayRatio,
                     maxZoom = maxZoom,
                     handleSize = handleSize,
-                    minOverlaySize = minOverlaySize,
                     fling = fling,
                     zoomable = zoomable,
                     pannable = pannable,
                     rotatable = rotatable,
                     limitPan = true,
                     fixedAspectRatio = fixedAspectRatio,
+                    minDimension = minDimension,
                 )
             }
         }

cropper/src/main/java/com/smarttoolfactory/cropper/state/DynamicCropState.kt

@@ -10,14 +10,14 @@ import com.smarttoolfactory.cropper.TouchRegion
 import com.smarttoolfactory.cropper.model.AspectRatio
 import com.smarttoolfactory.cropper.settings.CropProperties
 import kotlinx.coroutines.coroutineScope
+import kotlin.math.roundToInt
 
 /**
  * State for cropper with dynamic overlay. Overlay of this state can be moved or resized
  * using handles or touching inner position of overlay. When overlay overflow out of image bounds
  * or moves out of bounds it animates back to valid size and position
  *
  * @param handleSize size of the handle to control, move or scale dynamic overlay
- * @param minOverlaySize minimum overlay size that can be shrunk to by moving handles
  * @param imageSize size of the **Bitmap**
  * @param containerSize size of the Composable that draws **Bitmap**
  * @param maxZoom maximum zoom value
@@ -29,11 +29,11 @@ import kotlinx.coroutines.coroutineScope
  * @param rotatable when set to true rotation is enabled
  * @param limitPan limits pan to bounds of parent Composable. Using this flag prevents creating
  * @param fixedAspectRatio when set to true aspect ratio of overlay is fixed
+ * @param minDimension minimum size of the overlay, if null defaults to handleSize * 2
  * empty space on sides or edges of parent
  */
 class DynamicCropState internal constructor(
     private var handleSize: Float,
-    private var minOverlaySize: Float,
     imageSize: IntSize,
     containerSize: IntSize,
     drawAreaSize: IntSize,
@@ -46,6 +46,7 @@ class DynamicCropState internal constructor(
     rotatable: Boolean,
     limitPan: Boolean,
     private val fixedAspectRatio: Boolean,
+    private val minDimension: IntSize?
 ) : CropState(
     imageSize = imageSize,
     containerSize = containerSize,
@@ -87,8 +88,6 @@ class DynamicCropState internal constructor(
 
     override suspend fun updateProperties(cropProperties: CropProperties, forceUpdate: Boolean) {
         handleSize = cropProperties.handleSize
-        minOverlaySize = handleSize * 2
-
         super.updateProperties(cropProperties, forceUpdate)
     }
 
@@ -131,12 +130,17 @@ class DynamicCropState internal constructor(
 
             val change = changes.first()
 
+            // Default min dimension is handle size * 2
+            val doubleHandleSize = handleSize * 2
+            val defaultMinDimension =
+                IntSize(doubleHandleSize.roundToInt(), doubleHandleSize.roundToInt())
+
             // update overlay rectangle based on where its touched and touch position to corners
             // This function moves and/or scales overlay rectangle
             val newRect = updateOverlayRect(
                 distanceToEdgeFromTouch = distanceToEdgeFromTouch,
                 touchRegion = touchRegion,
-                minDimension = minOverlaySize,
+                minDimension = minDimension ?: defaultMinDimension,
                 rectTemp = rectTemp,
                 overlayRect = overlayRect,
                 change = change,
@@ -359,7 +363,7 @@ class DynamicCropState internal constructor(
     private fun updateOverlayRect(
         distanceToEdgeFromTouch: Offset,
         touchRegion: TouchRegion,
-        minDimension: Float,
+        minDimension: IntSize,
         rectTemp: Rect,
         overlayRect: Rect,
         change: PointerInputChange,
@@ -380,15 +384,15 @@ class DynamicCropState internal constructor(
 
                 // Set position of top left while moving with top left handle and
                 // limit position to not intersect other handles
-                val left = screenPositionX.coerceAtMost(rectTemp.right - minDimension)
+                val left = screenPositionX.coerceAtMost(rectTemp.right - minDimension.width)
                 val top = if (fixedAspectRatio) {
                     // If aspect ratio is fixed we need to calculate top position based on
                     // left position and aspect ratio
                     val width = rectTemp.right - left
                     val height = width / aspectRatio
                     rectTemp.bottom - height
                 } else {
-                    screenPositionY.coerceAtMost(rectTemp.bottom - minDimension)
+                    screenPositionY.coerceAtMost(rectTemp.bottom - minDimension.height)
                 }
                 Rect(
                     left = left,
@@ -402,15 +406,15 @@ class DynamicCropState internal constructor(
 
                 // Set position of top left while moving with bottom left handle and
                 // limit position to not intersect other handles
-                val left = screenPositionX.coerceAtMost(rectTemp.right - minDimension)
+                val left = screenPositionX.coerceAtMost(rectTemp.right - minDimension.width)
                 val bottom = if (fixedAspectRatio) {
                     // If aspect ratio is fixed we need to calculate bottom position based on
                     // left position and aspect ratio
                     val width = rectTemp.right - left
                     val height = width / aspectRatio
                     rectTemp.top + height
                 } else {
-                    screenPositionY.coerceAtLeast(rectTemp.top + minDimension)
+                    screenPositionY.coerceAtLeast(rectTemp.top + minDimension.height)
                 }
                 Rect(
                     left = left,
@@ -424,15 +428,15 @@ class DynamicCropState internal constructor(
 
                 // Set position of top left while moving with top right handle and
                 // limit position to not intersect other handles
-                val right = screenPositionX.coerceAtLeast(rectTemp.left + minDimension)
+                val right = screenPositionX.coerceAtLeast(rectTemp.left + minDimension.width)
                 val top = if (fixedAspectRatio) {
                     // If aspect ratio is fixed we need to calculate top position based on
                     // right position and aspect ratio
                     val width = right - rectTemp.left
                     val height = width / aspectRatio
                     rectTemp.bottom - height
                 } else {
-                    screenPositionY.coerceAtMost(rectTemp.bottom - minDimension)
+                    screenPositionY.coerceAtMost(rectTemp.bottom - minDimension.height)
                 }
 
                 Rect(
@@ -448,15 +452,15 @@ class DynamicCropState internal constructor(
 
                 // Set position of top left while moving with bottom right handle and
                 // limit position to not intersect other handles
-                val right = screenPositionX.coerceAtLeast(rectTemp.left + minDimension)
+                val right = screenPositionX.coerceAtLeast(rectTemp.left + minDimension.width)
                 val bottom = if (fixedAspectRatio) {
                     // If aspect ratio is fixed we need to calculate bottom position based on
                     // right position and aspect ratio
                     val width = right - rectTemp.left
                     val height = width / aspectRatio
                     rectTemp.top + height
                 } else {
-                    screenPositionY.coerceAtLeast(rectTemp.top + minDimension)
+                    screenPositionY.coerceAtLeast(rectTemp.top + minDimension.height)
                 }
 
                 Rect(