update SpinningProgressIndicator

* calculates draw area dimensions to be equal to each other

Author: SmartToolFactory

progressindicator/src/main/java/com/smarttoolfactory/progressindicator/SpinningProgressIndicator.kt

@@ -2,6 +2,7 @@ package com.smarttoolfactory.progressindicator
 
 import androidx.compose.animation.core.*
 import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.border
 import androidx.compose.foundation.layout.size
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
@@ -19,87 +20,111 @@ enum class SpinnerShape {
     Rect, RoundedRect
 }
 
+/**
+ * Indeterminate Material Design spinning progress indicator with rectangle or rounded rectangle
+ * shape.
+ * @param staticItemColor color of the spinning items
+ * @param dynamicItemColor color of the stationary items
+ * @param spinnerShape shape of the items whether [SpinnerShape.Rect] or [SpinnerShape.RoundedRect]
+ * @param durationMillis duration of one cycle of spinning
+ */
 @Composable
 fun SpinningProgressIndicator(
     modifier: Modifier = Modifier,
     staticItemColor: Color = StaticItemColor,
     dynamicItemColor: Color = DynamicItemColor,
     spinnerShape: SpinnerShape = SpinnerShape.RoundedRect,
-    durationInMillis: Int = 1000
+    durationMillis: Int = 1000
 ) {
 
     val count = 12
+    val coefficient = 360f / count
 
     val infiniteTransition = rememberInfiniteTransition()
     val angle by infiniteTransition.animateFloat(
         initialValue = 0f,
         targetValue = count.toFloat(),
         animationSpec = infiniteRepeatable(
-            animation = tween(durationInMillis, easing = LinearEasing),
+            animation = tween(
+                durationMillis = durationMillis,
+                easing = LinearEasing
+            ),
             repeatMode = RepeatMode.Restart
         )
     )
 
+    Canvas(
+        modifier = modifier
+            .size(48.dp)
+            .border(1.dp, Color.Red)
+    ) {
 
-    Canvas(modifier = modifier.size(48.dp)) {
+        var canvasWidth = size.width
+        var canvasHeight = size.height
 
-        val canvasWidth = size.width
-        val canvasHeight = size.height
+        if (canvasHeight < canvasWidth) {
+            canvasWidth = canvasHeight
+        } else {
+            canvasHeight = canvasWidth
+        }
+
+        val itemWidth = canvasWidth * .3f
+        val itemHeight = canvasHeight / 12
+
+        val cornerRadius = itemWidth.coerceAtMost(itemHeight) / 2
+
+        val horizontalOffset = (size.width - size.height).coerceAtLeast(0f) / 2
+        val verticalOffset = (size.height - size.width).coerceAtLeast(0f) / 2
 
-        val width = canvasWidth * .3f
-        val height = canvasHeight / 12
+        val topLeftOffset = Offset(
+            x = horizontalOffset + canvasWidth - itemWidth,
+            y = verticalOffset + (canvasHeight - itemHeight) / 2
+        )
 
-        val cornerRadius = width.coerceAtMost(height) / 2
+        val size = Size(itemWidth, itemHeight)
 
         // Stationary items
         for (i in 0..360 step 360 / count) {
             rotate(i.toFloat()) {
                 if (spinnerShape == SpinnerShape.RoundedRect) {
                     drawRoundRect(
                         color = staticItemColor,
-                        topLeft = Offset(canvasWidth - width, (canvasHeight - height) / 2),
-                        size = Size(width, height),
+                        topLeft = topLeftOffset,
+                        size = size,
                         cornerRadius = CornerRadius(cornerRadius, cornerRadius)
                     )
                 } else {
                     drawRect(
                         color = staticItemColor,
-                        topLeft = Offset(canvasWidth - width, (canvasHeight - height) / 2),
-                        size = Size(width, height)
+                        topLeft = topLeftOffset,
+                        size = size,
                     )
                 }
             }
         }
 
-            val coefficient = 360f / count
-
-            // Dynamic items
-            for (i in 0..count / 2) {
-                rotate((angle.toInt() + i) * coefficient) {
-                    if (spinnerShape == SpinnerShape.RoundedRect) {
-                        drawRoundRect(
-                            color = dynamicItemColor.copy(
-                                alpha = (0.2f + 0.15f * i).coerceIn(
-                                    0f, 1f
-                                )
-                            ),
-                            topLeft = Offset(canvasWidth - width, (canvasHeight - height) / 2),
-                            size = Size(width, height),
-                            cornerRadius = CornerRadius(cornerRadius, cornerRadius)
-                        )
-                    } else {
-                        drawRect(
-                            color = dynamicItemColor.copy(
-                                alpha = (0.2f + 0.15f * i).coerceIn(
-                                    0f, 1f
-                                )
-                            ),
-                            topLeft = Offset(canvasWidth - width, (canvasHeight - height) / 2),
-                            size = Size(width, height)
-                        )
-                    }
+        // Dynamic items
+        for (i in 0..count / 2) {
+            rotate((angle.toInt() + i) * coefficient) {
+                if (spinnerShape == SpinnerShape.RoundedRect) {
+                    drawRoundRect(
+                        color = dynamicItemColor.copy(alpha = (0.2f + 0.15f * i).coerceIn(0f, 1f)),
+                        topLeft = topLeftOffset,
+                        size = size,
+                        cornerRadius = CornerRadius(cornerRadius, cornerRadius)
+                    )
+                } else {
+                    drawRect(
+                        color = dynamicItemColor.copy(
+                            alpha = (0.2f + 0.15f * i).coerceIn(
+                                0f, 1f
+                            )
+                        ),
+                        topLeft = topLeftOffset,
+                        size = size,
+                    )
                 }
             }
+        }
     }
 }
-