From d07268578152c3b1cb49c68661edebf91fb885b4 Mon Sep 17 00:00:00 2001
From: Cheon Jaeung <cheonjaewoong@gmail.com>
Date: Sat, 11 Oct 2025 13:11:05 +0900
Subject: [PATCH 1/5] Add SimpleGridCells.FixedSize

---
 grid/api/android/grid.api                     |  10 +
 grid/api/jvm/grid.api                         |  10 +
 .../compose/grid/SimpleGridCells.kt           |  59 +++
 .../cheonjaeung/compose/grid/BoxGridTest.kt   | 450 ++++++++++++++++++
 .../compose/grid/HorizontalGridTest.kt        | 135 ++++++
 .../compose/grid/VerticalGridTest.kt          | 115 +++++
 ...st_testAdaptiveRowsAndFixedSizeColumns.png | Bin 0 -> 4569 bytes
 ...veRowsAndFixedSizeColumnsWithFillFalse.png | Bin 0 -> 4569 bytes
 ...dTest_testFixedRowsAndFixedSizeColumns.png | Bin 0 -> 5140 bytes
 ...edRowsAndFixedSizeColumnsWithFillFalse.png | Bin 0 -> 4057 bytes
 ...t_testFixedSizeRowsAndFixedSizeColumns.png | Bin 0 -> 4492 bytes
 ...zeRowsAndFixedSizeColumnsWithFillFalse.png | Bin 0 -> 4492 bytes
 ...d_HorizontalGridTest_testFixedSizeRows.png | Bin 0 -> 4406 bytes
 ...ridTest_testFixedSizeRowsWithFillFalse.png | Bin 0 -> 4237 bytes
 ..._VerticalGridTest_testFixedSizeColumns.png | Bin 0 -> 4041 bytes
 ...Test_testFixedSizeColumnsWithFillFalse.png | Bin 0 -> 4344 bytes
 16 files changed, 779 insertions(+)
 create mode 100644 grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testAdaptiveRowsAndFixedSizeColumns.png
 create mode 100644 grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testAdaptiveRowsAndFixedSizeColumnsWithFillFalse.png
 create mode 100644 grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedRowsAndFixedSizeColumns.png
 create mode 100644 grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedRowsAndFixedSizeColumnsWithFillFalse.png
 create mode 100644 grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedSizeRowsAndFixedSizeColumns.png
 create mode 100644 grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedSizeRowsAndFixedSizeColumnsWithFillFalse.png
 create mode 100644 grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_HorizontalGridTest_testFixedSizeRows.png
 create mode 100644 grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_HorizontalGridTest_testFixedSizeRowsWithFillFalse.png
 create mode 100644 grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_VerticalGridTest_testFixedSizeColumns.png
 create mode 100644 grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_VerticalGridTest_testFixedSizeColumnsWithFillFalse.png

diff --git a/grid/api/android/grid.api b/grid/api/android/grid.api
index 1143dcc..b6c4c92 100644
--- a/grid/api/android/grid.api
+++ b/grid/api/android/grid.api
@@ -91,3 +91,13 @@ public final class com/cheonjaeung/compose/grid/SimpleGridCells$Fixed : com/cheo
 	public fun hashCode ()I
 }
 
+public final class com/cheonjaeung/compose/grid/SimpleGridCells$FixedSize : com/cheonjaeung/compose/grid/SimpleGridCells {
+	public static final field $stable I
+	public synthetic fun <init> (FZILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public synthetic fun <init> (FZLkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public fun calculateCrossAxisCellSizes (Landroidx/compose/ui/unit/Density;II)Ljava/util/List;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun fillCellSize ()Z
+	public fun hashCode ()I
+}
+
diff --git a/grid/api/jvm/grid.api b/grid/api/jvm/grid.api
index 1143dcc..b6c4c92 100644
--- a/grid/api/jvm/grid.api
+++ b/grid/api/jvm/grid.api
@@ -91,3 +91,13 @@ public final class com/cheonjaeung/compose/grid/SimpleGridCells$Fixed : com/cheo
 	public fun hashCode ()I
 }
 
+public final class com/cheonjaeung/compose/grid/SimpleGridCells$FixedSize : com/cheonjaeung/compose/grid/SimpleGridCells {
+	public static final field $stable I
+	public synthetic fun <init> (FZILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public synthetic fun <init> (FZLkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public fun calculateCrossAxisCellSizes (Landroidx/compose/ui/unit/Density;II)Ljava/util/List;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun fillCellSize ()Z
+	public fun hashCode ()I
+}
+
diff --git a/grid/src/commonMain/kotlin/com/cheonjaeung/compose/grid/SimpleGridCells.kt b/grid/src/commonMain/kotlin/com/cheonjaeung/compose/grid/SimpleGridCells.kt
index 48dbbb7..df55531 100644
--- a/grid/src/commonMain/kotlin/com/cheonjaeung/compose/grid/SimpleGridCells.kt
+++ b/grid/src/commonMain/kotlin/com/cheonjaeung/compose/grid/SimpleGridCells.kt
@@ -134,4 +134,63 @@ interface SimpleGridCells {
             return hash
         }
     }
+
+    /**
+     * Make grid to have as many rows or columns as possible and each cell has exactly [size].
+     * If [size] is bigger than container's size, the cell will have the same size to the container.
+     *
+     * For example, `FixedSize(20.dp)` for `VerticalGrid(Modifier.width(66.dp)` means that there
+     * will be 3 columns and each cell will have 20dp width and 6dp is remained.
+     *
+     * In other case, `FixedSize(150.dp)` for `VerticalGrid(Modifier.width(100.dp)` means that there
+     * will be only one column and the cell will have 100dp width.
+     *
+     * @param size The size which each cell should have.
+     * @param fill When `true`, item composable fill cell's width or height.
+     */
+    @ExperimentalGridApi
+    class FixedSize(
+        private val size: Dp,
+        private val fill: Boolean = true,
+    ) : SimpleGridCells {
+        init {
+            if (size <= 0.dp) {
+                throw IllegalArgumentException("FixedSize size must be a positive, but $size")
+            }
+        }
+
+        override fun Density.calculateCrossAxisCellSizes(
+            availableSize: Int,
+            spacing: Int
+        ): List<Int> {
+            val cellSize = size.roundToPx()
+            val availableSizeWithSpacing = availableSize + spacing
+            val cellSizeWithSpacing = cellSize + spacing
+
+            return if (cellSizeWithSpacing < availableSizeWithSpacing) {
+                val count = availableSizeWithSpacing / cellSizeWithSpacing
+                return List(count) { cellSize }
+            } else {
+                List(1) { availableSize }
+            }
+        }
+
+        override fun fillCellSize(): Boolean {
+            return fill
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (other !is FixedSize) return false
+            if (this.size != other.size) return false
+            if (this.fill != other.fill) return false
+            return true
+        }
+
+        override fun hashCode(): Int {
+            var hash = 1
+            hash = hash * 31 + size.hashCode()
+            hash = hash * 31 + fill.hashCode()
+            return hash
+        }
+    }
 }
diff --git a/grid/src/test/java/com/cheonjaeung/compose/grid/BoxGridTest.kt b/grid/src/test/java/com/cheonjaeung/compose/grid/BoxGridTest.kt
index d16b83d..2e0207a 100644
--- a/grid/src/test/java/com/cheonjaeung/compose/grid/BoxGridTest.kt
+++ b/grid/src/test/java/com/cheonjaeung/compose/grid/BoxGridTest.kt
@@ -711,6 +711,456 @@ class BoxGridTest {
         }
     }
 
+    @Test
+    fun testFixedRowsAndFixedSizeColumns() {
+        paparazzi.snapshot {
+            Column {
+                BoxGrid(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .weight(1f)
+                        .background(Color.LightGray),
+                    rows = SimpleGridCells.Fixed(2),
+                    columns = SimpleGridCells.FixedSize(80.dp)
+                ) {
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .background(Color.Blue)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .position(row = 1, column = 1)
+                            .background(Color.Green)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .position(row = 2, column = 2)
+                            .background(Color.Yellow)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .position(row = 3, column = 1)
+                            .background(Color.Red)
+                    )
+                }
+
+                CompositionLocalProvider(LocalLayoutDirection provides LayoutDirection.Rtl) {
+                    BoxGrid(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .weight(1f)
+                            .background(Color.Gray),
+                        rows = SimpleGridCells.Fixed(2),
+                        columns = SimpleGridCells.FixedSize(80.dp)
+                    ) {
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .background(Color.Blue)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .position(row = 1, column = 1)
+                                .background(Color.Green)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .position(row = 2, column = 2)
+                                .background(Color.Yellow)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .position(row = 3, column = 1)
+                                .background(Color.Red)
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun testFixedRowsAndFixedSizeColumnsWithFillFalse() {
+        paparazzi.snapshot {
+            Column {
+                BoxGrid(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .weight(1f)
+                        .background(Color.LightGray),
+                    rows = SimpleGridCells.Fixed(2, fill = false),
+                    columns = SimpleGridCells.FixedSize(80.dp, fill = false)
+                ) {
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .background(Color.Blue)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .position(row = 1, column = 1)
+                            .background(Color.Green)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .position(row = 2, column = 2)
+                            .background(Color.Yellow)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .position(row = 3, column = 1)
+                            .background(Color.Red)
+                    )
+                }
+
+                CompositionLocalProvider(LocalLayoutDirection provides LayoutDirection.Rtl) {
+                    BoxGrid(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .weight(1f)
+                            .background(Color.Gray),
+                        rows = SimpleGridCells.Fixed(2, fill = false),
+                        columns = SimpleGridCells.FixedSize(80.dp, fill = false)
+                    ) {
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .background(Color.Blue)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .position(row = 1, column = 1)
+                                .background(Color.Green)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .position(row = 2, column = 2)
+                                .background(Color.Yellow)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .position(row = 3, column = 1)
+                                .background(Color.Red)
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun testAdaptiveRowsAndFixedSizeColumns() {
+        paparazzi.snapshot {
+            Column {
+                BoxGrid(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .weight(1f)
+                        .background(Color.LightGray),
+                    rows = SimpleGridCells.Adaptive(60.dp),
+                    columns = SimpleGridCells.FixedSize(80.dp)
+                ) {
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .background(Color.Blue)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .position(row = 1, column = 1)
+                            .background(Color.Green)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .position(row = 2, column = 2)
+                            .background(Color.Yellow)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .position(row = 3, column = 1)
+                            .background(Color.Red)
+                    )
+                }
+
+                CompositionLocalProvider(LocalLayoutDirection provides LayoutDirection.Rtl) {
+                    BoxGrid(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .weight(1f)
+                            .background(Color.Gray),
+                        rows = SimpleGridCells.Adaptive(60.dp),
+                        columns = SimpleGridCells.FixedSize(80.dp)
+                    ) {
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .background(Color.Blue)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .position(row = 1, column = 1)
+                                .background(Color.Green)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .position(row = 2, column = 2)
+                                .background(Color.Yellow)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .position(row = 3, column = 1)
+                                .background(Color.Red)
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun testAdaptiveRowsAndFixedSizeColumnsWithFillFalse() {
+        paparazzi.snapshot {
+            Column {
+                BoxGrid(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .weight(1f)
+                        .background(Color.LightGray),
+                    rows = SimpleGridCells.Adaptive(60.dp, fill = false),
+                    columns = SimpleGridCells.FixedSize(80.dp, fill = false)
+                ) {
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .background(Color.Blue)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .position(row = 1, column = 1)
+                            .background(Color.Green)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .position(row = 2, column = 2)
+                            .background(Color.Yellow)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .position(row = 3, column = 1)
+                            .background(Color.Red)
+                    )
+                }
+
+                CompositionLocalProvider(LocalLayoutDirection provides LayoutDirection.Rtl) {
+                    BoxGrid(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .weight(1f)
+                            .background(Color.Gray),
+                        rows = SimpleGridCells.Adaptive(60.dp, fill = false),
+                        columns = SimpleGridCells.FixedSize(80.dp, fill = false)
+                    ) {
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .background(Color.Blue)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .position(row = 1, column = 1)
+                                .background(Color.Green)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .position(row = 2, column = 2)
+                                .background(Color.Yellow)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .position(row = 3, column = 1)
+                                .background(Color.Red)
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun testFixedSizeRowsAndFixedSizeColumns() {
+        paparazzi.snapshot {
+            Column {
+                BoxGrid(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .weight(1f)
+                        .background(Color.LightGray),
+                    rows = SimpleGridCells.FixedSize(60.dp),
+                    columns = SimpleGridCells.FixedSize(80.dp)
+                ) {
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .background(Color.Blue)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .position(row = 1, column = 1)
+                            .background(Color.Green)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .position(row = 2, column = 2)
+                            .background(Color.Yellow)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .position(row = 3, column = 1)
+                            .background(Color.Red)
+                    )
+                }
+
+                CompositionLocalProvider(LocalLayoutDirection provides LayoutDirection.Rtl) {
+                    BoxGrid(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .weight(1f)
+                            .background(Color.Gray),
+                        rows = SimpleGridCells.FixedSize(60.dp),
+                        columns = SimpleGridCells.FixedSize(80.dp)
+                    ) {
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .background(Color.Blue)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .position(row = 1, column = 1)
+                                .background(Color.Green)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .position(row = 2, column = 2)
+                                .background(Color.Yellow)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .position(row = 3, column = 1)
+                                .background(Color.Red)
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun testFixedSizeRowsAndFixedSizeColumnsWithFillFalse() {
+        paparazzi.snapshot {
+            Column {
+                BoxGrid(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .weight(1f)
+                        .background(Color.LightGray),
+                    rows = SimpleGridCells.FixedSize(60.dp, fill = false),
+                    columns = SimpleGridCells.FixedSize(80.dp, fill = false)
+                ) {
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .background(Color.Blue)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .position(row = 1, column = 1)
+                            .background(Color.Green)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .position(row = 2, column = 2)
+                            .background(Color.Yellow)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .position(row = 3, column = 1)
+                            .background(Color.Red)
+                    )
+                }
+
+                CompositionLocalProvider(LocalLayoutDirection provides LayoutDirection.Rtl) {
+                    BoxGrid(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .weight(1f)
+                            .background(Color.Gray),
+                        rows = SimpleGridCells.FixedSize(60.dp, fill = false),
+                        columns = SimpleGridCells.FixedSize(80.dp, fill = false)
+                    ) {
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .background(Color.Blue)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .position(row = 1, column = 1)
+                                .background(Color.Green)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .position(row = 2, column = 2)
+                                .background(Color.Yellow)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .position(row = 3, column = 1)
+                                .background(Color.Red)
+                        )
+                    }
+                }
+            }
+        }
+    }
+
     @Test
     fun testSpacing() {
         val colors = listOf(
diff --git a/grid/src/test/java/com/cheonjaeung/compose/grid/HorizontalGridTest.kt b/grid/src/test/java/com/cheonjaeung/compose/grid/HorizontalGridTest.kt
index 4e5c22b..a361fec 100644
--- a/grid/src/test/java/com/cheonjaeung/compose/grid/HorizontalGridTest.kt
+++ b/grid/src/test/java/com/cheonjaeung/compose/grid/HorizontalGridTest.kt
@@ -17,6 +17,7 @@ import app.cash.paparazzi.Paparazzi
 import org.junit.Rule
 import org.junit.Test
 
+@OptIn(ExperimentalGridApi::class)
 class HorizontalGridTest {
     @get:Rule
     val paparazzi = Paparazzi(
@@ -307,6 +308,140 @@ class HorizontalGridTest {
         }
     }
 
+    @Test
+    fun testFixedSizeRows() {
+        paparazzi.snapshot {
+            Column {
+                HorizontalGrid(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .weight(1f)
+                        .background(Color.LightGray),
+                    rows = SimpleGridCells.FixedSize(100.dp)
+                ) {
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .background(Color.Blue)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .background(Color.Green)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .background(Color.Yellow)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .background(Color.Red)
+                    )
+                }
+
+                CompositionLocalProvider(LocalLayoutDirection provides LayoutDirection.Rtl) {
+                    HorizontalGrid(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .weight(1f)
+                            .background(Color.Gray),
+                        rows = SimpleGridCells.FixedSize(100.dp)
+                    ) {
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .background(Color.Blue)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .background(Color.Green)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .background(Color.Yellow)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .background(Color.Red)
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun testFixedSizeRowsWithFillFalse() {
+        paparazzi.snapshot {
+            Column {
+                HorizontalGrid(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .weight(1f)
+                        .background(Color.LightGray),
+                    rows = SimpleGridCells.FixedSize(100.dp, fill = false)
+                ) {
+                    Box(
+                        modifier = Modifier
+                            .size(80.dp)
+                            .background(Color.Blue)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(80.dp)
+                            .background(Color.Green)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(80.dp)
+                            .background(Color.Yellow)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(80.dp)
+                            .background(Color.Red)
+                    )
+                }
+
+                CompositionLocalProvider(LocalLayoutDirection provides LayoutDirection.Rtl) {
+                    HorizontalGrid(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .weight(1f)
+                            .background(Color.Gray),
+                        rows = SimpleGridCells.FixedSize(100.dp, fill = false)
+                    ) {
+                        Box(
+                            modifier = Modifier
+                                .size(80.dp)
+                                .background(Color.Blue)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(80.dp)
+                                .background(Color.Green)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(80.dp)
+                                .background(Color.Yellow)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(80.dp)
+                                .background(Color.Red)
+                        )
+                    }
+                }
+            }
+        }
+    }
+
     @Test
     fun testBreakDownToNextLine() {
         val colors = listOf(
diff --git a/grid/src/test/java/com/cheonjaeung/compose/grid/VerticalGridTest.kt b/grid/src/test/java/com/cheonjaeung/compose/grid/VerticalGridTest.kt
index 38cc52a..2fb8762 100644
--- a/grid/src/test/java/com/cheonjaeung/compose/grid/VerticalGridTest.kt
+++ b/grid/src/test/java/com/cheonjaeung/compose/grid/VerticalGridTest.kt
@@ -17,6 +17,7 @@ import app.cash.paparazzi.Paparazzi
 import org.junit.Rule
 import org.junit.Test
 
+@OptIn(ExperimentalGridApi::class)
 class VerticalGridTest {
     @get:Rule
     val paparazzi = Paparazzi(
@@ -287,6 +288,120 @@ class VerticalGridTest {
         }
     }
 
+    @Test
+    fun testFixedSizeColumns() {
+        paparazzi.snapshot {
+            Column {
+                VerticalGrid(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .weight(1f)
+                        .background(Color.LightGray),
+                    columns = SimpleGridCells.FixedSize(120.dp)
+                ) {
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .background(Color.Blue)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .background(Color.Green)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .background(Color.Yellow)
+                    )
+                }
+
+                CompositionLocalProvider(LocalLayoutDirection provides LayoutDirection.Rtl) {
+                    VerticalGrid(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .weight(1f)
+                            .background(Color.Gray),
+                        columns = SimpleGridCells.FixedSize(120.dp)
+                    ) {
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .background(Color.Blue)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .background(Color.Green)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .background(Color.Yellow)
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun testFixedSizeColumnsWithFillFalse() {
+        paparazzi.snapshot {
+            Column {
+                VerticalGrid(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .weight(1f)
+                        .background(Color.LightGray),
+                    columns = SimpleGridCells.FixedSize(120.dp, fill = false)
+                ) {
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .background(Color.Blue)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .background(Color.Green)
+                    )
+                    Box(
+                        modifier = Modifier
+                            .size(100.dp)
+                            .background(Color.Yellow)
+                    )
+                }
+
+                CompositionLocalProvider(LocalLayoutDirection provides LayoutDirection.Rtl) {
+                    VerticalGrid(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .weight(1f)
+                            .background(Color.Gray),
+                        columns = SimpleGridCells.FixedSize(120.dp, fill = false)
+                    ) {
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .background(Color.Blue)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .background(Color.Green)
+                        )
+                        Box(
+                            modifier = Modifier
+                                .size(100.dp)
+                                .background(Color.Yellow)
+                        )
+                    }
+                }
+            }
+        }
+    }
+
     @Test
     fun testBreakDownToNextLine() {
         val colors = listOf(
diff --git a/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testAdaptiveRowsAndFixedSizeColumns.png b/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testAdaptiveRowsAndFixedSizeColumns.png
new file mode 100644
index 0000000000000000000000000000000000000000..9017eeeeb899cc3451ad0d15490920e187e13fe1
GIT binary patch
literal 4569
zcmdUzT}YEr7{|}vhMbLzGaY0fn8(x>mb5Zgp)pUZZJ4@QWKg0JNc4G8L4?R!?{Zye
zV;8#+!WMm82vadjZ%R`{v1n=`mQq6Df}{wgB+{O<x)3rjw^t{7F8(~cyytyB&yQWV
z<Qb!ttCa|$XtT*sfROAdLdya;3Ou>>Q<(^<ZkY|)2QR%I8_=E<tm<pMkCIku9XXcz
z@}`@qB<YN@!L;U+(0{k4FD=gG{cyoIQtENJTDH2|UktYPY_IVYBz9R(t-If^uqjgQ
z$s%G-B4EmJf{3Y&B!=i<fi5Iku#7M&*JB4kRLvI4LDie6oG_8-v5FyTz%r4{+wo4z
zcGSGJubr68dN{DzTxPpsWdYUKmyh=~JZRBEs1P&+?tsHWm4w|$5E+J|XhdESX{6Fi
zloZZ60k8LxY9hdCDR7?BtB}Oa0-d}Wcma4%ge>(qOAJN;UoSut^I(Fq3s;REKV5gk
zJ#_ZG`)FGJ?siP~7cGCH?C$;cs*;L4xA4<|SQ_#$e617ufKO-`q?25h!yp)NHjITx
zW=ablj$4S-d@mkvS}}b<X&#D$5@=xOXrL&eOYAlB#RDO!86SFSB+R#i@Gge+0wb@2
zqa3hUB$2!#q331B8?d)x_7tsZGrs8@7}3Y*qA*2sG+2R%un0BLzXv6Vk!aATNRMTa
zX>k1@8xa=QTJu@+n=!%mV`H+ZFMas)bbM8ev^*it35gG8VT}25fZr<ciwuSq!*xvg
zazr6GGVe|F?DCAclNtv%m=D$JsC>%zv0CHF&}B3f2jV%Z&2k@$79Zz0njT!GxxtMW
z%NMFY-0tU<LEr!kg+MW9j|h_*@$V!BDUaU*;mrx{pUhm}U5-a?7r8n{3-K|vwyZJ5
zs1yB55L~dgL_q;roWu_Fg2N!;y5T%e<v=eg_D2F!a+Yx{P>NdbT+H1zUhnEy(rw!o
zBM}_UfG()Wf=u=n`_IzYx+XWT$Xvl?j(qd`vB;(zg2ae4I*ui&#($OWUk|eYm4sTG
aYtO|zd;g`dV&_%(%LbYE<{5mf#QqDFnz*k3

literal 0
HcmV?d00001

diff --git a/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testAdaptiveRowsAndFixedSizeColumnsWithFillFalse.png b/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testAdaptiveRowsAndFixedSizeColumnsWithFillFalse.png
new file mode 100644
index 0000000000000000000000000000000000000000..9017eeeeb899cc3451ad0d15490920e187e13fe1
GIT binary patch
literal 4569
zcmdUzT}YEr7{|}vhMbLzGaY0fn8(x>mb5Zgp)pUZZJ4@QWKg0JNc4G8L4?R!?{Zye
zV;8#+!WMm82vadjZ%R`{v1n=`mQq6Df}{wgB+{O<x)3rjw^t{7F8(~cyytyB&yQWV
z<Qb!ttCa|$XtT*sfROAdLdya;3Ou>>Q<(^<ZkY|)2QR%I8_=E<tm<pMkCIku9XXcz
z@}`@qB<YN@!L;U+(0{k4FD=gG{cyoIQtENJTDH2|UktYPY_IVYBz9R(t-If^uqjgQ
z$s%G-B4EmJf{3Y&B!=i<fi5Iku#7M&*JB4kRLvI4LDie6oG_8-v5FyTz%r4{+wo4z
zcGSGJubr68dN{DzTxPpsWdYUKmyh=~JZRBEs1P&+?tsHWm4w|$5E+J|XhdESX{6Fi
zloZZ60k8LxY9hdCDR7?BtB}Oa0-d}Wcma4%ge>(qOAJN;UoSut^I(Fq3s;REKV5gk
zJ#_ZG`)FGJ?siP~7cGCH?C$;cs*;L4xA4<|SQ_#$e617ufKO-`q?25h!yp)NHjITx
zW=ablj$4S-d@mkvS}}b<X&#D$5@=xOXrL&eOYAlB#RDO!86SFSB+R#i@Gge+0wb@2
zqa3hUB$2!#q331B8?d)x_7tsZGrs8@7}3Y*qA*2sG+2R%un0BLzXv6Vk!aATNRMTa
zX>k1@8xa=QTJu@+n=!%mV`H+ZFMas)bbM8ev^*it35gG8VT}25fZr<ciwuSq!*xvg
zazr6GGVe|F?DCAclNtv%m=D$JsC>%zv0CHF&}B3f2jV%Z&2k@$79Zz0njT!GxxtMW
z%NMFY-0tU<LEr!kg+MW9j|h_*@$V!BDUaU*;mrx{pUhm}U5-a?7r8n{3-K|vwyZJ5
zs1yB55L~dgL_q;roWu_Fg2N!;y5T%e<v=eg_D2F!a+Yx{P>NdbT+H1zUhnEy(rw!o
zBM}_UfG()Wf=u=n`_IzYx+XWT$Xvl?j(qd`vB;(zg2ae4I*ui&#($OWUk|eYm4sTG
aYtO|zd;g`dV&_%(%LbYE<{5mf#QqDFnz*k3

literal 0
HcmV?d00001

diff --git a/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedRowsAndFixedSizeColumns.png b/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedRowsAndFixedSizeColumns.png
new file mode 100644
index 0000000000000000000000000000000000000000..eccc73de36636dee9ae4b80d8ecbd4f28d1a2c34
GIT binary patch
literal 5140
zcmeAS@N?(olHy`uVBq!ia0y~yU_8XY!2E)P4JhKf;hzlygYa!n7srr_TW_y9@-is$
zxE}0s=8h6LCMbL3MV7*BA->7;4G)-AN(;`s@}l;66n8^=YXYZYgMd;CgHwk96NjP`
zhe8VnWdaKYtc(~GMVuH~0yr22oD^9cI9de;NWg)E)tiH{ML>~7z^O&RfkV)VLD7W*
z0g$%_iPymHpvW^A0isxv!r-LQ!oaamfJvdniK9V)OL2e%fL2eVQhEfZX^^*oxQ}N5
z6C+B>5pcRFL}6k?j=um7SxMSQSAmFAf57th^Ab~wlYzDYlL;`XZ~==8N|_2Ra*n`K
z0+>mGWd<-&(}pSH1kAg@1aP4RXp^FeA`8$qU!Z*=PQo-1ZoSaU2uyUKG8LNsC}TDV
zRB?cPAP6i~frT2#Gt_4Wa6I**VW1!f_#Fu<g$yWfJ8^I<bO+TpGz%G|5T|XzK?<V)
zj=MuKkXi%4d6*8F3=&qL3LcmrKt(JynDj|PWahI6bsWbfI1ktgdQQCd?C1A_DKxI5
zBdE|QL}^%(T_pAi(YE?l6w#qpOA%B#12X|5u!?CVk4eL}^9JOm12r1QWP4IpmA0)G
zCk?8mUdq}zRz4_AK&q!@>h*I_QtywYXQzQ$eEolCRDe2jSW>ls(@r5!&3ggdelr2L
zOnkvLfH1X%&DB~!Nd{Eg1G}w*kGW8w3Nw&E)e@++Mx!u6HyhY!m?6LfY!h)P0vlMs
zj{V?cVzz`E1Wru_Myx`M8n`LP3G7`sWdI%CATW#C!aEJYZGS;fs~=eW0Tb;YW42yU
zhBRr>+s8Br3>*P1uxs!Kk~2mif%>B~OgI=}MZe57=Lds|eUpJ)$Br1_Xdi>8tDnm{
Hr-UW|8SNpn

literal 0
HcmV?d00001

diff --git a/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedRowsAndFixedSizeColumnsWithFillFalse.png b/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedRowsAndFixedSizeColumnsWithFillFalse.png
new file mode 100644
index 0000000000000000000000000000000000000000..fab3254c6d252aa60fcf21556da2f5bc0b46b357
GIT binary patch
literal 4057
zcmeAS@N?(olHy`uVBq!ia0y~yU_8XY!2E)P4JhKf;hzly1OEa~7srr_TW_yA^0pWV
zv|W^X942{ZRtPtfK_kB(3oD1hju}@swBIZ#kN;=G{8lAiQ?*HE@BPAg>I}@<O{y&n
zP8|YF9EwgH3N0Lp4FXCO3OKzu!O#-G!6@LQ$l}1!D!`y9;xteKiXu9SECNm~0uCI4
zP7I1J9E>dj6bQ5ey){_8266|6Xa1?TeE!2?dF^Xa3d7>|3(5=%ErS$sEOcjZ;9wk_
zNWh7Ke&|sCh4*qtFFiX3$|#`33Cb@NGaWc=n*_KNfmwQ?0245S(}t<h;-t~iAi%Yd
z6KIoDh7$+Swpl>?G+NYXBFwc=ni-hzTY>o*ninZ#Dt-|F`#`A$=ypXKF&7G)no7e!
zK@RYphIm7!K;ZS(V}H)56ec$aFcFCqTI3iR6j=r*0w!}71}Ba|h#CZ{SQuIaC`D}C
z4>##B9(X=QNM&Vd{eOEIRbX~gWB{gA22joh<~k1Q3QVJBTL9Fa-~u`m=u|F}nTtVX
zA?=zF4jioBSgKHrI+a)f%8G5w7E+PVWyeX^%<$$sVDe`gglQk*Br4?q%JUFb6Yz#B
z8HJr&(03_NE#4vkOtrv<CNMb+My7~UKd9h9$&J851Xz&+>uyd^TOk8n3(f+!7}RJY
z46Mb4oj_d!MHXOXE;tC8kaj*w+d{x;rx36>YPkSvcq^I!qt}7M7w888Ct+#}n}Zuq
zzz!KOqLe`GC{!lTqFmi&$x5BTK%_}CwPjHE8x$Eh1|@QOA&5OTeuV136uTttH;wH#
Qu*=Ti>FVdQ&MBb@00Lmnh5!Hn

literal 0
HcmV?d00001

diff --git a/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedSizeRowsAndFixedSizeColumns.png b/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedSizeRowsAndFixedSizeColumns.png
new file mode 100644
index 0000000000000000000000000000000000000000..ef8350868c8fdf73418d5007f4414448d6693736
GIT binary patch
literal 4492
zcmdT|T}V_x6du<#XE%&lGy4(6SuOV=(#%{Ft=;kWDl3v@^iXQ0`I0DsL>ex3w=~oi
zje<brQc@(AAqFXh{TU&cMiv<=29*zK7NwP$omqm64BOmGD|a3~4wpMS=bZ0+-)wnm
zN`i-al^P-BAtc6bMabngLaxJj5kyQ)-=YxGqzSRcZHM|so=Pb!YsLMcx7y(W#qt70
zd4)bdG|y|X5FWqbMNW|BV!GB;5Re#UY99HRuUfJ@u6TU#ple<5*QQgR#;Vr5J<ZQh
ze#ePS6*UvBh*%j>V9Kz+i02oONMtCYUJQw;*o82vG++z)PXPmVOU5oDp-RF;V!#@P
zXzUyTb21+4?cHxZck@Wq%g*Y+&F$?18`ivkZ1TPL=v4<l3I7~F;k=;%N0$;cg`7)7
z0Tqx3>O`g!%|tD!U?-N#Fzj{~_S1=LWC^P!A6F>81rlz79{5)n(*Ndw_l*fZVSG|0
zTzhVL7{c)Db$!$72R&geJ~7w`JBS3nZd@R+34Ses{xd=!Is(!U7#LedN`b$a&V&+a
zUGIR@SdaD>`<Zst)YHy9{lv<6ylG&lGct*mJEXopI|L45>rkx-y-8()5)i=F^rfqL
z*Tbj-8fayL4x>Qf)v~F5%u~MzQ}mY$h7}^rNtf6igZxEjTv$p#2JGUTi?EZ(Occ(!
z?5gLOdrU-aimSOUEy;TR(v!jIqKG7!-N9OW<bQ61Fb~;JP=NqrK79~OImA_e?!cMc
z;w@D@cgg~5yWE8@Q$bW&wWF~?cRE~Om@_REaep<7$`W?n6O4-3&21PB1FK@dCQwYm
zmO47Dx7i4J2kLwVwL}j8o+R$w?9Iui=!V{nLS7#!%xDXI_jwtMD9<g~S+lqQSa&5A
zc_rb|0ay?aOW^%yx`x@kgdI^(9`3WL5=@SU{eX~XZh0(@Ns)DQEZbDwmLBI_mqC?X
zQwi~t*}nDGyOlO?3wIdEKjt>q$)Ha3<CmddE)6!~az@^=F_qZ*QN!6O1BCoLB1P8G
zf{2RVOoJzoUKSO1av647TNNNnHSCi1KfR2l<4)?VxUFh08F#zTSdn$5C3rjh%YuZs
Kl-SEGv-CUYBC!ns

literal 0
HcmV?d00001

diff --git a/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedSizeRowsAndFixedSizeColumnsWithFillFalse.png b/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedSizeRowsAndFixedSizeColumnsWithFillFalse.png
new file mode 100644
index 0000000000000000000000000000000000000000..ef8350868c8fdf73418d5007f4414448d6693736
GIT binary patch
literal 4492
zcmdT|T}V_x6du<#XE%&lGy4(6SuOV=(#%{Ft=;kWDl3v@^iXQ0`I0DsL>ex3w=~oi
zje<brQc@(AAqFXh{TU&cMiv<=29*zK7NwP$omqm64BOmGD|a3~4wpMS=bZ0+-)wnm
zN`i-al^P-BAtc6bMabngLaxJj5kyQ)-=YxGqzSRcZHM|so=Pb!YsLMcx7y(W#qt70
zd4)bdG|y|X5FWqbMNW|BV!GB;5Re#UY99HRuUfJ@u6TU#ple<5*QQgR#;Vr5J<ZQh
ze#ePS6*UvBh*%j>V9Kz+i02oONMtCYUJQw;*o82vG++z)PXPmVOU5oDp-RF;V!#@P
zXzUyTb21+4?cHxZck@Wq%g*Y+&F$?18`ivkZ1TPL=v4<l3I7~F;k=;%N0$;cg`7)7
z0Tqx3>O`g!%|tD!U?-N#Fzj{~_S1=LWC^P!A6F>81rlz79{5)n(*Ndw_l*fZVSG|0
zTzhVL7{c)Db$!$72R&geJ~7w`JBS3nZd@R+34Ses{xd=!Is(!U7#LedN`b$a&V&+a
zUGIR@SdaD>`<Zst)YHy9{lv<6ylG&lGct*mJEXopI|L45>rkx-y-8()5)i=F^rfqL
z*Tbj-8fayL4x>Qf)v~F5%u~MzQ}mY$h7}^rNtf6igZxEjTv$p#2JGUTi?EZ(Occ(!
z?5gLOdrU-aimSOUEy;TR(v!jIqKG7!-N9OW<bQ61Fb~;JP=NqrK79~OImA_e?!cMc
z;w@D@cgg~5yWE8@Q$bW&wWF~?cRE~Om@_REaep<7$`W?n6O4-3&21PB1FK@dCQwYm
zmO47Dx7i4J2kLwVwL}j8o+R$w?9Iui=!V{nLS7#!%xDXI_jwtMD9<g~S+lqQSa&5A
zc_rb|0ay?aOW^%yx`x@kgdI^(9`3WL5=@SU{eX~XZh0(@Ns)DQEZbDwmLBI_mqC?X
zQwi~t*}nDGyOlO?3wIdEKjt>q$)Ha3<CmddE)6!~az@^=F_qZ*QN!6O1BCoLB1P8G
zf{2RVOoJzoUKSO1av647TNNNnHSCi1KfR2l<4)?VxUFh08F#zTSdn$5C3rjh%YuZs
Kl-SEGv-CUYBC!ns

literal 0
HcmV?d00001

diff --git a/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_HorizontalGridTest_testFixedSizeRows.png b/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_HorizontalGridTest_testFixedSizeRows.png
new file mode 100644
index 0000000000000000000000000000000000000000..7ecca5ffd66daf690f5b16e0101d10bbe04a4c05
GIT binary patch
literal 4406
zcmeAS@N?(olHy`uVBq!ia0y~yU_8XY!2E)P4JhKf;hzlygTP-;7srr_TW_y#%w%>H
zXuG)b&8vU{Q;on^Aqobo4m2t!&XE#daO7m+%!3P#d@MDLn_BQmP1&|?FI!)ty@=q<
zD@J|Z=RWf|uq)~~aVWHKC^iTvwJ<n!2rzLd4ibTd0$e~>aVau5X|ynKEEHf;XmR2o
zQGjFNhQa7Ha1cAas9<af;9wMRQe<)9Xcb^k6meo8O~8Re(1}6Og@dt0K#@hjsYT#H
zqtgy+wXHq+@B73TL~~qTl^f%BoSTe*L($@t0ZI~T!1OU_85%8p;$#LQINTMdh=M{;
z7#N%;gOwoyOek0rOF}M({@cW*)AAKrUWgys^G_oclq^J?D2jPtPU{{-r2$H*L}_e;
za#>42Op5?U1{xd!iY0qcO1%SX6>YX3pBgkx9~{Fw{%J0mlnN{@NG~x^v<NsQqLm+m
z!~39kX}$1~iOfPDR(1`(Dh*QZ1FJJ&m4>CfN+{*1|NeW)wE34$eq{Q>wXmO|L4av+
zB83(^CI%-C?5JGg(BX#@82;Qh@R6Jt@|X(MT&pXhjvG8_lscs>uw^r7+FU55ET}Pv
zt=YA~sKx)h<Zk7w7I6)JigVg{R-02)(}0V*!P~Tew|TJUSrQr@z|wlKHZ4%wJXqSJ
z33Jbj9rCV@SP9ICRx_hGHruYb0_rf3-!uo6(h4ny23xNKo&&fRK4!(*+9EE-fvUib
zjEF(p$T)x!e+PUOYqAw>*pG53I;<Dq(`^wHQ67z9+}*RG7sKGrv-aM+?LRl(4CoPH
u`f#BI*z05&oXCNrmW2W6K1}rPs=Q9<9_{N{|9XMrAq<|belF{r5}E+Jja$e7

literal 0
HcmV?d00001

diff --git a/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_HorizontalGridTest_testFixedSizeRowsWithFillFalse.png b/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_HorizontalGridTest_testFixedSizeRowsWithFillFalse.png
new file mode 100644
index 0000000000000000000000000000000000000000..7df448809c5ed126555abf687dfca0b91a5d7b83
GIT binary patch
literal 4237
zcmeAS@N?(olHy`uVBq!ia0y~yU_8XY!2E)P4JhKf;hzlygFuL<i(^Q|t+!VVy;K}U
zjz8RW<XAN;|HVdyH=I4*2F4L;W&&*DKB+uDEuO5rt-MPPrnnS1&N*<T^_-e{b$4~^
zLr=%rKfiZ7e0&kFsoEs7)o)|eT84}WK^;XF0jCxL2M$3e21OSR#ufnz1w@?O*%Vrw
zI2r`F6d9Z}S{OJM3NQ_j0LQ`vPQ?ZRr4|OK4gn?(MJEo077p?SG=Scs)F)3`K73C1
z?K_(E_5?!||3Y^L2M$KE(Sn--a(`{PiemP~Ss684bB;K)DQx+x6AUc@9E<`^iYyKs
ztpW^+B2EJ(pg2Vvl$wNrNy~(q48@X^flgYmbkHC$3z)JNaw<B^SKL#-i@(Um#?As1
z7cT@E1f0l68D=f=^7or%-oLk(m2`Nm*mJ&L<Z_6t<Y35FAipcLG^tW4TfwuY(~Cir
zbVYzA;|q(H*=O@6JbwH3%0$L3a!&mW4FXJLBZtk3G4U}hmh<xSAyFFCBon;0k7uBB
zDXg>*a5^YNrAh!^kqoMw$~6sA30z3$xZdqL;qm#iy~@lPwk>ju42mp+6FG3$GBG%D
z&<e#19r{@#$FL<^;+Tf&iARGe`vI%3k<c))T~+$izU>LHs@SClY%3{}kD@L1SoQ3^
zU#%kO)NqXVvB1$!&jww54)2!0sj1MWK)+wz+#?@v8hW+}G_2zUHiOB}zz4+My{kKt
z_PJNZiQ~eKLK&q+6F`OQU}@lqfU_x8>x}@8!Pd(8yKCRQ{^`?YCjql(EHDYT2#}2$
zbmyE;+h}8<&?&%Vk|)#F5##~toeXR@3DK720`}FY-f0?)Eu38?cC(Le3Zp`dlARQY
m(x~`_gZvr+e{E7Tx1Ph?gXz0hx;k)}fx*+&&t;ucLK6TO+ZSK}

literal 0
HcmV?d00001

diff --git a/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_VerticalGridTest_testFixedSizeColumns.png b/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_VerticalGridTest_testFixedSizeColumns.png
new file mode 100644
index 0000000000000000000000000000000000000000..30a1bfce9dccd740381a3516f520f0fdba29b6da
GIT binary patch
literal 4041
zcmeAS@N?(olHy`uVBq!ia0y~yU_8XY!2E)P4JhKf;hzly1OEh17srr_TW_y!%su2F
z(f06mt6)%cQVY+6Cc_sFUXLv^jF?4DOr}jQcs`GDUrZjutp%qS`=4j{{(8ywDU%$E
zZ!e#5b?$11uQhckk<-?RGCFYhatJyJI0-wo2q=m`C=)QpL{WqhC}yJQ!qGZPQ5XcQ
z4B&ut1c!D@0Fw_e&|5CF1TYAID1p&%rcxS%1TZu?Bhv9de~#mY+$R0O$8uX@R`ISX
zwf!c4=$<?WgA+Px5U^sx6dfcYK*zBR5~rX!W3UI?V2)F!27$qd6k7Ti2B*t_u2N{>
zV;r20qe8G9ux=}uwd_kyY`G`blbD%X?|#?(8ttIm!m*H3(Me;JB0C6}z#-TnFbf!t
za8iJa0mKn#5>RSU0|xFWMRpKyD1bsx5jB(rxWIu84POPq$@fP0>#xS2Z5;NkVyvr`
zH{vlix!W$l5GUxw&>}EMkzxtUAaxlq$P`OB2C3r)d9V%UIAvi_9E`|;LzZ!Hx(w(l
ipyQaR>$nE{Pt3VYX75UCDtdukbOujXKbLh*2~7Yrnfqn{

literal 0
HcmV?d00001

diff --git a/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_VerticalGridTest_testFixedSizeColumnsWithFillFalse.png b/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_VerticalGridTest_testFixedSizeColumnsWithFillFalse.png
new file mode 100644
index 0000000000000000000000000000000000000000..1c7d840e5f982df50fb905545cfa529c1a81320a
GIT binary patch
literal 4344
zcmeAS@N?(olHy`uVBq!ia0y~yU_8XY!2E)P4JhKf;hzlygTQ`I7srr_TW_x#dNBuz
zv|ZfZd8KiU;@c&gJZ7@;ED=}}<B;XZ!LqDKn9)2zT}Y>G!k2??6DJ%ycIus#-T|kN
zn&)Ne{H%{YHH`PtY}$0?tKzlSU;Cx^@hL|JzTW?J^Pbkf|8#a;cT3!Md$-Q}hx@$`
zDYZChfKi74*FrE-gbHZ1a4h5m3n{gzwSW|M2+R@~mJ~1qGJw7V2LLCs|Dj<54<txX
z;R!Hw4Ol~!2t`gBI!Ms~*Ki5q5>P~d9IFU)HdrArra;afeiYDCYCvzn0{|K*Sc26_
zBL`cE;nqNushEmDp^WJql=!HyQT+2`Wze)`l_x$)r1fuJ!EefHS#Nj#lUUjA)fOf9
zm+Q<vyLUsadP^Teg8<XuL<)o3aSRGAgAs8oR341Zf&>=FLgzv1xIrFlgE>wW891no
z{?u_i|6KXO)VEkru=CKGF!jiL&hM9Auf6Ma>p|v(r@B3Exl7*d43tO|c2X1pBNvX=
z05B4O3WzwhKm-Cf1SwUdC?bZ<)J%xME*!p4n@u1JTQ0PKTrvD8pr?eP!Rm`QR24<c
zumu=YjN-V0Mm0Eou|+O09zanJi~y(-u&V_jjvsy$FgWl>2RtXV5|uk9oYxhbesP;<
zYown4<~{8n-&(AC_j^imk@3k-V#_YSUa@N0Az+So_vK&|aAFvosO5s-Aaxlqyjm_O
z4pPSr@?aaxaVo&jGANN^3CkdL88EyQOE{?PxPK?C(+?OjP5W@M4>+R1;OXk;vd$@?
F2>{8}(2f8A

literal 0
HcmV?d00001


From 5fb71c1c1152045ec4556c236808923fcbf9e867 Mon Sep 17 00:00:00 2001
From: Cheon Jaeung <cheonjaewoong@gmail.com>
Date: Sat, 11 Oct 2025 20:10:47 +0900
Subject: [PATCH 2/5] Update documentation for FixedSize

---
 README.md                         |   2 +-
 docs/cell-strategy.md             |  48 ++++++++++++++++++++++++++++--
 docs/images/fixedsize-example.png | Bin 0 -> 15850 bytes
 docs/index.md                     |   2 +-
 4 files changed, 47 insertions(+), 5 deletions(-)
 create mode 100644 docs/images/fixedsize-example.png

diff --git a/README.md b/README.md
index ae98482..6cdcc1b 100644
--- a/README.md
+++ b/README.md
@@ -15,7 +15,7 @@ This library can be simpler solution for small grid UI.
 There are benefits of this library:
 
 - **Similar API to LazyGrid**: The GridLayout's APIs are designed to provide similar development experience to LazyGrid.
-- **Easy to implement adaptive grid**: There are _"Fixed"_ and _"Adaptive"_ for grid layout management like LazyGrid.
+- **Easy to implement various grid**: There are _"Fixed"_, _"Adaptive"_ and _"FixedSize"_ for grid layout management like LazyGrid.
   Like LazyGrid, it eliminates dealing with different screen sizes.
 - **Simple to use as a part of LazyList**: The GridLayout is not lazy layout. It can be simply placed in lazy layouts.
   If only a portion of the full layout is grid, No need to use LazyGrid with span size for full layout.
diff --git a/docs/cell-strategy.md b/docs/cell-strategy.md
index ad669ee..b2d7af5 100644
--- a/docs/cell-strategy.md
+++ b/docs/cell-strategy.md
@@ -3,8 +3,8 @@
 All grid layout composables take a cell strategy parameter called `SimpleGridCells`.
 `SimpleGridCells` defines the number of cells and the size of each cell.
 
-There are 2 types of cell strategy, `Fixed` and `Adaptive`.
-They are similar to LazyGrid's `Fixed` and `Adaptive`.
+There are several types of cell strategy, `Fixed`, `Adaptive` and `FixedSize`.
+They are similar to LazyGrid's `GridCells.Fixed`, `GridCells.Adaptive` and `GridCells.FixedSize`.
 
 ## Fixed
 
@@ -94,9 +94,51 @@ And each cells will have 1/3 of 400dp (about 133.333dp) width or height.
 If the grid size is expanded to 600dp, the number of cells on each line will be changed to 5
 and each cell's size will be 120dp.
 
+## FixedSize
+
+`SimpleGridCells.FixedSize` is a cell strategy for as many cells as possible with exact size.
+
+The API of `FixedSize` looks like this:
+
+```kotlin
+class FixedSize(
+    private val size: Dp,
+    private val fill: Boolean = true
+) : SimpleGridCells
+```
+
+There is a parameter called `size`. This is the size of each cell should have.
+The `size` must be a positive size. If the size is 0 or below, it occurs an exception.
+If the `size` is bigger than container's size, the cell will have the same size to the container.
+
+!!! note
+    For information about `fill` parameter, read [Fill Option](#fill-option) section.
+
+For example, a grid has 400dp width or height and `FixedSize(120.dp)` is applied.
+
+```kotlin
+HorizontalGrid(
+    rows = SimpleGridCells.FixedSize(120.dp),
+    modifier = Modifier.height(400.dp)
+) { /* content */ }
+
+VerticalGrid(
+    columns = SimpleGridCells.FixedSize(120.dp),
+    modifier = Modifier.width(400.dp)
+) { /* content */ }
+```
+
+![fixed-size-example](./images/fixedsize-example.png)
+
+The grid will have 3 cells on each line and the remaining space will not be used.
+If the grid size is expanded to 600dp, the number of cells on each line will be changed to 5.
+
+In other case, `FixedSize(300.dp)` for `VerticalGrid(Modifier.width(200.dp))` means that there
+will be only one column and the cell will have 200dp width.
+
 ## Fill Option
 
-Both `Fixed` and `Adaptive` have a optional parameter named `fill`.
+All cell strategy classes have a optional parameter named `fill`.
 The `fill` parameter determines that grid's item composable should fill grid cell's size.
 
 When `fill` is true, grid layout forces item composable to have width or height to fit cell's maximum width or height.
diff --git a/docs/images/fixedsize-example.png b/docs/images/fixedsize-example.png
new file mode 100644
index 0000000000000000000000000000000000000000..fab1b7b6269fc57f6735fcf92e2d78f53ce058c8
GIT binary patch
literal 15850
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
WEgPkJQ@|BLAUE|*uAy}upZyOb15A$q

literal 0
HcmV?d00001

diff --git a/docs/index.md b/docs/index.md
index 9796938..28da988 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -11,7 +11,7 @@ This library can be simpler solution for small grid UI.
 There are benefits of this library:
 
 - **Similar API to LazyGrid**: The GridLayout's APIs are designed to provide similar development experience to LazyGrid.
-- **Easy to implement adaptive grid**: There are _"Fixed"_ and _"Adaptive"_ for grid layout management like LazyGrid.
+- **Easy to implement various grid**: There are _"Fixed"_, _"Adaptive"_ and _"FixedSize"_ for grid layout management like LazyGrid.
   Like LazyGrid, it eliminates dealing with different screen sizes.
 - **Simple to use as a part of LazyList**: The GridLayout is not lazy layout. It can be simply placed in lazy layouts.
   If only a portion of the full layout is grid, No need to use LazyGrid with span size for full layout.

From 9d31114c99492f9b08b671956504f3ec1dec8193 Mon Sep 17 00:00:00 2001
From: Cheon Jaeung <cheonjaewoong@gmail.com>
Date: Wed, 15 Oct 2025 20:44:52 +0900
Subject: [PATCH 3/5] Change item size for more clear testing

---
 .../cheonjaeung/compose/grid/BoxGridTest.kt   |  64 +++++++++---------
 ...veRowsAndFixedSizeColumnsWithFillFalse.png | Bin 4569 -> 4223 bytes
 ...zeRowsAndFixedSizeColumnsWithFillFalse.png | Bin 4492 -> 4240 bytes
 3 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/grid/src/test/java/com/cheonjaeung/compose/grid/BoxGridTest.kt b/grid/src/test/java/com/cheonjaeung/compose/grid/BoxGridTest.kt
index 2e0207a..037ff04 100644
--- a/grid/src/test/java/com/cheonjaeung/compose/grid/BoxGridTest.kt
+++ b/grid/src/test/java/com/cheonjaeung/compose/grid/BoxGridTest.kt
@@ -875,24 +875,24 @@ class BoxGridTest {
                 ) {
                     Box(
                         modifier = Modifier
-                            .size(100.dp)
+                            .size(50.dp)
                             .background(Color.Blue)
                     )
                     Box(
                         modifier = Modifier
-                            .size(100.dp)
+                            .size(50.dp)
                             .position(row = 1, column = 1)
                             .background(Color.Green)
                     )
                     Box(
                         modifier = Modifier
-                            .size(100.dp)
+                            .size(50.dp)
                             .position(row = 2, column = 2)
                             .background(Color.Yellow)
                     )
                     Box(
                         modifier = Modifier
-                            .size(100.dp)
+                            .size(50.dp)
                             .position(row = 3, column = 1)
                             .background(Color.Red)
                     )
@@ -909,24 +909,24 @@ class BoxGridTest {
                     ) {
                         Box(
                             modifier = Modifier
-                                .size(100.dp)
+                                .size(50.dp)
                                 .background(Color.Blue)
                         )
                         Box(
                             modifier = Modifier
-                                .size(100.dp)
+                                .size(50.dp)
                                 .position(row = 1, column = 1)
                                 .background(Color.Green)
                         )
                         Box(
                             modifier = Modifier
-                                .size(100.dp)
+                                .size(50.dp)
                                 .position(row = 2, column = 2)
                                 .background(Color.Yellow)
                         )
                         Box(
                             modifier = Modifier
-                                .size(100.dp)
+                                .size(50.dp)
                                 .position(row = 3, column = 1)
                                 .background(Color.Red)
                         )
@@ -950,24 +950,24 @@ class BoxGridTest {
                 ) {
                     Box(
                         modifier = Modifier
-                            .size(100.dp)
+                            .size(50.dp)
                             .background(Color.Blue)
                     )
                     Box(
                         modifier = Modifier
-                            .size(100.dp)
+                            .size(50.dp)
                             .position(row = 1, column = 1)
                             .background(Color.Green)
                     )
                     Box(
                         modifier = Modifier
-                            .size(100.dp)
+                            .size(50.dp)
                             .position(row = 2, column = 2)
                             .background(Color.Yellow)
                     )
                     Box(
                         modifier = Modifier
-                            .size(100.dp)
+                            .size(50.dp)
                             .position(row = 3, column = 1)
                             .background(Color.Red)
                     )
@@ -984,24 +984,24 @@ class BoxGridTest {
                     ) {
                         Box(
                             modifier = Modifier
-                                .size(100.dp)
+                                .size(50.dp)
                                 .background(Color.Blue)
                         )
                         Box(
                             modifier = Modifier
-                                .size(100.dp)
+                                .size(50.dp)
                                 .position(row = 1, column = 1)
                                 .background(Color.Green)
                         )
                         Box(
                             modifier = Modifier
-                                .size(100.dp)
+                                .size(50.dp)
                                 .position(row = 2, column = 2)
                                 .background(Color.Yellow)
                         )
                         Box(
                             modifier = Modifier
-                                .size(100.dp)
+                                .size(50.dp)
                                 .position(row = 3, column = 1)
                                 .background(Color.Red)
                         )
@@ -1025,24 +1025,24 @@ class BoxGridTest {
                 ) {
                     Box(
                         modifier = Modifier
-                            .size(100.dp)
+                            .size(50.dp)
                             .background(Color.Blue)
                     )
                     Box(
                         modifier = Modifier
-                            .size(100.dp)
+                            .size(50.dp)
                             .position(row = 1, column = 1)
                             .background(Color.Green)
                     )
                     Box(
                         modifier = Modifier
-                            .size(100.dp)
+                            .size(50.dp)
                             .position(row = 2, column = 2)
                             .background(Color.Yellow)
                     )
                     Box(
                         modifier = Modifier
-                            .size(100.dp)
+                            .size(50.dp)
                             .position(row = 3, column = 1)
                             .background(Color.Red)
                     )
@@ -1059,24 +1059,24 @@ class BoxGridTest {
                     ) {
                         Box(
                             modifier = Modifier
-                                .size(100.dp)
+                                .size(50.dp)
                                 .background(Color.Blue)
                         )
                         Box(
                             modifier = Modifier
-                                .size(100.dp)
+                                .size(50.dp)
                                 .position(row = 1, column = 1)
                                 .background(Color.Green)
                         )
                         Box(
                             modifier = Modifier
-                                .size(100.dp)
+                                .size(50.dp)
                                 .position(row = 2, column = 2)
                                 .background(Color.Yellow)
                         )
                         Box(
                             modifier = Modifier
-                                .size(100.dp)
+                                .size(50.dp)
                                 .position(row = 3, column = 1)
                                 .background(Color.Red)
                         )
@@ -1100,24 +1100,24 @@ class BoxGridTest {
                 ) {
                     Box(
                         modifier = Modifier
-                            .size(100.dp)
+                            .size(50.dp)
                             .background(Color.Blue)
                     )
                     Box(
                         modifier = Modifier
-                            .size(100.dp)
+                            .size(50.dp)
                             .position(row = 1, column = 1)
                             .background(Color.Green)
                     )
                     Box(
                         modifier = Modifier
-                            .size(100.dp)
+                            .size(50.dp)
                             .position(row = 2, column = 2)
                             .background(Color.Yellow)
                     )
                     Box(
                         modifier = Modifier
-                            .size(100.dp)
+                            .size(50.dp)
                             .position(row = 3, column = 1)
                             .background(Color.Red)
                     )
@@ -1134,24 +1134,24 @@ class BoxGridTest {
                     ) {
                         Box(
                             modifier = Modifier
-                                .size(100.dp)
+                                .size(50.dp)
                                 .background(Color.Blue)
                         )
                         Box(
                             modifier = Modifier
-                                .size(100.dp)
+                                .size(50.dp)
                                 .position(row = 1, column = 1)
                                 .background(Color.Green)
                         )
                         Box(
                             modifier = Modifier
-                                .size(100.dp)
+                                .size(50.dp)
                                 .position(row = 2, column = 2)
                                 .background(Color.Yellow)
                         )
                         Box(
                             modifier = Modifier
-                                .size(100.dp)
+                                .size(50.dp)
                                 .position(row = 3, column = 1)
                                 .background(Color.Red)
                         )
diff --git a/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testAdaptiveRowsAndFixedSizeColumnsWithFillFalse.png b/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testAdaptiveRowsAndFixedSizeColumnsWithFillFalse.png
index 9017eeeeb899cc3451ad0d15490920e187e13fe1..dbf0b16893e8baac453b836fc04878d60706fe63 100644
GIT binary patch
literal 4223
zcmeAS@N?(olHy`uVBq!ia0y~yU_8XY!2E)P4JhKf;hzlygMgc-i(^Q|t+!V<dPOHn
z9DkUv{UvKpV+z-n?Fupzl;&JKEA7F{qBS$ds8m~w%jw+#0T%v^e5%ggCs#!7VPLQH
zUhb#9+-c>9XAd9mZ2bQJ;QA>-69YqYlXk{19SC#fU=(mtWO3kV6<|;labjo*7%~DE
z4lr;iVnI$CEevl8IO^Gz7oU8xypiz*-$G>ug%*;~pTd1s{THjIT>5%;YcHc>%I;t5
z`X+rjoB!O5twlhQMZl>=z=1>1i9ykYgAr9g1Q?pY5CsM$5DyV%%LPGDyaPScDgg8v
z>C9Xn4n-#pg_bQdYG)t)^4nzTvt=6%Nepse{Ctq%=g$w0T7Unxc#FU;*C|uXW}n)p
z(4x@NAkZYh<iz2`!J){Zh$aAx?gjy+7LXiOm<la@4FX(1dpH&XZEYHy%vwi|g{LoH
zem&*g`};S6fyF>F`mlfZ>en4XLA&Ojhs7R;A}AmkoH_)UAkhgE&;W+6LJKHg0r3!F
zax7E^Mj#W=GhDzFLk9Df1SFSdeti5!$1HT}rR%G;rJ0>L7zP402v{)<h{eQM+91F*
zI1w-_GYn3b0bQlg!pBG-#~s+u_pri-kD=^%fkkJK($a$oAKz4i@-~+uC_^)VG6yhw
za|~etY^9SOE7(K3lT3aI?2Vgz>EXk4MHU9!$bmza5mUNC(p|nksear1Nwuv43xfB*
zboc!AMjKlxiBxO?ode_n!xmIq(U0l$0u+b9*aXHX7bt$|%Dfd0X$xhP+t~K~3Z4rJ
zFjDKKxFauLdaenp){Kn_F>~W+e5*D&(PhdMvF^rRK_>?eM_?m`MUkaNpas}Y5kM6H
zHd`EluoWmb%$SNLpcW;tr3q|Nf;^7IlvZwW2<MQOk6&6+`SaK@tnFb!f(PQWe*Fcu
z1U9WlulJEsG^k|&%1*#$)<QZnxq!|0fopeU#6z0<3+_&DZqBIMI|Y>aNpIQ`)&gv>
z5LQGBi-|FlP#VJ04Wo}1V39Xqb`$iW(+h#Y;<zn8S#M`_zhcjvI~zE#z~JfX=d#Wz
Gp$Pz@hgMqv

literal 4569
zcmdUzT}YEr7{|}vhMbLzGaY0fn8(x>mb5Zgp)pUZZJ4@QWKg0JNc4G8L4?R!?{Zye
zV;8#+!WMm82vadjZ%R`{v1n=`mQq6Df}{wgB+{O<x)3rjw^t{7F8(~cyytyB&yQWV
z<Qb!ttCa|$XtT*sfROAdLdya;3Ou>>Q<(^<ZkY|)2QR%I8_=E<tm<pMkCIku9XXcz
z@}`@qB<YN@!L;U+(0{k4FD=gG{cyoIQtENJTDH2|UktYPY_IVYBz9R(t-If^uqjgQ
z$s%G-B4EmJf{3Y&B!=i<fi5Iku#7M&*JB4kRLvI4LDie6oG_8-v5FyTz%r4{+wo4z
zcGSGJubr68dN{DzTxPpsWdYUKmyh=~JZRBEs1P&+?tsHWm4w|$5E+J|XhdESX{6Fi
zloZZ60k8LxY9hdCDR7?BtB}Oa0-d}Wcma4%ge>(qOAJN;UoSut^I(Fq3s;REKV5gk
zJ#_ZG`)FGJ?siP~7cGCH?C$;cs*;L4xA4<|SQ_#$e617ufKO-`q?25h!yp)NHjITx
zW=ablj$4S-d@mkvS}}b<X&#D$5@=xOXrL&eOYAlB#RDO!86SFSB+R#i@Gge+0wb@2
zqa3hUB$2!#q331B8?d)x_7tsZGrs8@7}3Y*qA*2sG+2R%un0BLzXv6Vk!aATNRMTa
zX>k1@8xa=QTJu@+n=!%mV`H+ZFMas)bbM8ev^*it35gG8VT}25fZr<ciwuSq!*xvg
zazr6GGVe|F?DCAclNtv%m=D$JsC>%zv0CHF&}B3f2jV%Z&2k@$79Zz0njT!GxxtMW
z%NMFY-0tU<LEr!kg+MW9j|h_*@$V!BDUaU*;mrx{pUhm}U5-a?7r8n{3-K|vwyZJ5
zs1yB55L~dgL_q;roWu_Fg2N!;y5T%e<v=eg_D2F!a+Yx{P>NdbT+H1zUhnEy(rw!o
zBM}_UfG()Wf=u=n`_IzYx+XWT$Xvl?j(qd`vB;(zg2ae4I*ui&#($OWUk|eYm4sTG
aYtO|zd;g`dV&_%(%LbYE<{5mf#QqDFnz*k3

diff --git a/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedSizeRowsAndFixedSizeColumnsWithFillFalse.png b/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedSizeRowsAndFixedSizeColumnsWithFillFalse.png
index ef8350868c8fdf73418d5007f4414448d6693736..2ee1bf47fc5bc531b8ed40d7cf11eb1e813ee2eb 100644
GIT binary patch
literal 4240
zcmeAS@N?(olHy`uVBq!ia0y~yU_8XY!2E)P4JhKf;hzlygFv{ai(^Q|t+!V<dd*H0
zIsWkbu`^T7YHRFZ-DlZ+;pD*t6_+1vdXt*+xb%YVycJ-QKf=N-mbqYuh)Q{3*WJk>
z1sv-9`saD){O8^u<mKYV&VG8v*))a?VS-K!Edd;i0#1r74jiol42mK{M!>{?!HEMC
zH3)DiGFZzT+MbXSa(zE9&w*zGR!o@6kVH=W-}S#xe!G2saMcX^8xjIe*H*`^*6_Ul
zqcA7gfdd#qiY^?CEdq)x0!}RgXab<{0%DNdP+>Z7$T|X}8t55d!~?xXGV{W*1_7lO
z2B#BT)A#Ew{=Iy5ka2zv4~HTHUQ{z@`t&-l^XJ3Au`0HlRr2yW{j{;xk;4(_1{Ot@
z7J(L^iv*k;PzA_!A}*gfa>z0Q;|XLF$kxHh{M{tbB*5gvk*y=Pc*?wa`)-Q22r%G7
z1=6~1i!0Wyn)1vy8JJ=t-|I>QdU^Ff-q;I@UtCESl$Kk80R;@>)}h2yECIzEC?A57
z4H-;nW~UATCJsgIGqaz?8yIcUS7>1vD1<l5;LlLBm34Z-L0bzb@ww9rfkEoHK^<(n
z<qjQ85MX%I7q`AINNH(V^{02$9E#uy(@CR+fn%WnlR}FV#}F0(Iv?l}Aa>$_GwoQx
z9@@R=zJ2%Jy_sHf&-Ds0HQ+`HEqx3*ix=y=7ykHap!%Cj@qpXfOl_}A>G4=w07y*&
zU|9sJ#Xw~)9ho9d?w~f@0F~hv_JM+$L-9b?)lkvj_rC{kT8}$u!J&RgOp4F{@w<1y
zUgF}h(#kCds!H#6cTBpJa%r2P69<PPhoVA@LQ4ar4n!4b0=Dgd3Kjz8h8a@{nCO7X
z7UXwO<%G=4NQN|x5?UXAFj=>L^^|kx?QcscvM}I9KP=4W`uW^?JLQdb3xl+8^xBS~
zAW+nBC_>^3(u4!og9rgoMgfNSLSXZbo=mQV%4m5ODf`l#nE}n$30pT$p1h*JpKuDs
zS9%aASnx;>tkgg?fC$>l0ZbeO6%CXEj)l&H)Nw=w+k`{${i}O=PtFv&3mj=+@O1Ta
JS?83{1OPfMK$HLg

literal 4492
zcmdT|T}V_x6du<#XE%&lGy4(6SuOV=(#%{Ft=;kWDl3v@^iXQ0`I0DsL>ex3w=~oi
zje<brQc@(AAqFXh{TU&cMiv<=29*zK7NwP$omqm64BOmGD|a3~4wpMS=bZ0+-)wnm
zN`i-al^P-BAtc6bMabngLaxJj5kyQ)-=YxGqzSRcZHM|so=Pb!YsLMcx7y(W#qt70
zd4)bdG|y|X5FWqbMNW|BV!GB;5Re#UY99HRuUfJ@u6TU#ple<5*QQgR#;Vr5J<ZQh
ze#ePS6*UvBh*%j>V9Kz+i02oONMtCYUJQw;*o82vG++z)PXPmVOU5oDp-RF;V!#@P
zXzUyTb21+4?cHxZck@Wq%g*Y+&F$?18`ivkZ1TPL=v4<l3I7~F;k=;%N0$;cg`7)7
z0Tqx3>O`g!%|tD!U?-N#Fzj{~_S1=LWC^P!A6F>81rlz79{5)n(*Ndw_l*fZVSG|0
zTzhVL7{c)Db$!$72R&geJ~7w`JBS3nZd@R+34Ses{xd=!Is(!U7#LedN`b$a&V&+a
zUGIR@SdaD>`<Zst)YHy9{lv<6ylG&lGct*mJEXopI|L45>rkx-y-8()5)i=F^rfqL
z*Tbj-8fayL4x>Qf)v~F5%u~MzQ}mY$h7}^rNtf6igZxEjTv$p#2JGUTi?EZ(Occ(!
z?5gLOdrU-aimSOUEy;TR(v!jIqKG7!-N9OW<bQ61Fb~;JP=NqrK79~OImA_e?!cMc
z;w@D@cgg~5yWE8@Q$bW&wWF~?cRE~Om@_REaep<7$`W?n6O4-3&21PB1FK@dCQwYm
zmO47Dx7i4J2kLwVwL}j8o+R$w?9Iui=!V{nLS7#!%xDXI_jwtMD9<g~S+lqQSa&5A
zc_rb|0ay?aOW^%yx`x@kgdI^(9`3WL5=@SU{eX~XZh0(@Ns)DQEZbDwmLBI_mqC?X
zQwi~t*}nDGyOlO?3wIdEKjt>q$)Ha3<CmddE)6!~az@^=F_qZ*QN!6O1BCoLB1P8G
zf{2RVOoJzoUKSO1av647TNNNnHSCi1KfR2l<4)?VxUFh08F#zTSdn$5C3rjh%YuZs
Kl-SEGv-CUYBC!ns


From 1ceea082dd18cc84599c4aacf6719b09ff1ea90e Mon Sep 17 00:00:00 2001
From: Cheon Jaeung <cheonjaewoong@gmail.com>
Date: Wed, 15 Oct 2025 20:47:38 +0900
Subject: [PATCH 4/5] Fix item X position when using FixedSize in RTL

---
 .../compose/grid/BoxGridMeasurePolicy.kt      |  14 +++++++++++---
 ...st_testAdaptiveRowsAndFixedSizeColumns.png | Bin 4569 -> 4549 bytes
 ...veRowsAndFixedSizeColumnsWithFillFalse.png | Bin 4223 -> 4206 bytes
 ...dTest_testFixedRowsAndFixedSizeColumns.png | Bin 5140 -> 5086 bytes
 ...edRowsAndFixedSizeColumnsWithFillFalse.png | Bin 4057 -> 4031 bytes
 ...t_testFixedSizeRowsAndFixedSizeColumns.png | Bin 4492 -> 4470 bytes
 ...zeRowsAndFixedSizeColumnsWithFillFalse.png | Bin 4240 -> 4223 bytes
 7 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/grid/src/commonMain/kotlin/com/cheonjaeung/compose/grid/BoxGridMeasurePolicy.kt b/grid/src/commonMain/kotlin/com/cheonjaeung/compose/grid/BoxGridMeasurePolicy.kt
index fc100cf..b2d59a7 100644
--- a/grid/src/commonMain/kotlin/com/cheonjaeung/compose/grid/BoxGridMeasurePolicy.kt
+++ b/grid/src/commonMain/kotlin/com/cheonjaeung/compose/grid/BoxGridMeasurePolicy.kt
@@ -189,14 +189,22 @@ private class BoxGridMeasureHelper(
         val horizontalSpacingPx = horizontalSpacing.roundToPx()
         val verticalSpacingPx = verticalSpacing.roundToPx()
 
-        var currentX = 0
-        var currentY = 0
+        var currentX = if (layoutDirection == LayoutDirection.Rtl) {
+            val horizontalSpacingCount = (columnCount - 1).coerceAtLeast(0)
+            val horizontalSpacingSumPx = horizontalSpacingPx * horizontalSpacingCount
+            val contentWidth = cellWidthConstraintList.sum() + horizontalSpacingSumPx
+            measureResult.layoutSize.width.roundToInt() - contentWidth
+        } else {
+            0
+        }
         val xPositions = IntArray(columnCount)
-        val yPositions = IntArray(rowCount)
         for (i in 0 until columnCount) {
             xPositions[i] = currentX
             currentX += cellWidthConstraintList[i] + horizontalSpacingPx
         }
+
+        var currentY = 0
+        val yPositions = IntArray(rowCount)
         for (i in 0 until rowCount) {
             yPositions[i] = currentY
             currentY += cellHeightConstraintList[i] + verticalSpacingPx
diff --git a/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testAdaptiveRowsAndFixedSizeColumns.png b/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testAdaptiveRowsAndFixedSizeColumns.png
index 9017eeeeb899cc3451ad0d15490920e187e13fe1..5cba6f1aced6ea7313064e3357b4807a21a44f0a 100644
GIT binary patch
literal 4549
zcmeAS@N?(olHy`uVBq!ia0y~yU_8XY!2E)P4JhKf;hzlygJ6%Ri(^Q|t+&?=y_f?<
z+AeNiqLb96qsaI={J5631jjZp#n!b;xP8*?Q>{7^1W&)*)b?7(u|%)u$%kUIg38C@
z-kO3>R+M&p{>gKoNA#eO6N91)2V;wXB8z}ii+}@%AcX>oUrsQz1aL44I4QC?aI^|A
zD2g}@lz^g$4z;}1BJiNTrC{eCR?AnPqqoHCde$5`prTmPVpF;zP$&1EghGpxMhgQF
zJ8@9X<XEW8u~2}?sY8HEQK5xaOt52thR*`pq|u_*(jdUKkP~R1Q-%`<ErbQCl0jAo
zFaZtcQly-z(88w(3~mlZpz9k1ln_j##>Y=3-iCWmx}EDe>Gju><~;(3?i~FQuV~q}
zuqv5D5omuC5OOIF73MUcYn57nu2lpk3CfvDEq$Qy!e$=VLi09y1kJtfh1WjjdntCB
zvr#EEK+==b3l8+ufRr$(!~`Z^Q0~-dX;KAc8bxq+QKAtO7$ejUA_43{BwX=+*AE*R
zk4L?XP8<xxp#}jfCL)#6Um4JGEcCaP7#jzBunmGZwdZ`8x1F2e+3L(+8mcEAO=JX?
z6HLI$i3615Kou>+00{uC2G#K#z#2>mSmSp9>oZ^pK#_n(i<~4iy>;MkM0xfklm6ck
zI(8mPEeBM(macs%ov-uxtraK;so7BB1eJst-~we9Fk%#d?FdkDNNr(YfeSJm6xu+$
zIB3b#Xz2qbEo!t-8e(vV!=X8I{P+uZ>UeB=6{d1?PfpEYCyx5-{rguX|0(t5%jZ#K
z0XCckfDp(S5=<A4)&LGiVE^Hu5YW}24h67dAqZi*aL6(uct{dtGew-}6hvwIUW%Ug
zP43O0eaeF*Zl@OlkhTmJ65%v(t^pO4wC+p1=mmEjXq!KQt-AvvaoMUT>vn%V)*`?_
z9#SmfAX6uK_7Sg3v4mxix(w)t!R<H}21R<KhWo$SmeoA@(4?}81vosz;OXk;vd$@?
F2>|qqlBWOw

literal 4569
zcmdUzT}YEr7{|}vhMbLzGaY0fn8(x>mb5Zgp)pUZZJ4@QWKg0JNc4G8L4?R!?{Zye
zV;8#+!WMm82vadjZ%R`{v1n=`mQq6Df}{wgB+{O<x)3rjw^t{7F8(~cyytyB&yQWV
z<Qb!ttCa|$XtT*sfROAdLdya;3Ou>>Q<(^<ZkY|)2QR%I8_=E<tm<pMkCIku9XXcz
z@}`@qB<YN@!L;U+(0{k4FD=gG{cyoIQtENJTDH2|UktYPY_IVYBz9R(t-If^uqjgQ
z$s%G-B4EmJf{3Y&B!=i<fi5Iku#7M&*JB4kRLvI4LDie6oG_8-v5FyTz%r4{+wo4z
zcGSGJubr68dN{DzTxPpsWdYUKmyh=~JZRBEs1P&+?tsHWm4w|$5E+J|XhdESX{6Fi
zloZZ60k8LxY9hdCDR7?BtB}Oa0-d}Wcma4%ge>(qOAJN;UoSut^I(Fq3s;REKV5gk
zJ#_ZG`)FGJ?siP~7cGCH?C$;cs*;L4xA4<|SQ_#$e617ufKO-`q?25h!yp)NHjITx
zW=ablj$4S-d@mkvS}}b<X&#D$5@=xOXrL&eOYAlB#RDO!86SFSB+R#i@Gge+0wb@2
zqa3hUB$2!#q331B8?d)x_7tsZGrs8@7}3Y*qA*2sG+2R%un0BLzXv6Vk!aATNRMTa
zX>k1@8xa=QTJu@+n=!%mV`H+ZFMas)bbM8ev^*it35gG8VT}25fZr<ciwuSq!*xvg
zazr6GGVe|F?DCAclNtv%m=D$JsC>%zv0CHF&}B3f2jV%Z&2k@$79Zz0njT!GxxtMW
z%NMFY-0tU<LEr!kg+MW9j|h_*@$V!BDUaU*;mrx{pUhm}U5-a?7r8n{3-K|vwyZJ5
zs1yB55L~dgL_q;roWu_Fg2N!;y5T%e<v=eg_D2F!a+Yx{P>NdbT+H1zUhnEy(rw!o
zBM}_UfG()Wf=u=n`_IzYx+XWT$Xvl?j(qd`vB;(zg2ae4I*ui&#($OWUk|eYm4sTG
aYtO|zd;g`dV&_%(%LbYE<{5mf#QqDFnz*k3

diff --git a/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testAdaptiveRowsAndFixedSizeColumnsWithFillFalse.png b/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testAdaptiveRowsAndFixedSizeColumnsWithFillFalse.png
index dbf0b16893e8baac453b836fc04878d60706fe63..b8cdd70ae9fc67e3577543fc2a781e6455aec947 100644
GIT binary patch
literal 4206
zcmeAS@N?(olHy`uVBq!ia0y~yU_8XY!2E)P4JhKf;hzlygMg{0i(^Q|t+!V<W(60D
z9RK)V?T5)e2PP*r`GbdAm0GRKU(0!Nh#HA5X<i*tu&ZCdYr*s@e3Kj}_T)~pb7(I*
za`NRft&Y~o{O#wt=iL9GyVNBmB=mN~+AxL<!GcZ<Edd;i0#1r74jiol42mK{M!>{?
z!HEMCH3)DiGE~bPia&TF!|s1#0>dxo7n}?niX@@^v1{~`HqBg8Qd*mu?7(qz?Y^~(
zRrVe|d+1n$fKm&CQ-=T(hoTdQLJNl?nt+oAP+Fq}BsWx;4FXk7z(50fW}yHR&}*bK
zdl?m7I2c<d@SVM`c5eUN<yYdio3XVBFp!A;9sB!t^%S$&+rP0Yw$ur#E`7UglRk$c
z2heE>Ee!%qK-Y0Nai9v2<6OMH<XET<j5?q_z~}?nI~bW6@d8dSKL7Y(vvl`vb6{Yx
zFp!M?yw7`WwP?zeJTY!*W<2Q`l)$-w=>nKGxP}tb=>;b+0zsJ*lw!zWf)cPIi-40=
zjlFeuZs^i4sXMnADzq>R2m&U`fw7nv-;!9il2i~=q!^e6DAG?;k2$>%q?6<RycRf@
zwwa+Jw(YQ)SLYlao(2IXOav<Fz;!36+5*)CLrH**&4Gh)!R3b!pG)xEn$jZBuvZP}
z2@>l31D9vc^LxC&(&Oci!y9{B1roM@tdUWD*{kPnCg#KduHC?;L5qL`2e8eAEC6gf
z0V_XX!>L7pET-ZY4q(#@*a!nQ#9D#I4+&<j4x|-SGGm_K;(rm#OFsQOatvE@46}iT
zEaJa7GwyiRUnSMwN-YlSx5>J>c%Iycx4s|T6*IKS&>>I-sxXy+^$!=YnMe(0t)SC_
z<3&G><mBcpO^GM5VFhW3Jve{n_~VYCpj|S(Ine0C(TD}b0H{p>EDFeE0!z1{*KW8K
z0nCKJZ2sayo>6C+fyc|s7bgPC0#ci?Q1!rkO{Pw=VwVKF6u+>LpqkdMK{J1FJC2N&
nHa)aBaM&^;_W>GgKMI!xcRyS8B{UW|j=<pQ>gTe~DWM4f?%`%$

literal 4223
zcmeAS@N?(olHy`uVBq!ia0y~yU_8XY!2E)P4JhKf;hzlygMgc-i(^Q|t+!V<dPOHn
z9DkUv{UvKpV+z-n?Fupzl;&JKEA7F{qBS$ds8m~w%jw+#0T%v^e5%ggCs#!7VPLQH
zUhb#9+-c>9XAd9mZ2bQJ;QA>-69YqYlXk{19SC#fU=(mtWO3kV6<|;labjo*7%~DE
z4lr;iVnI$CEevl8IO^Gz7oU8xypiz*-$G>ug%*;~pTd1s{THjIT>5%;YcHc>%I;t5
z`X+rjoB!O5twlhQMZl>=z=1>1i9ykYgAr9g1Q?pY5CsM$5DyV%%LPGDyaPScDgg8v
z>C9Xn4n-#pg_bQdYG)t)^4nzTvt=6%Nepse{Ctq%=g$w0T7Unxc#FU;*C|uXW}n)p
z(4x@NAkZYh<iz2`!J){Zh$aAx?gjy+7LXiOm<la@4FX(1dpH&XZEYHy%vwi|g{LoH
zem&*g`};S6fyF>F`mlfZ>en4XLA&Ojhs7R;A}AmkoH_)UAkhgE&;W+6LJKHg0r3!F
zax7E^Mj#W=GhDzFLk9Df1SFSdeti5!$1HT}rR%G;rJ0>L7zP402v{)<h{eQM+91F*
zI1w-_GYn3b0bQlg!pBG-#~s+u_pri-kD=^%fkkJK($a$oAKz4i@-~+uC_^)VG6yhw
za|~etY^9SOE7(K3lT3aI?2Vgz>EXk4MHU9!$bmza5mUNC(p|nksear1Nwuv43xfB*
zboc!AMjKlxiBxO?ode_n!xmIq(U0l$0u+b9*aXHX7bt$|%Dfd0X$xhP+t~K~3Z4rJ
zFjDKKxFauLdaenp){Kn_F>~W+e5*D&(PhdMvF^rRK_>?eM_?m`MUkaNpas}Y5kM6H
zHd`EluoWmb%$SNLpcW;tr3q|Nf;^7IlvZwW2<MQOk6&6+`SaK@tnFb!f(PQWe*Fcu
z1U9WlulJEsG^k|&%1*#$)<QZnxq!|0fopeU#6z0<3+_&DZqBIMI|Y>aNpIQ`)&gv>
z5LQGBi-|FlP#VJ04Wo}1V39Xqb`$iW(+h#Y;<zn8S#M`_zhcjvI~zE#z~JfX=d#Wz
Gp$Pz@hgMqv

diff --git a/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedRowsAndFixedSizeColumns.png b/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedRowsAndFixedSizeColumns.png
index eccc73de36636dee9ae4b80d8ecbd4f28d1a2c34..0689f7b8f70d720a6072c2a9bbb9c9d5bb226d56 100644
GIT binary patch
literal 5086
zcmdT|F=!M)6#bi9!?@;TF1Ly#pf?_bgIE{{1|`U4vQbaDut+2dB0?-I1Ez?<VhOXH
zhNy_d!bTRc65<tN5pAL<Hp-^(KtT~ixJJdsQv9=*VuPu&Gr3D~@cG63`)}TV^Zwp&
zM~|niE(-wCr4!C+0OKV<s!rN5Q?C9U1js%rIYVR9pMHE8N(1W{S)O~m`)O`If24M7
zJXPu3dG|qIvFm~}wlXpQ<j)rvJYb$8hM>%(T+kxPa9~ctgdg59NI=_if)kHg40u66
zlM=jemXn+y%%l4S@awdVumlMU+iFrL>y}N_%zuDbK|Vz}GmFHhz-$h}B}S7H!mX;}
zqvW)WZDA)<mzqh&_!W9|?p{JNuDL&6f2;qxyoYo~9R1e4t9EFh9lNn`tX4-NVaV$l
zNjB6TpP~|J3L_fe;bp93^DIZAhXU)der9S&yX5m86hTx!{7KbG8j_$Q#}Vb)#{Ztt
z6#DL>Mo{8_zq@HDLMFo2qcf&fWMYVGB~Bb8KirBSxx|+<ya_|rzzQELEEZ|JicsHh
z#VNGWIr~|ee18sJ^j<mRth{a|uN8@$Dz7D<w}QCU(F$%vsxIZroeJFX8i(B~UJGB{
zBH5;N6KE~3wV={#Nrqd&@K*H7Uze)SzMmYZU46b+I(rpb*$`e4My9PldVkB2i_1!X
zqCAc7inNGwOT}7|QPCCJ{I=X%6I$EG3Fo)t>c}snqIvW_9+?w8sFozqljij|T9Jt%
zu8u<2dUQe(I~&coyap@ij#dEt_<`Kb$ZbGF=!bb#_J7sn>ZeZwE4tLD6`2^~emJZQ
ir14Ffv5kXt_;+f@tJ#CUJ}&IT?{-ic8Fd!<#o2#=U<1Ga

literal 5140
zcmeAS@N?(olHy`uVBq!ia0y~yU_8XY!2E)P4JhKf;hzlygYa!n7srr_TW_y9@-is$
zxE}0s=8h6LCMbL3MV7*BA->7;4G)-AN(;`s@}l;66n8^=YXYZYgMd;CgHwk96NjP`
zhe8VnWdaKYtc(~GMVuH~0yr22oD^9cI9de;NWg)E)tiH{ML>~7z^O&RfkV)VLD7W*
z0g$%_iPymHpvW^A0isxv!r-LQ!oaamfJvdniK9V)OL2e%fL2eVQhEfZX^^*oxQ}N5
z6C+B>5pcRFL}6k?j=um7SxMSQSAmFAf57th^Ab~wlYzDYlL;`XZ~==8N|_2Ra*n`K
z0+>mGWd<-&(}pSH1kAg@1aP4RXp^FeA`8$qU!Z*=PQo-1ZoSaU2uyUKG8LNsC}TDV
zRB?cPAP6i~frT2#Gt_4Wa6I**VW1!f_#Fu<g$yWfJ8^I<bO+TpGz%G|5T|XzK?<V)
zj=MuKkXi%4d6*8F3=&qL3LcmrKt(JynDj|PWahI6bsWbfI1ktgdQQCd?C1A_DKxI5
zBdE|QL}^%(T_pAi(YE?l6w#qpOA%B#12X|5u!?CVk4eL}^9JOm12r1QWP4IpmA0)G
zCk?8mUdq}zRz4_AK&q!@>h*I_QtywYXQzQ$eEolCRDe2jSW>ls(@r5!&3ggdelr2L
zOnkvLfH1X%&DB~!Nd{Eg1G}w*kGW8w3Nw&E)e@++Mx!u6HyhY!m?6LfY!h)P0vlMs
zj{V?cVzz`E1Wru_Myx`M8n`LP3G7`sWdI%CATW#C!aEJYZGS;fs~=eW0Tb;YW42yU
zhBRr>+s8Br3>*P1uxs!Kk~2mif%>B~OgI=}MZe57=Lds|eUpJ)$Br1_Xdi>8tDnm{
Hr-UW|8SNpn

diff --git a/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedRowsAndFixedSizeColumnsWithFillFalse.png b/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedRowsAndFixedSizeColumnsWithFillFalse.png
index fab3254c6d252aa60fcf21556da2f5bc0b46b357..8c5a3bad9569ae546e0bc67760e3b2a70b923a30 100644
GIT binary patch
literal 4031
zcmeAS@N?(olHy`uVBq!ia0y~yU_8XY!2E)P4JhKf;hzly1Am*Ri(^Q|t+!VXavo6-
zaSfC%PM3VglI_W8HqmYq*GdJ}mY0wGMVl1ck7qtmzBeU^rTELgBc-tnIy#)w1eiD!
zoj4R)I20QMlv)^^Iw%z2TIkNE(Bj0=Ai$-_;H1&Qz_Cz(X@CSc7A9~~$y=bH(ExgD
zfP8}0T8v2hFjwH(FYad&kH4K@2;*O<%%IRRND;@NcAO#u2i?#^=`YLOH)Vc4#-J$T
zq{t%R1f(cuI&jE3a<mEvIJE?DFe<vxhzWGCh?4_H>xCAeO^POpEI`|Qf%b_w3DZQl
z^@21r(27<8pq)T}QO;B>;Q;$U5E$|;0yJU<a6I**VW1!f_#Q*NAyXjuST3-BswYSp
zBaukJ$(?~nrSw-O;M6`y9Y>vDOV}uocUz2M&FU%2L0oAcPcVS8Gcc>M0Hav|R7wn#
z0MKesS=9o}iGsl5$_1Di1t=5{aq8z8Xm7!SSHS6@5S6?I4;n0ymcYCA?ZnR~Rh&2u
zEawEamN*6{Y7nqu8k{Zzx(etx7P>i3=jY5DTc$3qNOs}?HfxnyK#g3QGPxEy!`q#}
zwlu5>N)|I5sJlU67SPEGEo#7~EXP7lVAI?wgEqnfRdfiXh1*|)IvPN40HcEo*wm+#
zNso{LhdQt?0g4UW$!Cqy{F$D&?(H#DWMLo+0h@qK<msffE}+X8X>AAD=9B5ThVUQE
ZI^mb3-<a)^19r?AJYD@<);T3K0RR=NuZsWx

literal 4057
zcmeAS@N?(olHy`uVBq!ia0y~yU_8XY!2E)P4JhKf;hzly1OEa~7srr_TW_yA^0pWV
zv|W^X942{ZRtPtfK_kB(3oD1hju}@swBIZ#kN;=G{8lAiQ?*HE@BPAg>I}@<O{y&n
zP8|YF9EwgH3N0Lp4FXCO3OKzu!O#-G!6@LQ$l}1!D!`y9;xteKiXu9SECNm~0uCI4
zP7I1J9E>dj6bQ5ey){_8266|6Xa1?TeE!2?dF^Xa3d7>|3(5=%ErS$sEOcjZ;9wk_
zNWh7Ke&|sCh4*qtFFiX3$|#`33Cb@NGaWc=n*_KNfmwQ?0245S(}t<h;-t~iAi%Yd
z6KIoDh7$+Swpl>?G+NYXBFwc=ni-hzTY>o*ninZ#Dt-|F`#`A$=ypXKF&7G)no7e!
zK@RYphIm7!K;ZS(V}H)56ec$aFcFCqTI3iR6j=r*0w!}71}Ba|h#CZ{SQuIaC`D}C
z4>##B9(X=QNM&Vd{eOEIRbX~gWB{gA22joh<~k1Q3QVJBTL9Fa-~u`m=u|F}nTtVX
zA?=zF4jioBSgKHrI+a)f%8G5w7E+PVWyeX^%<$$sVDe`gglQk*Br4?q%JUFb6Yz#B
z8HJr&(03_NE#4vkOtrv<CNMb+My7~UKd9h9$&J851Xz&+>uyd^TOk8n3(f+!7}RJY
z46Mb4oj_d!MHXOXE;tC8kaj*w+d{x;rx36>YPkSvcq^I!qt}7M7w888Ct+#}n}Zuq
zzz!KOqLe`GC{!lTqFmi&$x5BTK%_}CwPjHE8x$Eh1|@QOA&5OTeuV136uTttH;wH#
Qu*=Ti>FVdQ&MBb@00Lmnh5!Hn

diff --git a/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedSizeRowsAndFixedSizeColumns.png b/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedSizeRowsAndFixedSizeColumns.png
index ef8350868c8fdf73418d5007f4414448d6693736..5c3f5022ba7eb09d5bbc3673d00e6248073a1414 100644
GIT binary patch
literal 4470
zcmdT{T}YEr7(UY>$E9%86`@uh`(dDjhMHib?YPi|t|eZGH)-}uSRrL43TnsFC^uJR
zT2M>ENR(-y;YDVe5jr#qvQ}t%Gcj*O=~wMNnh@Rix6$YJj_=ufaem&P=Y761qandp
z5vV{2`RWsODG14)BjoACUf@Z#P47a;Pp#K!Q_p`Gd)JuE_A6h0j+3jyB09tRHAxRo
zC2NP#7VaBi-I}_-s>ou9w3^4yraLxh6AG{2`##>=^2~l=+IGWVTb}OdAIn7_ZJ}ul
zhj2^_Nhn9Glz3peLWhc%`)F_pK~%{QH)0uKRQ{hFgthxKM0Hrk36&GZi3a;E;27M^
zZH_5L&fCkCX>ASqAy2Oce`Ye*Hb-B1V813~DlP&9542)fNb=+mC2=MyhZDL78gU6^
z0TvH{ol5#RfrLcCeny<^7Ppe^^uku6fSOWRp`extGh5&P4F9pIz!Gc<uzdL%HW0yZ
z%XY)eT1!oKT~IvMLXB|(x6rN<XoJ%ds6{QL+ZB*bU})A-QVgw&>EF;wS|eQ$8uR0h
z{EgZ5hmOC>iR~%qz_c=Mrm;LFai~l5w&*8#tQ=~vx)`bjSO}^G?&BT^ZL8v<A~U>U
zE5UT|AG--Mr%OVV)N-JHD7MPn3ABUJ;!JP~;zXiGCkVn+ipHFNh%kv7@7s(*xI}G9
z`TW&R47G32U~aTMX0LZs><%f&1ffpg2UBwKGGSpMA%<;*OpqGz4F>9=LNTC)9c^8v
zEKAh6-q$1f79B3CQ{8Mn;&{^7<CqkytYD=6Gl@g^HaHlzdJEn?HcOAyv+V0?_dNH4
zw1nG-3L177v;zJ8NhRo>`K&G#PM5zpsJv}g>+?>jEk1WIJ<X)NJ9}T-qv46s>fn<;
zRLC|0UjVBD>O^%5;nD67rxsNXLd0(l>abdj-B2#x0~mGzRB@Mth@a^`JXJ>Zflc8j
zCVkh?)1&v5mOEL_u2~5Sq8^gqR_F?KGpCQZ(I#GnAm}9^zug6ART(V)>6R<h%}C5e
znSNbOMNq(U$0F~Gm+H*2CLj%#Nz({3p+e#zO_Qz+Sumx81K+&*HCHo_+9AO3(eE+n
I8dyg0Z?|-a82|tP

literal 4492
zcmdT|T}V_x6du<#XE%&lGy4(6SuOV=(#%{Ft=;kWDl3v@^iXQ0`I0DsL>ex3w=~oi
zje<brQc@(AAqFXh{TU&cMiv<=29*zK7NwP$omqm64BOmGD|a3~4wpMS=bZ0+-)wnm
zN`i-al^P-BAtc6bMabngLaxJj5kyQ)-=YxGqzSRcZHM|so=Pb!YsLMcx7y(W#qt70
zd4)bdG|y|X5FWqbMNW|BV!GB;5Re#UY99HRuUfJ@u6TU#ple<5*QQgR#;Vr5J<ZQh
ze#ePS6*UvBh*%j>V9Kz+i02oONMtCYUJQw;*o82vG++z)PXPmVOU5oDp-RF;V!#@P
zXzUyTb21+4?cHxZck@Wq%g*Y+&F$?18`ivkZ1TPL=v4<l3I7~F;k=;%N0$;cg`7)7
z0Tqx3>O`g!%|tD!U?-N#Fzj{~_S1=LWC^P!A6F>81rlz79{5)n(*Ndw_l*fZVSG|0
zTzhVL7{c)Db$!$72R&geJ~7w`JBS3nZd@R+34Ses{xd=!Is(!U7#LedN`b$a&V&+a
zUGIR@SdaD>`<Zst)YHy9{lv<6ylG&lGct*mJEXopI|L45>rkx-y-8()5)i=F^rfqL
z*Tbj-8fayL4x>Qf)v~F5%u~MzQ}mY$h7}^rNtf6igZxEjTv$p#2JGUTi?EZ(Occ(!
z?5gLOdrU-aimSOUEy;TR(v!jIqKG7!-N9OW<bQ61Fb~;JP=NqrK79~OImA_e?!cMc
z;w@D@cgg~5yWE8@Q$bW&wWF~?cRE~Om@_REaep<7$`W?n6O4-3&21PB1FK@dCQwYm
zmO47Dx7i4J2kLwVwL}j8o+R$w?9Iui=!V{nLS7#!%xDXI_jwtMD9<g~S+lqQSa&5A
zc_rb|0ay?aOW^%yx`x@kgdI^(9`3WL5=@SU{eX~XZh0(@Ns)DQEZbDwmLBI_mqC?X
zQwi~t*}nDGyOlO?3wIdEKjt>q$)Ha3<CmddE)6!~az@^=F_qZ*QN!6O1BCoLB1P8G
zf{2RVOoJzoUKSO1av647TNNNnHSCi1KfR2l<4)?VxUFh08F#zTSdn$5C3rjh%YuZs
Kl-SEGv-CUYBC!ns

diff --git a/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedSizeRowsAndFixedSizeColumnsWithFillFalse.png b/grid/src/test/snapshots/images/com.cheonjaeung.compose.grid_BoxGridTest_testFixedSizeRowsAndFixedSizeColumnsWithFillFalse.png
index 2ee1bf47fc5bc531b8ed40d7cf11eb1e813ee2eb..efb8e0c877602bcf2c48e6166003aa714a8260d6 100644
GIT binary patch
literal 4223
zcmeAS@N?(olHy`uVBq!ia0y~yU_8XY!2E)P4JhKf;hzlygMgc-i(^Q|t+#hJdPOHn
z9Dn%!*qJG3wKZ7o@a+&`-_6Cww~U2J_OfI9B_G$W-Lg#u3ThD>JeZFzRoL0ReMz;S
zjLf0g?fuW$?*0F8dtZ>3i`(9NTF*XPGHlUu;%E@yQe<$_Xkp-3D8Qu9GIRvk*c><*
zF_D0iB1=NQ^A0{Yx5XFbnVC1(w)8PH2r%JBpQ5(g=Rf{+z0~V_ceOOLlgI8?OS>k0
z@s(d@#?~UB$Rgm>BH+Lw=)|Dt!oi3tAOf@uXrTyDZpbiOE(o>+a4-Tr(<%V;8tKej
z9u7q(4uzJSf}g*Q{Qk{baz#f97;GF2cv1fIpF90tzI?g5){!G|cgLhlSywmfb0~5s
zDzqrHGzc^aFgbBJai9ux0Mn*I3n*baQHRN~P#KiOflvcz>)>Q&#0xkHI5}`EJX&Pw
z_wwV%-M|3DlFpG*e)+{Bo4)C*yfQDE08{LQveyYNnwqvg%SV$hw)728z8f-T{Xcl(
z#6H|51D-;II#LQP41*H^Gs+-!88Ey!7CH}7#|`RWdsEH9-t5TWFxxL(Y^jSMp8C@P
zST%rZGzL)Z0IE=jiU2b+FnMgac=6(P3yT>`RazL{n1URSv-m8#dh~d=#owA)mu@aM
zmgZJ;*!^#Xyz0x>_eyhhS{Q(p4iluR<4|l6P(l>|RvtiUU_An=!N_1by$}F4y?|94
zuzKSH8b2hMw;~`dpc@P1t`+`xY_RmP{&6!gCk6q0=!R=}`1{Atp2d27bLD7Uo3`1{
zWy+K{-PkI8q!z&7tejDr4Zz$EYCQv6EenCEgBr|R;)*OS0xbeJa%}zyO!k~QsTSDm
z#2dH`=EiGY?|5AnJS$}124SZLUAMn=z}kOpaz-+qmMbVf18oWbwra^|0?P)V39Z1k
zaqEy_UN{D7xpF8vc=Mb;A1rlkYb~&(Yat6MmT-`%lRW!~*QHp(GDuwp^uyqG91DZu
mU_=favWyhEtl{ow{?$Kw`u@GIJ`NmMVDNPHb6Mw<&;$Vgq=2FT

literal 4240
zcmeAS@N?(olHy`uVBq!ia0y~yU_8XY!2E)P4JhKf;hzlygFv{ai(^Q|t+!V<dd*H0
zIsWkbu`^T7YHRFZ-DlZ+;pD*t6_+1vdXt*+xb%YVycJ-QKf=N-mbqYuh)Q{3*WJk>
z1sv-9`saD){O8^u<mKYV&VG8v*))a?VS-K!Edd;i0#1r74jiol42mK{M!>{?!HEMC
zH3)DiGFZzT+MbXSa(zE9&w*zGR!o@6kVH=W-}S#xe!G2saMcX^8xjIe*H*`^*6_Ul
zqcA7gfdd#qiY^?CEdq)x0!}RgXab<{0%DNdP+>Z7$T|X}8t55d!~?xXGV{W*1_7lO
z2B#BT)A#Ew{=Iy5ka2zv4~HTHUQ{z@`t&-l^XJ3Au`0HlRr2yW{j{;xk;4(_1{Ot@
z7J(L^iv*k;PzA_!A}*gfa>z0Q;|XLF$kxHh{M{tbB*5gvk*y=Pc*?wa`)-Q22r%G7
z1=6~1i!0Wyn)1vy8JJ=t-|I>QdU^Ff-q;I@UtCESl$Kk80R;@>)}h2yECIzEC?A57
z4H-;nW~UATCJsgIGqaz?8yIcUS7>1vD1<l5;LlLBm34Z-L0bzb@ww9rfkEoHK^<(n
z<qjQ85MX%I7q`AINNH(V^{02$9E#uy(@CR+fn%WnlR}FV#}F0(Iv?l}Aa>$_GwoQx
z9@@R=zJ2%Jy_sHf&-Ds0HQ+`HEqx3*ix=y=7ykHap!%Cj@qpXfOl_}A>G4=w07y*&
zU|9sJ#Xw~)9ho9d?w~f@0F~hv_JM+$L-9b?)lkvj_rC{kT8}$u!J&RgOp4F{@w<1y
zUgF}h(#kCds!H#6cTBpJa%r2P69<PPhoVA@LQ4ar4n!4b0=Dgd3Kjz8h8a@{nCO7X
z7UXwO<%G=4NQN|x5?UXAFj=>L^^|kx?QcscvM}I9KP=4W`uW^?JLQdb3xl+8^xBS~
zAW+nBC_>^3(u4!og9rgoMgfNSLSXZbo=mQV%4m5ODf`l#nE}n$30pT$p1h*JpKuDs
zS9%aASnx;>tkgg?fC$>l0ZbeO6%CXEj)l&H)Nw=w+k`{${i}O=PtFv&3mj=+@O1Ta
JS?83{1OPfMK$HLg


From 7e189d808075cc92d4cc05b8d4b7b14b637f8150 Mon Sep 17 00:00:00 2001
From: Cheon Jaeung <cheonjaewoong@gmail.com>
Date: Wed, 15 Oct 2025 20:58:05 +0900
Subject: [PATCH 5/5] Fix divide by zero bug in FixedSize

---
 .../kotlin/com/cheonjaeung/compose/grid/SimpleGridCells.kt  | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/grid/src/commonMain/kotlin/com/cheonjaeung/compose/grid/SimpleGridCells.kt b/grid/src/commonMain/kotlin/com/cheonjaeung/compose/grid/SimpleGridCells.kt
index df55531..7a9b532 100644
--- a/grid/src/commonMain/kotlin/com/cheonjaeung/compose/grid/SimpleGridCells.kt
+++ b/grid/src/commonMain/kotlin/com/cheonjaeung/compose/grid/SimpleGridCells.kt
@@ -168,7 +168,11 @@ interface SimpleGridCells {
             val cellSizeWithSpacing = cellSize + spacing
 
             return if (cellSizeWithSpacing < availableSizeWithSpacing) {
-                val count = availableSizeWithSpacing / cellSizeWithSpacing
+                val count = if (cellSizeWithSpacing != 0) {
+                    availableSizeWithSpacing / cellSizeWithSpacing
+                } else {
+                    1
+                }
                 return List(count) { cellSize }
             } else {
                 List(1) { availableSize }