From 0cdc988baaa21b182bbca389953ea7ca7e61cbff Mon Sep 17 00:00:00 2001 From: nani <87673002+nanihadesuka@users.noreply.github.com> Date: Sun, 21 Apr 2024 01:16:09 +0200 Subject: [PATCH] Rename from normalized prefix --- .../controller/LazyGridStateController.kt | 38 +++++++++---------- .../controller/LazyListStateController.kt | 38 +++++++++---------- .../controller/ScrollStateController.kt | 30 +++++++-------- .../compose/controller/StateController.kt | 4 +- .../compose/generic/ElementScrollbar.kt | 4 +- 5 files changed, 57 insertions(+), 57 deletions(-) diff --git a/lib/src/main/java/my/nanihadesuka/compose/controller/LazyGridStateController.kt b/lib/src/main/java/my/nanihadesuka/compose/controller/LazyGridStateController.kt index 53bf162..4e4062e 100644 --- a/lib/src/main/java/my/nanihadesuka/compose/controller/LazyGridStateController.kt +++ b/lib/src/main/java/my/nanihadesuka/compose/controller/LazyGridStateController.kt @@ -87,7 +87,7 @@ internal fun rememberLazyGridStateController( } - val normalizedThumbSizeReal = remember { + val thumbSizeNormalizedReal = remember { derivedStateOf { state.layoutInfo.let { if (it.totalItemsCount == 0) @@ -107,15 +107,15 @@ internal fun rememberLazyGridStateController( } } - val normalizedThumbSize = remember { + val thumbSizeNormalized = remember { derivedStateOf { - normalizedThumbSizeReal.value.coerceAtLeast(thumbMinLengthUpdated.value) + thumbSizeNormalizedReal.value.coerceAtLeast(thumbMinLengthUpdated.value) } } fun offsetCorrection(top: Float): Float { - val topRealMax = (1f - normalizedThumbSizeReal.value).coerceIn(0f, 1f) - if (normalizedThumbSizeReal.value >= thumbMinLengthUpdated.value) { + val topRealMax = (1f - thumbSizeNormalizedReal.value).coerceIn(0f, 1f) + if (thumbSizeNormalizedReal.value >= thumbMinLengthUpdated.value) { return when { reverseLayout.value -> topRealMax - top else -> top @@ -129,7 +129,7 @@ internal fun rememberLazyGridStateController( } } - val normalizedOffsetPosition = remember { + val thumbOffsetNormalized = remember { derivedStateOf { state.layoutInfo.let { if (it.totalItemsCount == 0 || it.visibleItemsInfo.isEmpty()) @@ -152,15 +152,15 @@ internal fun rememberLazyGridStateController( return remember { LazyGridStateController( - normalizedThumbSize = normalizedThumbSize, - normalizedOffsetPosition = normalizedOffsetPosition, + thumbSizeNormalized = thumbSizeNormalized, + thumbSizeNormalizedReal = thumbSizeNormalizedReal, + thumbOffsetNormalized = thumbOffsetNormalized, thumbIsInAction = thumbIsInAction, _isSelected = isSelected, dragOffset = dragOffset, selectionMode = selectionModeUpdated, realFirstVisibleItem = realFirstVisibleItem, thumbMinLength = thumbMinLengthUpdated, - normalizedThumbSizeReal = normalizedThumbSizeReal, reverseLayout = reverseLayout, orientation = orientationUpdated, nColumns = nColumns, @@ -171,14 +171,14 @@ internal fun rememberLazyGridStateController( } internal class LazyGridStateController( - override val normalizedThumbSize: State, - override val normalizedOffsetPosition: State, + override val thumbSizeNormalized: State, + override val thumbOffsetNormalized: State, override val thumbIsInAction: State, private val _isSelected: MutableState, private val dragOffset: MutableFloatState, private val selectionMode: State, private val realFirstVisibleItem: State, - private val normalizedThumbSizeReal: State, + private val thumbSizeNormalizedReal: State, private val thumbMinLength: State, private val reverseLayout: State, private val orientation: State, @@ -207,13 +207,13 @@ internal class LazyGridStateController( else -> offsetPixels / maxLengthPixels } val currentOffset = when { - reverseLayout.value -> 1f - normalizedOffsetPosition.value - normalizedThumbSize.value - else -> normalizedOffsetPosition.value + reverseLayout.value -> 1f - thumbOffsetNormalized.value - thumbSizeNormalized.value + else -> thumbOffsetNormalized.value } when (selectionMode.value) { ScrollbarSelectionMode.Full -> { - if (newOffset in currentOffset..(currentOffset + normalizedThumbSize.value)) + if (newOffset in currentOffset..(currentOffset + thumbSizeNormalized.value)) setDragOffset(currentOffset) else setScrollOffset(newOffset) @@ -221,7 +221,7 @@ internal class LazyGridStateController( } ScrollbarSelectionMode.Thumb -> { - if (newOffset in currentOffset..(currentOffset + normalizedThumbSize.value)) { + if (newOffset in currentOffset..(currentOffset + thumbSizeNormalized.value)) { setDragOffset(currentOffset) _isSelected.value = true } @@ -259,14 +259,14 @@ internal class LazyGridStateController( } private fun setDragOffset(value: Float) { - val maxValue = (1f - normalizedThumbSize.value).coerceAtLeast(0f) + val maxValue = (1f - thumbSizeNormalized.value).coerceAtLeast(0f) dragOffset.floatValue = value.coerceIn(0f, maxValue) } private fun offsetCorrectionInverse(top: Float): Float { - if (normalizedThumbSizeReal.value >= thumbMinLength.value) + if (thumbSizeNormalizedReal.value >= thumbMinLength.value) return top - val topRealMax = 1f - normalizedThumbSizeReal.value + val topRealMax = 1f - thumbSizeNormalizedReal.value val topMax = 1f - thumbMinLength.value return top * topRealMax / topMax } diff --git a/lib/src/main/java/my/nanihadesuka/compose/controller/LazyListStateController.kt b/lib/src/main/java/my/nanihadesuka/compose/controller/LazyListStateController.kt index 91de6f2..12bdd65 100644 --- a/lib/src/main/java/my/nanihadesuka/compose/controller/LazyListStateController.kt +++ b/lib/src/main/java/my/nanihadesuka/compose/controller/LazyListStateController.kt @@ -58,7 +58,7 @@ internal fun rememberLazyListStateController( fun LazyListItemInfo.fractionVisibleBottom(viewportEndOffset: Int) = if (size == 0) 0f else (viewportEndOffset - offset).toFloat() / size.toFloat() - val normalizedThumbSizeReal = remember { + val thumbSizeNormalizedReal = remember { derivedStateOf { state.layoutInfo.let { if (it.totalItemsCount == 0) @@ -78,15 +78,15 @@ internal fun rememberLazyListStateController( } } - val normalizedThumbSize = remember { + val thumbSizeNormalized = remember { derivedStateOf { - normalizedThumbSizeReal.value.coerceAtLeast(thumbMinLengthUpdated.value) + thumbSizeNormalizedReal.value.coerceAtLeast(thumbMinLengthUpdated.value) } } fun offsetCorrection(top: Float): Float { - val topRealMax = (1f - normalizedThumbSizeReal.value).coerceIn(0f, 1f) - if (normalizedThumbSizeReal.value >= thumbMinLengthUpdated.value) { + val topRealMax = (1f - thumbSizeNormalizedReal.value).coerceIn(0f, 1f) + if (thumbSizeNormalizedReal.value >= thumbMinLengthUpdated.value) { return when { reverseLayout.value -> topRealMax - top else -> top @@ -100,7 +100,7 @@ internal fun rememberLazyListStateController( } } - val normalizedOffsetPosition = remember { + val thumbOffsetNormalized = remember { derivedStateOf { state.layoutInfo.let { if (it.totalItemsCount == 0 || it.visibleItemsInfo.isEmpty()) @@ -120,13 +120,13 @@ internal fun rememberLazyListStateController( return remember { LazyListStateController( - normalizedThumbSize = normalizedThumbSize, - normalizedOffsetPosition = normalizedOffsetPosition, + thumbSizeNormalized = thumbSizeNormalized, + thumbSizeNormalizedReal = thumbSizeNormalizedReal, + thumbOffsetNormalized = thumbOffsetNormalized, thumbIsInAction = thumbIsInAction, _isSelected = isSelected, dragOffset = dragOffset, selectionMode = selectionModeUpdated, - normalizedThumbSizeReal = normalizedThumbSizeReal, realFirstVisibleItem = realFirstVisibleItem, reverseLayout = reverseLayout, thumbMinLength = thumbMinLengthUpdated, @@ -137,12 +137,12 @@ internal fun rememberLazyListStateController( } internal class LazyListStateController( - override val normalizedThumbSize: State, - override val normalizedOffsetPosition: State, + override val thumbSizeNormalized: State, + override val thumbOffsetNormalized: State, override val thumbIsInAction: State, private val _isSelected: MutableState, private val dragOffset: MutableFloatState, - private val normalizedThumbSizeReal: State, + private val thumbSizeNormalizedReal: State, private val realFirstVisibleItem: State, private val selectionMode: State, private val reverseLayout: State, @@ -170,13 +170,13 @@ internal class LazyListStateController( else -> offsetPixels / maxLengthPixels } val currentOffset = when { - reverseLayout.value -> 1f - normalizedOffsetPosition.value - normalizedThumbSize.value - else -> normalizedOffsetPosition.value + reverseLayout.value -> 1f - thumbOffsetNormalized.value - thumbSizeNormalized.value + else -> thumbOffsetNormalized.value } when (selectionMode.value) { ScrollbarSelectionMode.Full -> { - if (newOffset in currentOffset..(currentOffset + normalizedThumbSize.value)) + if (newOffset in currentOffset..(currentOffset + thumbSizeNormalized.value)) setDragOffset(currentOffset) else setScrollOffset(newOffset) @@ -184,7 +184,7 @@ internal class LazyListStateController( } ScrollbarSelectionMode.Thumb -> { - if (newOffset in currentOffset..(currentOffset + normalizedThumbSize.value)) { + if (newOffset in currentOffset..(currentOffset + thumbSizeNormalized.value)) { setDragOffset(currentOffset) _isSelected.value = true } @@ -199,14 +199,14 @@ internal class LazyListStateController( } private fun setDragOffset(value: Float) { - val maxValue = (1f - normalizedThumbSize.value).coerceAtLeast(0f) + val maxValue = (1f - thumbSizeNormalized.value).coerceAtLeast(0f) dragOffset.floatValue = value.coerceIn(0f, maxValue) } private fun offsetCorrectionInverse(top: Float): Float { - if (normalizedThumbSizeReal.value >= thumbMinLength.value) + if (thumbSizeNormalizedReal.value >= thumbMinLength.value) return top - val topRealMax = 1f - normalizedThumbSizeReal.value + val topRealMax = 1f - thumbSizeNormalizedReal.value val topMax = 1f - thumbMinLength.value return top * topRealMax / topMax } diff --git a/lib/src/main/java/my/nanihadesuka/compose/controller/ScrollStateController.kt b/lib/src/main/java/my/nanihadesuka/compose/controller/ScrollStateController.kt index fb6aa1d..7f5e117 100644 --- a/lib/src/main/java/my/nanihadesuka/compose/controller/ScrollStateController.kt +++ b/lib/src/main/java/my/nanihadesuka/compose/controller/ScrollStateController.kt @@ -43,7 +43,7 @@ internal fun rememberScrollStateController( } } - val normalizedThumbSizeReal = remember { + val thumbSizeNormalizedReal = remember { derivedStateOf { if (fullLengthDp.value == 0.dp) 1f else { val normalizedDp = visibleLengthDpUpdated.value / fullLengthDp.value @@ -52,19 +52,19 @@ internal fun rememberScrollStateController( } } - val normalizedThumbSize = remember { + val thumbSizeNormalized = remember { derivedStateOf { - normalizedThumbSizeReal.value.coerceAtLeast(thumbMinLengthUpdated.value) + thumbSizeNormalizedReal.value.coerceAtLeast(thumbMinLengthUpdated.value) } } fun offsetCorrection(top: Float): Float { val topRealMax = 1f - val topMax = (1f - normalizedThumbSize.value).coerceIn(0f, 1f) + val topMax = (1f - thumbSizeNormalized.value).coerceIn(0f, 1f) return top * topMax / topRealMax } - val normalizedOffsetPosition = remember { + val thumbOffsetNormalized = remember { derivedStateOf { if (state.maxValue == 0) return@derivedStateOf 0f val normalized = state.value.toFloat() / state.maxValue.toFloat() @@ -80,8 +80,8 @@ internal fun rememberScrollStateController( return remember { ScrollStateController( - normalizedThumbSize = normalizedThumbSize, - normalizedOffsetPosition = normalizedOffsetPosition, + thumbSizeNormalized = thumbSizeNormalized, + thumbOffsetNormalized = thumbOffsetNormalized, thumbIsInAction = thumbIsInAction, _isSelected = isSelected, dragOffset = dragOffset, @@ -93,8 +93,8 @@ internal fun rememberScrollStateController( } internal class ScrollStateController( - override val normalizedThumbSize: State, - override val normalizedOffsetPosition: State, + override val thumbSizeNormalized: State, + override val thumbOffsetNormalized: State, override val thumbIsInAction: State, private val _isSelected: MutableState, private val dragOffset: MutableState, @@ -106,11 +106,11 @@ internal class ScrollStateController( override fun onDragStarted(offsetPixels: Float, maxLengthPixels: Float) { val newOffset = offsetPixels / maxLengthPixels - val currentOffset = normalizedOffsetPosition.value + val currentOffset = thumbOffsetNormalized.value when (selectionMode.value) { ScrollbarSelectionMode.Full -> { - if (newOffset in currentOffset..(currentOffset + normalizedThumbSize.value)) + if (newOffset in currentOffset..(currentOffset + thumbSizeNormalized.value)) setDragOffset(currentOffset) else setScrollOffset(newOffset) @@ -118,7 +118,7 @@ internal class ScrollStateController( } ScrollbarSelectionMode.Thumb -> { - if (newOffset in currentOffset..(currentOffset + normalizedThumbSize.value)) { + if (newOffset in currentOffset..(currentOffset + thumbSizeNormalized.value)) { setDragOffset(currentOffset) _isSelected.value = true } @@ -139,12 +139,12 @@ internal class ScrollStateController( } override fun indicatorValue(): Float { - return offsetCorrectionInverse(normalizedOffsetPosition.value) + return offsetCorrectionInverse(thumbOffsetNormalized.value) } private fun offsetCorrectionInverse(top: Float): Float { val topRealMax = 1f - val topMax = 1f - normalizedThumbSize.value + val topMax = 1f - thumbSizeNormalized.value if (topMax == 0f) return top return (top * topRealMax / topMax).coerceAtLeast(0f) } @@ -158,7 +158,7 @@ internal class ScrollStateController( } private fun setDragOffset(value: Float) { - val maxValue = (1f - normalizedThumbSize.value).coerceAtLeast(0f) + val maxValue = (1f - thumbSizeNormalized.value).coerceAtLeast(0f) dragOffset.value = value.coerceIn(0f, maxValue) } } diff --git a/lib/src/main/java/my/nanihadesuka/compose/controller/StateController.kt b/lib/src/main/java/my/nanihadesuka/compose/controller/StateController.kt index 5b143bf..9cd8cef 100644 --- a/lib/src/main/java/my/nanihadesuka/compose/controller/StateController.kt +++ b/lib/src/main/java/my/nanihadesuka/compose/controller/StateController.kt @@ -5,8 +5,8 @@ import androidx.compose.runtime.State @Stable interface StateController { - val normalizedThumbSize: State - val normalizedOffsetPosition: State + val thumbSizeNormalized: State + val thumbOffsetNormalized: State val thumbIsInAction: State val isSelected: State diff --git a/lib/src/main/java/my/nanihadesuka/compose/generic/ElementScrollbar.kt b/lib/src/main/java/my/nanihadesuka/compose/generic/ElementScrollbar.kt index 4b169b6..d20833d 100644 --- a/lib/src/main/java/my/nanihadesuka/compose/generic/ElementScrollbar.kt +++ b/lib/src/main/java/my/nanihadesuka/compose/generic/ElementScrollbar.kt @@ -39,8 +39,8 @@ internal fun ElementScrollbar( ScrollbarLayout( orientation = orientation, - thumbSizeNormalized = stateController.normalizedThumbSize.value, - thumbOffsetNormalized = stateController.normalizedOffsetPosition.value, + thumbSizeNormalized = stateController.thumbSizeNormalized.value, + thumbOffsetNormalized = stateController.thumbOffsetNormalized.value, thumbIsInAction = stateController.thumbIsInAction.value, settings = ScrollbarLayoutSettings( durationAnimationMillis = 500,