From cd5488d8701b7b0f2d08ceac0e4e6c517bc002c6 Mon Sep 17 00:00:00 2001 From: samuelsumbane Date: Tue, 9 Dec 2025 22:31:10 +0200 Subject: [PATCH 1/3] WIP: Implement fillMaxSize in datatable --- .env | 2 + .idea/appInsightsSettings.xml | 19 +- .idea/caches/deviceStreaming.xml | 1394 +++++++++++++++++ .idea/migrations.xml | 10 + .../paging/PaginatedDataTableState.kt | 14 +- 5 files changed, 1436 insertions(+), 3 deletions(-) create mode 100644 .env create mode 100644 .idea/caches/deviceStreaming.xml create mode 100644 .idea/migrations.xml diff --git a/.env b/.env new file mode 100644 index 0000000..8f8e461 --- /dev/null +++ b/.env @@ -0,0 +1,2 @@ +export JAVA_HOME=/usr/lib/jvm/temurin-11-jdk +export PATH=$JAVA_HOME/bin:$PATH diff --git a/.idea/appInsightsSettings.xml b/.idea/appInsightsSettings.xml index 96637de..0829d0e 100644 --- a/.idea/appInsightsSettings.xml +++ b/.idea/appInsightsSettings.xml @@ -8,7 +8,7 @@ + + + + + + + diff --git a/.idea/caches/deviceStreaming.xml b/.idea/caches/deviceStreaming.xml new file mode 100644 index 0000000..351bf19 --- /dev/null +++ b/.idea/caches/deviceStreaming.xml @@ -0,0 +1,1394 @@ + + + + + + \ No newline at end of file diff --git a/.idea/migrations.xml b/.idea/migrations.xml new file mode 100644 index 0000000..f8051a6 --- /dev/null +++ b/.idea/migrations.xml @@ -0,0 +1,10 @@ + + + + + + \ No newline at end of file diff --git a/datatable/src/commonMain/kotlin/com/seanproctor/datatable/paging/PaginatedDataTableState.kt b/datatable/src/commonMain/kotlin/com/seanproctor/datatable/paging/PaginatedDataTableState.kt index ad70c54..629a5f0 100644 --- a/datatable/src/commonMain/kotlin/com/seanproctor/datatable/paging/PaginatedDataTableState.kt +++ b/datatable/src/commonMain/kotlin/com/seanproctor/datatable/paging/PaginatedDataTableState.kt @@ -1,9 +1,13 @@ package com.seanproctor.datatable.paging -import androidx.compose.runtime.* +import androidx.compose.runtime.Composable +import androidx.compose.runtime.Stable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.saveable.Saver import androidx.compose.runtime.saveable.listSaver import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.runtime.setValue interface PaginatedDataTableState { var pageSize: Int @@ -36,8 +40,14 @@ fun rememberPaginatedDataTableState( initialPageSize: Int, initialPageIndex: Int = 0, initialCount: Int = 0, + ): PaginatedDataTableState { return rememberSaveable(saver = PaginatedDataTableStateImpl.Saver) { PaginatedDataTableStateImpl(initialPageSize, initialPageIndex, initialCount) } -} \ No newline at end of file +} + +sealed class SizePage { + data object FillMaxHeight : SizePage() + data class FixedSize(val initialPageSize: Int) : SizePage() +} From e29f22384ec047833b00f542190bb21af7a68512 Mon Sep 17 00:00:00 2001 From: samuelsumbane Date: Wed, 10 Dec 2025 19:07:37 +0200 Subject: [PATCH 2/3] WIP: Implement fillMaxSize in datatable --- .idea/caches/deviceStreaming.xml | 1394 ----------------- .../datatable/material3/PaginatedDataTable.kt | 15 +- .../paging/BasicPaginatedDataTable.kt | 81 +- .../paging/PaginatedDataTableState.kt | 22 +- .../com/seanproctor/datatable/demo/App.kt | 15 +- 5 files changed, 97 insertions(+), 1430 deletions(-) delete mode 100644 .idea/caches/deviceStreaming.xml diff --git a/.idea/caches/deviceStreaming.xml b/.idea/caches/deviceStreaming.xml deleted file mode 100644 index 351bf19..0000000 --- a/.idea/caches/deviceStreaming.xml +++ /dev/null @@ -1,1394 +0,0 @@ - - - - - - \ No newline at end of file diff --git a/datatable-material3/src/commonMain/kotlin/com/seanproctor/datatable/material3/PaginatedDataTable.kt b/datatable-material3/src/commonMain/kotlin/com/seanproctor/datatable/material3/PaginatedDataTable.kt index d56805f..0c9b8e1 100644 --- a/datatable-material3/src/commonMain/kotlin/com/seanproctor/datatable/material3/PaginatedDataTable.kt +++ b/datatable-material3/src/commonMain/kotlin/com/seanproctor/datatable/material3/PaginatedDataTable.kt @@ -3,6 +3,7 @@ package com.seanproctor.datatable.material3 import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.PaddingValues import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxHeight import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.padding @@ -12,15 +13,20 @@ import androidx.compose.material3.IconButton import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Text import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.graphics.Color +import androidx.compose.ui.platform.LocalWindowInfo import androidx.compose.ui.unit.Dp import androidx.compose.ui.unit.dp import com.seanproctor.datatable.DataColumn import com.seanproctor.datatable.DataTableScope import com.seanproctor.datatable.paging.BasicPaginatedDataTable import com.seanproctor.datatable.paging.PaginatedDataTableState +import com.seanproctor.datatable.paging.rememberPaginatedDataTableState import com.seanproctor.datatable_material3.generated.resources.Res import com.seanproctor.datatable_material3.generated.resources.chevron_left import com.seanproctor.datatable_material3.generated.resources.chevron_right @@ -45,6 +51,7 @@ fun PaginatedDataTable( logger: ((String) -> Unit)? = null, content: DataTableScope.() -> Unit, ) { + BasicPaginatedDataTable( columns = columns, modifier = modifier, @@ -55,15 +62,15 @@ fun PaginatedDataTable( headerBackgroundColor = headerBackgroundColor, footerBackgroundColor = footerBackgroundColor, state = state, - footer = { + footer = { pageSize -> Row( modifier = Modifier.height(rowHeight).padding(horizontal = 16.dp).fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(16.dp, alignment = Alignment.End), verticalAlignment = Alignment.CenterVertically, ) { - val start = min(state.pageIndex * state.pageSize + 1, state.count) - val end = min(start + state.pageSize - 1, state.count) - val pageCount = (state.count + state.pageSize - 1) / state.pageSize + val start = min(state.pageIndex * pageSize + 1, state.count) + val end = min(start + pageSize - 1, state.count) + val pageCount = (state.count + pageSize - 1) / pageSize Text("$start-$end of ${state.count}") IconButton( onClick = { state.pageIndex = 0 }, diff --git a/datatable/src/commonMain/kotlin/com/seanproctor/datatable/paging/BasicPaginatedDataTable.kt b/datatable/src/commonMain/kotlin/com/seanproctor/datatable/paging/BasicPaginatedDataTable.kt index b0946e2..250b573 100644 --- a/datatable/src/commonMain/kotlin/com/seanproctor/datatable/paging/BasicPaginatedDataTable.kt +++ b/datatable/src/commonMain/kotlin/com/seanproctor/datatable/paging/BasicPaginatedDataTable.kt @@ -1,9 +1,14 @@ package com.seanproctor.datatable.paging +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.runtime.* import androidx.compose.ui.Modifier import androidx.compose.ui.graphics.Color +import androidx.compose.ui.layout.onGloballyPositioned +import androidx.compose.ui.platform.LocalDensity import androidx.compose.ui.unit.Dp import androidx.compose.ui.unit.dp import com.seanproctor.datatable.* @@ -14,39 +19,69 @@ fun BasicPaginatedDataTable( state: PaginatedDataTableState, modifier: Modifier = Modifier, separator: @Composable () -> Unit = { }, - headerHeight: Dp = Dp.Unspecified, - rowHeight: Dp = Dp.Unspecified, + headerHeight: Dp, + rowHeight: Dp, contentPadding: PaddingValues = PaddingValues(horizontal = 16.dp), headerBackgroundColor: Color = Color.Unspecified, footerBackgroundColor: Color = Color.Unspecified, - footer: @Composable () -> Unit = { }, + footer: @Composable (Int) -> Unit = { }, cellContentProvider: CellContentProvider = DefaultCellContentProvider, sortColumnIndex: Int? = null, sortAscending: Boolean = true, logger: ((String) -> Unit)? = null, content: DataTableScope.() -> Unit ) { - BasicDataTable( - columns = columns, - modifier = modifier, - state = remember(state.pageSize, state.pageIndex) { DataTableState() }, - separator = separator, - headerHeight = headerHeight, - rowHeight = rowHeight, - contentPadding = contentPadding, - headerBackgroundColor = headerBackgroundColor, - footerBackgroundColor = footerBackgroundColor, - footer = footer, - cellContentProvider = cellContentProvider, - sortColumnIndex = sortColumnIndex, - sortAscending = sortAscending, - logger = logger, + var pageSize by remember { mutableStateOf(state.pageSize) } + var calculated by remember { mutableStateOf(false) } + val density = LocalDensity.current + + Box( + Modifier + .fillMaxSize() + .onGloballyPositioned { coords -> + val heightPx = coords.size.height.toFloat() + + val rowHeightPx = with(density) { rowHeight.toPx() } + + val rows = (heightPx / rowHeightPx).toInt() + pageSize = rows - 3 + println("pageRows is: $rows") + println("pageSize is: $pageSize") + } ) { - val start = state.pageIndex * state.pageSize - val scope = PaginatedRowScope(start, start + state.pageSize, this) - content(scope) - if (state.count != scope.index) { - state.count = scope.index + BasicDataTable( + columns = columns, + modifier = modifier + // .onGloballyPositioned { coords -> + // if (!calculated) { + // val tableHeight = coords.size.height.dp + // val pageRows = ((tableHeight - rowHeight) / rowHeight).toInt() + // pageSize = pageRows - 1 + // println("pageRows is: $pageRows") + // println("pageSize is: $pageSize") + // calculated = true + // } + // }, + , + state = remember(pageSize, state.pageIndex) { DataTableState() }, + separator = separator, + headerHeight = headerHeight, + rowHeight = rowHeight, + contentPadding = contentPadding, + headerBackgroundColor = headerBackgroundColor, + footerBackgroundColor = footerBackgroundColor, + footer = { footer(pageSize) }, + cellContentProvider = cellContentProvider, + sortColumnIndex = sortColumnIndex, + sortAscending = sortAscending, + logger = logger, + ) { + val start = state.pageIndex * pageSize + val scope = PaginatedRowScope(start, start + pageSize, this) + content(scope) + if (state.count != scope.index) { + state.count = scope.index + } } } } diff --git a/datatable/src/commonMain/kotlin/com/seanproctor/datatable/paging/PaginatedDataTableState.kt b/datatable/src/commonMain/kotlin/com/seanproctor/datatable/paging/PaginatedDataTableState.kt index 629a5f0..f660561 100644 --- a/datatable/src/commonMain/kotlin/com/seanproctor/datatable/paging/PaginatedDataTableState.kt +++ b/datatable/src/commonMain/kotlin/com/seanproctor/datatable/paging/PaginatedDataTableState.kt @@ -8,6 +8,8 @@ import androidx.compose.runtime.saveable.Saver import androidx.compose.runtime.saveable.listSaver import androidx.compose.runtime.saveable.rememberSaveable import androidx.compose.runtime.setValue +import androidx.compose.ui.platform.LocalWindowInfo +import androidx.compose.ui.unit.dp interface PaginatedDataTableState { var pageSize: Int @@ -37,17 +39,25 @@ private class PaginatedDataTableStateImpl ( @Composable fun rememberPaginatedDataTableState( - initialPageSize: Int, +// initialPageSize: Int, + initialPageSize: PageSize, initialPageIndex: Int = 0, initialCount: Int = 0, + ): PaginatedDataTableState { +// val windowInfo = LocalWindowInfo.current +// val tableHeaderHeight = 56.dp +// val tableRowHeight = 52.dp +// val windowHeight = ((windowInfo.containerSize.height.dp - tableHeaderHeight) / tableRowHeight).toInt() +// println("window: ${windowInfo.containerSize.height.dp}, sum: ${tableRowHeight}, all: ${windowHeight}") -): PaginatedDataTableState { return rememberSaveable(saver = PaginatedDataTableStateImpl.Saver) { - PaginatedDataTableStateImpl(initialPageSize, initialPageIndex, initialCount) + val pageSizeValue = if (initialPageSize is PageSize.FixedSize) initialPageSize.initialPageSize else 5 + PaginatedDataTableStateImpl(pageSizeValue, initialPageIndex, initialCount) } } -sealed class SizePage { - data object FillMaxHeight : SizePage() - data class FixedSize(val initialPageSize: Int) : SizePage() +sealed class PageSize { + data object FillMaxHeight : PageSize() + data class FixedSize(val initialPageSize: Int) : PageSize() } + diff --git a/demo-common/src/commonMain/kotlin/com/seanproctor/datatable/demo/App.kt b/demo-common/src/commonMain/kotlin/com/seanproctor/datatable/demo/App.kt index 3d54cf7..a521210 100644 --- a/demo-common/src/commonMain/kotlin/com/seanproctor/datatable/demo/App.kt +++ b/demo-common/src/commonMain/kotlin/com/seanproctor/datatable/demo/App.kt @@ -1,10 +1,13 @@ package com.seanproctor.datatable.demo +import androidx.compose.foundation.background import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Spacer import androidx.compose.foundation.layout.fillMaxHeight import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.padding import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.MaterialTheme @@ -29,6 +32,7 @@ import com.seanproctor.datatable.TableColumnWidth import com.seanproctor.datatable.material3.DataTable import com.seanproctor.datatable.material3.LazyPaginatedDataTable import com.seanproctor.datatable.material3.PaginatedDataTable +import com.seanproctor.datatable.paging.PageSize import com.seanproctor.datatable.paging.rememberPaginatedDataTableState import io.github.oikvpqya.compose.fastscroller.HorizontalScrollbar import io.github.oikvpqya.compose.fastscroller.VerticalScrollbar @@ -41,6 +45,7 @@ fun App(onRowClick: (Int) -> Unit) { Surface(Modifier.fillMaxSize()) { Column { var selectedIndex by remember { mutableStateOf(0) } +// Spacer(Modifier.height(90.dp)) PrimaryTabRow( selectedTabIndex = selectedIndex ) { @@ -135,10 +140,13 @@ fun App(onRowClick: (Int) -> Unit) { 1 -> { PaginatedDataTable( columns = columns, - state = rememberPaginatedDataTableState(5), +// state = rememberPaginatedDataTableState(5), + state = rememberPaginatedDataTableState(initialPageSize = PageSize.FillMaxHeight), sortColumnIndex = sortColumnIndex, sortAscending = sortAscending, - modifier = Modifier.fillMaxWidth().padding(16.dp), + modifier = Modifier.fillMaxWidth() + .background(Color.Red) + .padding(16.dp), logger = { println(it) } ) { generateTable( @@ -152,7 +160,8 @@ fun App(onRowClick: (Int) -> Unit) { else -> { LazyPaginatedDataTable( columns = columns, - state = rememberPaginatedDataTableState(initialPageSize = 5, initialCount = sortedData.size), +// state = rememberPaginatedDataTableState(initialPageSize = 5, initialCount = sortedData.size), + state = rememberPaginatedDataTableState(initialPageSize = PageSize.FixedSize(2), initialCount = sortedData.size), sortColumnIndex = sortColumnIndex, sortAscending = sortAscending, modifier = Modifier.fillMaxWidth().padding(16.dp), From 485d2226015a47f26de831f49d8ea2b10bfb3985 Mon Sep 17 00:00:00 2001 From: samuelsumbane Date: Wed, 10 Dec 2025 20:51:38 +0200 Subject: [PATCH 3/3] feat: add dynamic page size support to PaginatedDataTable --- .env | 2 - README.md | 40 +++++++++++++- .../datatable/material3/PaginatedDataTable.kt | 1 - .../paging/BasicPaginatedDataTable.kt | 52 +++++++++---------- .../paging/PaginatedDataTableState.kt | 20 ++++--- .../com/seanproctor/datatable/demo/App.kt | 14 ++--- 6 files changed, 76 insertions(+), 53 deletions(-) delete mode 100644 .env diff --git a/.env b/.env deleted file mode 100644 index 8f8e461..0000000 --- a/.env +++ /dev/null @@ -1,2 +0,0 @@ -export JAVA_HOME=/usr/lib/jvm/temurin-11-jdk -export PATH=$JAVA_HOME/bin:$PATH diff --git a/README.md b/README.md index e55c309..efbce73 100644 --- a/README.md +++ b/README.md @@ -56,7 +56,7 @@ DataTable( } ``` -Draw a paginated table +Draw a paginated table with fixed size ```kotlin PaginatedDataTable( columns = listOf( @@ -70,7 +70,7 @@ PaginatedDataTable( Text("Column3") }, ), - state = rememberPaginatedDataTableState(5), + state = rememberPaginatedDataTableState(initialSize = PageSize.FixedSize(5)), ) { for (rowIndex in 0 until 100) { row { @@ -88,3 +88,39 @@ PaginatedDataTable( } } ``` + + +Draw paginated table with dynamic size (fill available height) + +```kotlin +PaginatedDataTable( + columns = listOf( + DataColumn { + Text("Column1") + }, + DataColumn { + Text("Column2") + }, + DataColumn { + Text("Column3") + }, + ), + state = rememberPaginatedDataTableState(initialSize = PageSize.FillMaxHeight), +) { + for (rowIndex in 0 until 100) { + row { + onClick = { println("Row clicked: $rowIndex") } + cell { + Text("Row $rowIndex, column 1") + } + cell { + Text("Row $rowIndex, column 2") + } + cell { + Text("Row $rowIndex, column 3") + } + } + } +} +``` + diff --git a/datatable-material3/src/commonMain/kotlin/com/seanproctor/datatable/material3/PaginatedDataTable.kt b/datatable-material3/src/commonMain/kotlin/com/seanproctor/datatable/material3/PaginatedDataTable.kt index 0c9b8e1..c7c9bd5 100644 --- a/datatable-material3/src/commonMain/kotlin/com/seanproctor/datatable/material3/PaginatedDataTable.kt +++ b/datatable-material3/src/commonMain/kotlin/com/seanproctor/datatable/material3/PaginatedDataTable.kt @@ -51,7 +51,6 @@ fun PaginatedDataTable( logger: ((String) -> Unit)? = null, content: DataTableScope.() -> Unit, ) { - BasicPaginatedDataTable( columns = columns, modifier = modifier, diff --git a/datatable/src/commonMain/kotlin/com/seanproctor/datatable/paging/BasicPaginatedDataTable.kt b/datatable/src/commonMain/kotlin/com/seanproctor/datatable/paging/BasicPaginatedDataTable.kt index 250b573..66b6266 100644 --- a/datatable/src/commonMain/kotlin/com/seanproctor/datatable/paging/BasicPaginatedDataTable.kt +++ b/datatable/src/commonMain/kotlin/com/seanproctor/datatable/paging/BasicPaginatedDataTable.kt @@ -1,17 +1,25 @@ package com.seanproctor.datatable.paging -import androidx.compose.foundation.background import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.PaddingValues import androidx.compose.foundation.layout.fillMaxSize -import androidx.compose.runtime.* +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue import androidx.compose.ui.Modifier import androidx.compose.ui.graphics.Color import androidx.compose.ui.layout.onGloballyPositioned import androidx.compose.ui.platform.LocalDensity import androidx.compose.ui.unit.Dp import androidx.compose.ui.unit.dp -import com.seanproctor.datatable.* +import com.seanproctor.datatable.BasicDataTable +import com.seanproctor.datatable.CellContentProvider +import com.seanproctor.datatable.DataColumn +import com.seanproctor.datatable.DataTableScope +import com.seanproctor.datatable.DataTableState +import com.seanproctor.datatable.DefaultCellContentProvider @Composable fun BasicPaginatedDataTable( @@ -19,8 +27,8 @@ fun BasicPaginatedDataTable( state: PaginatedDataTableState, modifier: Modifier = Modifier, separator: @Composable () -> Unit = { }, - headerHeight: Dp, - rowHeight: Dp, + headerHeight: Dp = Dp.Unspecified, + rowHeight: Dp = Dp.Unspecified, contentPadding: PaddingValues = PaddingValues(horizontal = 16.dp), headerBackgroundColor: Color = Color.Unspecified, footerBackgroundColor: Color = Color.Unspecified, @@ -32,37 +40,29 @@ fun BasicPaginatedDataTable( content: DataTableScope.() -> Unit ) { var pageSize by remember { mutableStateOf(state.pageSize) } - var calculated by remember { mutableStateOf(false) } val density = LocalDensity.current Box( Modifier .fillMaxSize() .onGloballyPositioned { coords -> - val heightPx = coords.size.height.toFloat() - - val rowHeightPx = with(density) { rowHeight.toPx() } - - val rows = (heightPx / rowHeightPx).toInt() - pageSize = rows - 3 - println("pageRows is: $rows") - println("pageSize is: $pageSize") + /** + * The table size is calculated to fit the screen height. + * This is if pageSize is equal to 'PAGE_SIZE_FIXED_FLAG (-1)' + * + * Otherwise, the table has a fixed size + */ + if (state.pageSize == PAGE_SIZE_FIXED_FLAG) { + val heightPx = coords.size.height.toFloat() + val rowHeightPx = with(density) { rowHeight.toPx() } + val rows = (heightPx / rowHeightPx).toInt() + pageSize = rows - 3 + } } ) { BasicDataTable( columns = columns, - modifier = modifier - // .onGloballyPositioned { coords -> - // if (!calculated) { - // val tableHeight = coords.size.height.dp - // val pageRows = ((tableHeight - rowHeight) / rowHeight).toInt() - // pageSize = pageRows - 1 - // println("pageRows is: $pageRows") - // println("pageSize is: $pageSize") - // calculated = true - // } - // }, - , + modifier = modifier, state = remember(pageSize, state.pageIndex) { DataTableState() }, separator = separator, headerHeight = headerHeight, diff --git a/datatable/src/commonMain/kotlin/com/seanproctor/datatable/paging/PaginatedDataTableState.kt b/datatable/src/commonMain/kotlin/com/seanproctor/datatable/paging/PaginatedDataTableState.kt index f660561..a037ff8 100644 --- a/datatable/src/commonMain/kotlin/com/seanproctor/datatable/paging/PaginatedDataTableState.kt +++ b/datatable/src/commonMain/kotlin/com/seanproctor/datatable/paging/PaginatedDataTableState.kt @@ -8,8 +8,13 @@ import androidx.compose.runtime.saveable.Saver import androidx.compose.runtime.saveable.listSaver import androidx.compose.runtime.saveable.rememberSaveable import androidx.compose.runtime.setValue -import androidx.compose.ui.platform.LocalWindowInfo -import androidx.compose.ui.unit.dp + + +/** + * PAGE_SIZE_FIXED_FLAG (-1) indicates dynamic page size. + * This is only used internally for automatic calculation. + */ +const val PAGE_SIZE_FIXED_FLAG = -1 interface PaginatedDataTableState { var pageSize: Int @@ -39,19 +44,12 @@ private class PaginatedDataTableStateImpl ( @Composable fun rememberPaginatedDataTableState( -// initialPageSize: Int, - initialPageSize: PageSize, + initialSize: PageSize, initialPageIndex: Int = 0, initialCount: Int = 0, ): PaginatedDataTableState { -// val windowInfo = LocalWindowInfo.current -// val tableHeaderHeight = 56.dp -// val tableRowHeight = 52.dp -// val windowHeight = ((windowInfo.containerSize.height.dp - tableHeaderHeight) / tableRowHeight).toInt() -// println("window: ${windowInfo.containerSize.height.dp}, sum: ${tableRowHeight}, all: ${windowHeight}") - return rememberSaveable(saver = PaginatedDataTableStateImpl.Saver) { - val pageSizeValue = if (initialPageSize is PageSize.FixedSize) initialPageSize.initialPageSize else 5 + val pageSizeValue = if (initialSize is PageSize.FixedSize) initialSize.initialPageSize else PAGE_SIZE_FIXED_FLAG PaginatedDataTableStateImpl(pageSizeValue, initialPageIndex, initialCount) } } diff --git a/demo-common/src/commonMain/kotlin/com/seanproctor/datatable/demo/App.kt b/demo-common/src/commonMain/kotlin/com/seanproctor/datatable/demo/App.kt index a521210..6b09282 100644 --- a/demo-common/src/commonMain/kotlin/com/seanproctor/datatable/demo/App.kt +++ b/demo-common/src/commonMain/kotlin/com/seanproctor/datatable/demo/App.kt @@ -1,13 +1,10 @@ package com.seanproctor.datatable.demo -import androidx.compose.foundation.background import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Column -import androidx.compose.foundation.layout.Spacer import androidx.compose.foundation.layout.fillMaxHeight import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.fillMaxWidth -import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.padding import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.MaterialTheme @@ -45,7 +42,6 @@ fun App(onRowClick: (Int) -> Unit) { Surface(Modifier.fillMaxSize()) { Column { var selectedIndex by remember { mutableStateOf(0) } -// Spacer(Modifier.height(90.dp)) PrimaryTabRow( selectedTabIndex = selectedIndex ) { @@ -140,13 +136,10 @@ fun App(onRowClick: (Int) -> Unit) { 1 -> { PaginatedDataTable( columns = columns, -// state = rememberPaginatedDataTableState(5), - state = rememberPaginatedDataTableState(initialPageSize = PageSize.FillMaxHeight), + state = rememberPaginatedDataTableState(initialSize = PageSize.FixedSize(2)), sortColumnIndex = sortColumnIndex, sortAscending = sortAscending, - modifier = Modifier.fillMaxWidth() - .background(Color.Red) - .padding(16.dp), + modifier = Modifier.fillMaxWidth().padding(16.dp), logger = { println(it) } ) { generateTable( @@ -160,8 +153,7 @@ fun App(onRowClick: (Int) -> Unit) { else -> { LazyPaginatedDataTable( columns = columns, -// state = rememberPaginatedDataTableState(initialPageSize = 5, initialCount = sortedData.size), - state = rememberPaginatedDataTableState(initialPageSize = PageSize.FixedSize(2), initialCount = sortedData.size), + state = rememberPaginatedDataTableState(initialSize = PageSize.FillMaxHeight, initialCount = sortedData.size), sortColumnIndex = sortColumnIndex, sortAscending = sortAscending, modifier = Modifier.fillMaxWidth().padding(16.dp),