Google Git
Sign in
android / platform / frameworks / support / 32de9dd24cb6eff254b2147d4c8d83e5c2430959 / . / compose / foundation / foundation / src / desktopMain / kotlin / androidx / compose / foundation / Scrollbar.desktop.kt
blob: 77c547625d99a04151d6900dd3177e1dc8a73176 [file] [log] [blame]
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]1/*
2 * Copyright 2020 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package androidx.compose.foundation
18
Doris Liu1ad57c42021-01-17 23:17:48 -0800[diff] [blame]19import androidx.compose.animation.animateColorAsState
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]20import androidx.compose.animation.core.TweenSpec
Matvei Malkov49bd56a2021-03-24 19:19:28 +0000[diff] [blame]21import androidx.compose.foundation.gestures.awaitFirstDown
Igor Demine9ef17e2021-04-22 16:46:17 +0300[diff] [blame]22import androidx.compose.foundation.gestures.detectTapAndPress
Matvei Malkov49bd56a2021-03-24 19:19:28 +0000[diff] [blame]23import androidx.compose.foundation.gestures.drag
George Mount32de9dd2022-10-05 14:51:06 -0700[diff] [blame^]24import androidx.compose.foundation.gestures.awaitEachGesture
Igor Demin7c097c42021-05-21 18:09:59 +0300[diff] [blame]25import androidx.compose.foundation.gestures.scrollBy
Igor Demine9ef17e2021-04-22 16:46:17 +0300[diff] [blame]26import androidx.compose.foundation.interaction.DragInteraction
27import androidx.compose.foundation.interaction.MutableInteractionSource
Igor Demine897e072021-08-25 20:53:19 +0300[diff] [blame]28import androidx.compose.foundation.interaction.collectIsHoveredAsState
Igor Demine9ef17e2021-04-22 16:46:17 +0300[diff] [blame]29import androidx.compose.foundation.layout.Box
30import androidx.compose.foundation.lazy.LazyListState
Igor Demin4c169c32021-07-21 09:01:19 +0300[diff] [blame]31import androidx.compose.foundation.shape.RoundedCornerShape
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]32import androidx.compose.runtime.Composable
Igor Demine9ef17e2021-04-22 16:46:17 +0300[diff] [blame]33import androidx.compose.runtime.CompositionLocal
34import androidx.compose.runtime.DisposableEffect
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]35import androidx.compose.runtime.Immutable
36import androidx.compose.runtime.LaunchedEffect
Matvei Malkov49bd56a2021-03-24 19:19:28 +0000[diff] [blame]37import androidx.compose.runtime.MutableState
Igor Demin76a746c2021-05-05 20:08:39 +0300[diff] [blame]38import androidx.compose.runtime.derivedStateOf
Igor Demine9ef17e2021-04-22 16:46:17 +0300[diff] [blame]39import androidx.compose.runtime.getValue
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]40import androidx.compose.runtime.mutableStateOf
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]41import androidx.compose.runtime.remember
Igor Demin59cc44f2021-05-05 13:18:07 +0300[diff] [blame]42import androidx.compose.runtime.rememberUpdatedState
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]43import androidx.compose.runtime.setValue
Louis Pullen-Freilichd42e1072021-01-27 18:20:02 +0000[diff] [blame]44import androidx.compose.runtime.staticCompositionLocalOf
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]45import androidx.compose.ui.Modifier
46import androidx.compose.ui.composed
47import androidx.compose.ui.geometry.Offset
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]48import androidx.compose.ui.graphics.Color
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]49import androidx.compose.ui.graphics.Shape
Matvei Malkov49bd56a2021-03-24 19:19:28 +0000[diff] [blame]50import androidx.compose.ui.input.pointer.pointerInput
51import androidx.compose.ui.input.pointer.positionChange
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]52import androidx.compose.ui.layout.Layout
Mihai Popa49584752021-01-25 12:38:07 +0000[diff] [blame]53import androidx.compose.ui.layout.MeasurePolicy
Louis Pullen-Freilichd42e1072021-01-27 18:20:02 +0000[diff] [blame]54import androidx.compose.ui.platform.LocalDensity
Igor Demin2c71f212022-01-21 19:41:17 +0300[diff] [blame]55import androidx.compose.ui.platform.LocalLayoutDirection
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]56import androidx.compose.ui.unit.Constraints
57import androidx.compose.ui.unit.Dp
Igor Demin2c71f212022-01-21 19:41:17 +0300[diff] [blame]58import androidx.compose.ui.unit.LayoutDirection
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]59import androidx.compose.ui.unit.constrainHeight
60import androidx.compose.ui.unit.constrainWidth
61import androidx.compose.ui.unit.dp
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]62import kotlinx.coroutines.delay
63import kotlinx.coroutines.runBlocking
Igor Demin7c097c42021-05-21 18:09:59 +0300[diff] [blame]64import kotlin.math.abs
Andrey Kulikov78fca422021-02-08 21:39:23 +0000[diff] [blame]65import kotlin.math.roundToInt
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]66import kotlin.math.sign
67
68/**
Igor Demine9ef17e2021-04-22 16:46:17 +0300[diff] [blame]69 * [CompositionLocal] used to pass [ScrollbarStyle] down the tree.
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]70 * This value is typically set in some "Theme" composable function
71 * (DesktopTheme, MaterialTheme)
72 */
Igor Demine9ef17e2021-04-22 16:46:17 +0300[diff] [blame]73val LocalScrollbarStyle = staticCompositionLocalOf { defaultScrollbarStyle() }
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]74
75/**
76 * Defines visual style of scrollbars (thickness, shapes, colors, etc).
Igor Demine9ef17e2021-04-22 16:46:17 +0300[diff] [blame]77 * Can be passed as a parameter of scrollbar through [LocalScrollbarStyle]
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]78 */
79@Immutable
80data class ScrollbarStyle(
81 val minimalHeight: Dp,
82 val thickness: Dp,
83 val shape: Shape,
84 val hoverDurationMillis: Int,
85 val unhoverColor: Color,
86 val hoverColor: Color
87)
88
89/**
Igor Demin4c169c32021-07-21 09:01:19 +0300[diff] [blame]90 * Simple default [ScrollbarStyle] without applying MaterialTheme.
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]91 */
92fun defaultScrollbarStyle() = ScrollbarStyle(
93 minimalHeight = 16.dp,
94 thickness = 8.dp,
Igor Demin4c169c32021-07-21 09:01:19 +0300[diff] [blame]95 shape = RoundedCornerShape(4.dp),
96 hoverDurationMillis = 300,
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]97 unhoverColor = Color.Black.copy(alpha = 0.12f),
Igor Demin4c169c32021-07-21 09:01:19 +0300[diff] [blame]98 hoverColor = Color.Black.copy(alpha = 0.50f)
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]99)
100
101/**
102 * Vertical scrollbar that can be attached to some scrollable
Andrey Kulikov1e8ebd32020-12-08 22:12:16 +0000[diff] [blame]103 * component (ScrollableColumn, LazyColumn) and share common state with it.
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]104 *
105 * Can be placed independently.
106 *
107 * Example:
108 * val state = rememberScrollState(0f)
109 *
110 * Box(Modifier.fillMaxSize()) {
Igor Demindd2ac2e2021-05-05 21:25:57 +0300[diff] [blame]111 * Box(modifier = Modifier.verticalScroll(state)) {
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]112 * ...
113 * }
114 *
115 * VerticalScrollbar(
116 * Modifier.align(Alignment.CenterEnd).fillMaxHeight(),
117 * rememberScrollbarAdapter(state)
118 * )
119 * }
120 *
121 * @param adapter [ScrollbarAdapter] that will be used to communicate with scrollable component
122 * @param modifier the modifier to apply to this layout
Igor Demin64a76892021-05-21 16:21:13 +0300[diff] [blame]123 * @param reverseLayout reverse the direction of scrolling and layout, when `true`
124 * and [LazyListState.firstVisibleItemIndex] == 0 then scrollbar
125 * will be at the bottom of the container.
126 * It is usually used in pair with `LazyColumn(reverseLayout = true)`
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]127 * @param style [ScrollbarStyle] to define visual style of scrollbar
Louis Pullen-Freilich2ae44912021-02-06 21:48:44 +0000[diff] [blame]128 * @param interactionSource [MutableInteractionSource] that will be used to dispatch
129 * [DragInteraction.Start] when this Scrollbar is being dragged.
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]130 */
131@Composable
132fun VerticalScrollbar(
133 adapter: ScrollbarAdapter,
134 modifier: Modifier = Modifier,
Igor Demin64a76892021-05-21 16:21:13 +0300[diff] [blame]135 reverseLayout: Boolean = false,
Igor Demine9ef17e2021-04-22 16:46:17 +0300[diff] [blame]136 style: ScrollbarStyle = LocalScrollbarStyle.current,
Louis Pullen-Freilich2ae44912021-02-06 21:48:44 +0000[diff] [blame]137 interactionSource: MutableInteractionSource = remember { MutableInteractionSource() }
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]138) = Scrollbar(
139 adapter,
140 modifier,
Igor Demin64a76892021-05-21 16:21:13 +0300[diff] [blame]141 reverseLayout,
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]142 style,
Louis Pullen-Freilich2ae44912021-02-06 21:48:44 +0000[diff] [blame]143 interactionSource,
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]144 isVertical = true
145)
146
147/**
148 * Horizontal scrollbar that can be attached to some scrollable
Igor Demindd2ac2e2021-05-05 21:25:57 +0300[diff] [blame]149 * component (Modifier.verticalScroll(), LazyRow) and share common state with it.
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]150 *
151 * Can be placed independently.
152 *
153 * Example:
154 * val state = rememberScrollState(0f)
155 *
156 * Box(Modifier.fillMaxSize()) {
Igor Demindd2ac2e2021-05-05 21:25:57 +0300[diff] [blame]157 * Box(modifier = Modifier.verticalScroll(state)) {
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]158 * ...
159 * }
160 *
161 * HorizontalScrollbar(
162 * Modifier.align(Alignment.BottomCenter).fillMaxWidth(),
163 * rememberScrollbarAdapter(state)
164 * )
165 * }
166 *
167 * @param adapter [ScrollbarAdapter] that will be used to communicate with scrollable component
168 * @param modifier the modifier to apply to this layout
Igor Demin64a76892021-05-21 16:21:13 +0300[diff] [blame]169 * @param reverseLayout reverse the direction of scrolling and layout, when `true`
170 * and [LazyListState.firstVisibleItemIndex] == 0 then scrollbar
171 * will be at the end of the container.
172 * It is usually used in pair with `LazyRow(reverseLayout = true)`
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]173 * @param style [ScrollbarStyle] to define visual style of scrollbar
Louis Pullen-Freilich2ae44912021-02-06 21:48:44 +0000[diff] [blame]174 * @param interactionSource [MutableInteractionSource] that will be used to dispatch
175 * [DragInteraction.Start] when this Scrollbar is being dragged.
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]176 */
177@Composable
178fun HorizontalScrollbar(
179 adapter: ScrollbarAdapter,
180 modifier: Modifier = Modifier,
Igor Demin64a76892021-05-21 16:21:13 +0300[diff] [blame]181 reverseLayout: Boolean = false,
Igor Demine9ef17e2021-04-22 16:46:17 +0300[diff] [blame]182 style: ScrollbarStyle = LocalScrollbarStyle.current,
Louis Pullen-Freilich2ae44912021-02-06 21:48:44 +0000[diff] [blame]183 interactionSource: MutableInteractionSource = remember { MutableInteractionSource() }
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]184) = Scrollbar(
185 adapter,
186 modifier,
Igor Demin2c71f212022-01-21 19:41:17 +0300[diff] [blame]187 if (LocalLayoutDirection.current == LayoutDirection.Rtl) !reverseLayout else reverseLayout,
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]188 style,
Louis Pullen-Freilich2ae44912021-02-06 21:48:44 +0000[diff] [blame]189 interactionSource,
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]190 isVertical = false
191)
192
193// TODO(demin): do we need to stop dragging if cursor is beyond constraints?
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]194@Composable
195private fun Scrollbar(
196 adapter: ScrollbarAdapter,
197 modifier: Modifier = Modifier,
Igor Demin64a76892021-05-21 16:21:13 +0300[diff] [blame]198 reverseLayout: Boolean,
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]199 style: ScrollbarStyle,
Louis Pullen-Freilich2ae44912021-02-06 21:48:44 +0000[diff] [blame]200 interactionSource: MutableInteractionSource,
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]201 isVertical: Boolean
Louis Pullen-Freilichd42e1072021-01-27 18:20:02 +0000[diff] [blame]202) = with(LocalDensity.current) {
Louis Pullen-Freilich2ae44912021-02-06 21:48:44 +0000[diff] [blame]203 val dragInteraction = remember { mutableStateOf<DragInteraction.Start?>(null) }
204 DisposableEffect(interactionSource) {
Leland Richardson66b9205c2021-01-12 10:41:48 -0800[diff] [blame]205 onDispose {
Louis Pullen-Freilich2ae44912021-02-06 21:48:44 +0000[diff] [blame]206 dragInteraction.value?.let { interaction ->
207 interactionSource.tryEmit(DragInteraction.Cancel(interaction))
208 dragInteraction.value = null
209 }
Leland Richardson66b9205c2021-01-12 10:41:48 -0800[diff] [blame]210 }
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]211 }
212
213 var containerSize by remember { mutableStateOf(0) }
Igor Demine897e072021-08-25 20:53:19 +0300[diff] [blame]214 val isHovered by interactionSource.collectIsHoveredAsState()
Igor Demin76a746c2021-05-05 20:08:39 +0300[diff] [blame]215
216 val isHighlighted by remember {
217 derivedStateOf {
218 isHovered || dragInteraction.value is DragInteraction.Start
219 }
220 }
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]221
222 val minimalHeight = style.minimalHeight.toPx()
Igor Demin64a76892021-05-21 16:21:13 +0300[diff] [blame]223 val sliderAdapter = remember(adapter, containerSize, minimalHeight, reverseLayout) {
224 SliderAdapter(adapter, containerSize, minimalHeight, reverseLayout)
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]225 }
226
Mihai Popa53f5bac2021-01-20 18:48:00 +0000[diff] [blame]227 val scrollThickness = style.thickness.roundToPx()
Mihai Popa49584752021-01-25 12:38:07 +0000[diff] [blame]228 val measurePolicy = if (isVertical) {
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]229 remember(sliderAdapter, scrollThickness) {
Mihai Popa49584752021-01-25 12:38:07 +0000[diff] [blame]230 verticalMeasurePolicy(sliderAdapter, { containerSize = it }, scrollThickness)
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]231 }
232 } else {
233 remember(sliderAdapter, scrollThickness) {
Mihai Popa49584752021-01-25 12:38:07 +0000[diff] [blame]234 horizontalMeasurePolicy(sliderAdapter, { containerSize = it }, scrollThickness)
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]235 }
236 }
237
Doris Liu1ad57c42021-01-17 23:17:48 -0800[diff] [blame]238 val color by animateColorAsState(
Igor Demin76a746c2021-05-05 20:08:39 +0300[diff] [blame]239 if (isHighlighted) style.hoverColor else style.unhoverColor,
Doris Liu05c20be2020-12-15 22:36:45 -0800[diff] [blame]240 animationSpec = TweenSpec(durationMillis = style.hoverDurationMillis)
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]241 )
242
243 val isVisible = sliderAdapter.size < containerSize
244
245 Layout(
246 {
247 Box(
248 Modifier
249 .background(if (isVisible) color else Color.Transparent, style.shape)
Aleksandr Veselov793810b2022-01-26 00:12:16 +0300[diff] [blame]250 .scrollbarDrag(
251 interactionSource = interactionSource,
252 draggedInteraction = dragInteraction,
253 onDelta = { offset ->
254 sliderAdapter.rawPosition += if (isVertical) offset.y else offset.x
255 },
256 onFinished = { sliderAdapter.rawPosition = sliderAdapter.position }
257 )
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]258 )
259 },
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]260 modifier
Igor Demine897e072021-08-25 20:53:19 +0300[diff] [blame]261 .hoverable(interactionSource = interactionSource)
Mihai Popa49584752021-01-25 12:38:07 +0000[diff] [blame]262 .scrollOnPressOutsideSlider(isVertical, sliderAdapter, adapter, containerSize),
263 measurePolicy
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]264 )
265}
266
Matvei Malkov49bd56a2021-03-24 19:19:28 +0000[diff] [blame]267private fun Modifier.scrollbarDrag(
268 interactionSource: MutableInteractionSource,
269 draggedInteraction: MutableState<DragInteraction.Start?>,
Aleksandr Veselov793810b2022-01-26 00:12:16 +0300[diff] [blame]270 onDelta: (Offset) -> Unit,
271 onFinished: () -> Unit
Igor Demin59cc44f2021-05-05 13:18:07 +0300[diff] [blame]272): Modifier = composed {
273 val currentInteractionSource by rememberUpdatedState(interactionSource)
274 val currentDraggedInteraction by rememberUpdatedState(draggedInteraction)
275 val currentOnDelta by rememberUpdatedState(onDelta)
Aleksandr Veselov793810b2022-01-26 00:12:16 +0300[diff] [blame]276 val currentOnFinished by rememberUpdatedState(onFinished)
Igor Demin59cc44f2021-05-05 13:18:07 +0300[diff] [blame]277 pointerInput(Unit) {
George Mount32de9dd2022-10-05 14:51:06 -0700[diff] [blame^]278 awaitEachGesture {
279 val down = awaitFirstDown(requireUnconsumed = false)
280 val interaction = DragInteraction.Start()
281 currentInteractionSource.tryEmit(interaction)
282 currentDraggedInteraction.value = interaction
283 val isSuccess = drag(down.id) { change ->
284 currentOnDelta.invoke(change.positionChange())
285 change.consume()
Matvei Malkov49bd56a2021-03-24 19:19:28 +0000[diff] [blame]286 }
George Mount32de9dd2022-10-05 14:51:06 -0700[diff] [blame^]287 val finishInteraction = if (isSuccess) {
288 DragInteraction.Stop(interaction)
289 } else {
290 DragInteraction.Cancel(interaction)
291 }
292 currentInteractionSource.tryEmit(finishInteraction)
293 currentDraggedInteraction.value = null
294 currentOnFinished.invoke()
Matvei Malkov49bd56a2021-03-24 19:19:28 +0000[diff] [blame]295 }
296 }
297}
298
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]299private fun Modifier.scrollOnPressOutsideSlider(
300 isVertical: Boolean,
301 sliderAdapter: SliderAdapter,
302 scrollbarAdapter: ScrollbarAdapter,
303 containerSize: Int
304) = composed {
305 var targetOffset: Offset? by remember { mutableStateOf(null) }
306
307 if (targetOffset != null) {
308 val targetPosition = if (isVertical) targetOffset!!.y else targetOffset!!.x
309
310 LaunchedEffect(targetPosition) {
George Mount8c41a232021-01-11 21:13:04 +0000[diff] [blame]311 var delay = PressTimeoutMillis * 3
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]312 while (targetPosition !in sliderAdapter.bounds) {
313 val oldSign = sign(targetPosition - sliderAdapter.position)
314 scrollbarAdapter.scrollTo(
315 containerSize,
316 scrollbarAdapter.scrollOffset + oldSign * containerSize
317 )
318 val newSign = sign(targetPosition - sliderAdapter.position)
319
320 if (oldSign != newSign) {
321 break
322 }
323
George Mount8c41a232021-01-11 21:13:04 +0000[diff] [blame]324 delay(delay)
325 delay = PressTimeoutMillis
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]326 }
327 }
328 }
Matvei Malkov2f2b9d82021-03-18 15:20:32 +0000[diff] [blame]329 Modifier.pointerInput(Unit) {
330 detectTapAndPress(
331 onPress = { offset ->
332 targetOffset = offset
333 tryAwaitRelease()
334 targetOffset = null
335 },
336 onTap = {}
337 )
338 }
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]339}
340
341/**
342 * Create and [remember] [ScrollbarAdapter] for scrollable container and current instance of
343 * [scrollState]
344 */
345@Composable
346fun rememberScrollbarAdapter(
347 scrollState: ScrollState
348): ScrollbarAdapter = remember(scrollState) {
349 ScrollbarAdapter(scrollState)
350}
351
352/**
353 * Create and [remember] [ScrollbarAdapter] for lazy scrollable container and current instance of
Igor Demin7c097c42021-05-21 18:09:59 +0300[diff] [blame]354 * [scrollState]
355 */
356@Composable
357fun rememberScrollbarAdapter(
358 scrollState: LazyListState,
359): ScrollbarAdapter {
360 return remember(scrollState) {
361 ScrollbarAdapter(scrollState)
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]362 }
363}
364
365/**
Igor Demindd2ac2e2021-05-05 21:25:57 +0300[diff] [blame]366 * ScrollbarAdapter for Modifier.verticalScroll and Modifier.horizontalScroll
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]367 *
368 * [scrollState] is instance of [ScrollState] which is used by scrollable component
369 *
370 * Example:
371 * val state = rememberScrollState(0f)
372 *
373 * Box(Modifier.fillMaxSize()) {
Igor Demindd2ac2e2021-05-05 21:25:57 +0300[diff] [blame]374 * Box(modifier = Modifier.verticalScroll(state)) {
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]375 * ...
376 * }
377 *
378 * VerticalScrollbar(
379 * Modifier.align(Alignment.CenterEnd).fillMaxHeight(),
380 * rememberScrollbarAdapter(state)
381 * )
382 * }
383 */
384fun ScrollbarAdapter(
385 scrollState: ScrollState
386): ScrollbarAdapter = ScrollableScrollbarAdapter(scrollState)
387
388private class ScrollableScrollbarAdapter(
389 private val scrollState: ScrollState
390) : ScrollbarAdapter {
Andrey Kulikov78fca422021-02-08 21:39:23 +0000[diff] [blame]391 override val scrollOffset: Float get() = scrollState.value.toFloat()
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]392
393 override suspend fun scrollTo(containerSize: Int, scrollOffset: Float) {
Andrey Kulikov78fca422021-02-08 21:39:23 +0000[diff] [blame]394 scrollState.scrollTo(scrollOffset.roundToInt())
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]395 }
396
397 override fun maxScrollOffset(containerSize: Int) =
Andrey Kulikov78fca422021-02-08 21:39:23 +0000[diff] [blame]398 scrollState.maxValue.toFloat()
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]399}
400
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]401/**
Igor Demin7c097c42021-05-21 18:09:59 +0300[diff] [blame]402 * ScrollbarAdapter for lazy lists.
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]403 *
404 * [scrollState] is instance of [LazyListState] which is used by scrollable component
405 *
Igor Demin7c097c42021-05-21 18:09:59 +0300[diff] [blame]406 * Scrollbar size and position will be dynamically changed on the current visible content.
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]407 *
408 * Example:
409 * Box(Modifier.fillMaxSize()) {
410 * val state = rememberLazyListState()
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]411 *
412 * LazyColumn(state = state) {
413 * ...
414 * }
415 *
416 * VerticalScrollbar(
417 * Modifier.align(Alignment.CenterEnd),
Igor Demin7c097c42021-05-21 18:09:59 +0300[diff] [blame]418 * rememberScrollbarAdapter(state)
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]419 * )
420 * }
421 */
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]422fun ScrollbarAdapter(
Igor Demin7c097c42021-05-21 18:09:59 +0300[diff] [blame]423 scrollState: LazyListState
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]424): ScrollbarAdapter = LazyScrollbarAdapter(
Igor Demin7c097c42021-05-21 18:09:59 +0300[diff] [blame]425 scrollState
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]426)
427
428private class LazyScrollbarAdapter(
Igor Demin7c097c42021-05-21 18:09:59 +0300[diff] [blame]429 private val scrollState: LazyListState
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]430) : ScrollbarAdapter {
431 override val scrollOffset: Float
432 get() = scrollState.firstVisibleItemIndex * averageItemSize +
433 scrollState.firstVisibleItemScrollOffset
434
435 override suspend fun scrollTo(containerSize: Int, scrollOffset: Float) {
Igor Demin7c097c42021-05-21 18:09:59 +0300[diff] [blame]436 val distance = scrollOffset - this@LazyScrollbarAdapter.scrollOffset
437
438 // if we scroll less than containerSize we need to use scrollBy function to avoid
439 // undesirable scroll jumps (when an item size is different)
440 //
441 // if we scroll more than containerSize we should immediately jump to this position
442 // without recreating all items between the current and the new position
443 if (abs(distance) <= containerSize) {
444 scrollState.scrollBy(distance)
445 } else {
446 snapTo(containerSize, scrollOffset)
447 }
448 }
449
450 private suspend fun snapTo(containerSize: Int, scrollOffset: Float) {
Igor Deminbf4afe72021-05-21 18:01:55 +0300[diff] [blame]451 // In case of very big values, we can catch an overflow, so convert values to double and
452 // coerce them
453// val averageItemSize = 26.000002f
454// val scrollOffsetCoerced = 2.54490608E8.toFloat()
455// val index = (scrollOffsetCoerced / averageItemSize).toInt() // 9788100
456// val offset = (scrollOffsetCoerced - index * averageItemSize) // -16.0
457// println(offset)
458
459 val maximumValue = maxScrollOffset(containerSize).toDouble()
460 val scrollOffsetCoerced = scrollOffset.toDouble().coerceIn(0.0, maximumValue)
461 val averageItemSize = averageItemSize.toDouble()
Igor Demin67e4aa22020-11-19 11:12:43 +0300[diff] [blame]462
463 val index = (scrollOffsetCoerced / averageItemSize)
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]464 .toInt()
465 .coerceAtLeast(0)
466 .coerceAtMost(itemCount - 1)
467
Igor Deminbf4afe72021-05-21 18:01:55 +0300[diff] [blame]468 val offset = (scrollOffsetCoerced - index * averageItemSize)
469 .toInt()
470 .coerceAtLeast(0)
471
472 scrollState.scrollToItem(index = index, scrollOffset = offset)
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]473 }
474
475 override fun maxScrollOffset(containerSize: Int) =
Igor Demin95d08812021-08-02 12:38:05 +0300[diff] [blame]476 (averageItemSize * itemCount - containerSize).coerceAtLeast(0f)
Igor Demin7c097c42021-05-21 18:09:59 +0300[diff] [blame]477
478 private val itemCount get() = scrollState.layoutInfo.totalItemsCount
479
480 private val averageItemSize by derivedStateOf {
481 scrollState
482 .layoutInfo
483 .visibleItemsInfo
484 .asSequence()
485 .map { it.size }
486 .average()
487 .toFloat()
488 }
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]489}
490
491/**
492 * Defines how to scroll the scrollable component
493 */
494interface ScrollbarAdapter {
495 /**
496 * Scroll offset of the content inside the scrollable component.
497 * Offset "100" means that the content is scrolled by 100 pixels from the start.
498 */
499 val scrollOffset: Float
500
501 /**
502 * Instantly jump to [scrollOffset] in pixels
503 *
504 * @param containerSize size of the scrollable container
505 * (for example, it is height of ScrollableColumn if we use VerticalScrollbar)
506 * @param scrollOffset target value in pixels to jump to,
507 * value will be coerced to 0..maxScrollOffset
508 */
509 suspend fun scrollTo(containerSize: Int, scrollOffset: Float)
510
511 /**
512 * Maximum scroll offset of the content inside the scrollable component
513 *
514 * @param containerSize size of the scrollable component
515 * (for example, it is height of ScrollableColumn if we use VerticalScrollbar)
516 */
517 fun maxScrollOffset(containerSize: Int): Float
518}
519
520private class SliderAdapter(
521 val adapter: ScrollbarAdapter,
522 val containerSize: Int,
Igor Demin64a76892021-05-21 16:21:13 +0300[diff] [blame]523 val minHeight: Float,
524 val reverseLayout: Boolean
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]525) {
Igor Demin3bc059e2020-11-25 21:19:35 +0300[diff] [blame]526 private val contentSize get() = adapter.maxScrollOffset(containerSize) + containerSize
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]527 private val visiblePart get() = containerSize.toFloat() / contentSize
528
529 val size
530 get() = (containerSize * visiblePart)
531 .coerceAtLeast(minHeight)
532 .coerceAtMost(containerSize.toFloat())
533
Igor Demindd2ac2e2021-05-05 21:25:57 +0300[diff] [blame]534 private val scrollScale: Float
535 get() {
536 val extraScrollbarSpace = containerSize - size
537 val extraContentSpace = contentSize - containerSize
538 return if (extraContentSpace == 0f) 1f else extraScrollbarSpace / extraContentSpace
539 }
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]540
Aleksandr Veselov793810b2022-01-26 00:12:16 +0300[diff] [blame]541 /**
542 * A position with cumulative offset, may be out of the container when dragging
543 */
544 var rawPosition: Float = position
545 set(value) {
546 field = value
547 position = value
548 }
549
550 /**
551 * Actual scroll of content regarding slider layout
552 */
553 private var scrollPosition: Float
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]554 get() = scrollScale * adapter.scrollOffset
555 set(value) {
556 runBlocking {
557 adapter.scrollTo(containerSize, value / scrollScale)
558 }
559 }
560
Aleksandr Veselov793810b2022-01-26 00:12:16 +0300[diff] [blame]561 /**
562 * Actual position of a thumb within slider container
563 */
Igor Demin64a76892021-05-21 16:21:13 +0300[diff] [blame]564 var position: Float
Aleksandr Veselov793810b2022-01-26 00:12:16 +0300[diff] [blame]565 get() = if (reverseLayout) containerSize - size - scrollPosition else scrollPosition
Igor Demin64a76892021-05-21 16:21:13 +0300[diff] [blame]566 set(value) {
Aleksandr Veselov793810b2022-01-26 00:12:16 +0300[diff] [blame]567 scrollPosition = if (reverseLayout) {
Igor Demin64a76892021-05-21 16:21:13 +0300[diff] [blame]568 containerSize - size - value
569 } else {
570 value
571 }
572 }
573
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]574 val bounds get() = position..position + size
575}
576
Mihai Popa49584752021-01-25 12:38:07 +0000[diff] [blame]577private fun verticalMeasurePolicy(
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]578 sliderAdapter: SliderAdapter,
579 setContainerSize: (Int) -> Unit,
580 scrollThickness: Int
Mihai Popa49584752021-01-25 12:38:07 +0000[diff] [blame]581) = MeasurePolicy { measurables, constraints ->
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]582 setContainerSize(constraints.maxHeight)
583 val height = sliderAdapter.size.toInt()
584 val placeable = measurables.first().measure(
585 Constraints.fixed(
586 constraints.constrainWidth(scrollThickness),
587 height
588 )
589 )
590 layout(placeable.width, constraints.maxHeight) {
591 placeable.place(0, sliderAdapter.position.toInt())
592 }
593}
594
Mihai Popa49584752021-01-25 12:38:07 +0000[diff] [blame]595private fun horizontalMeasurePolicy(
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]596 sliderAdapter: SliderAdapter,
597 setContainerSize: (Int) -> Unit,
598 scrollThickness: Int
Mihai Popa49584752021-01-25 12:38:07 +0000[diff] [blame]599) = MeasurePolicy { measurables, constraints ->
Igor Demind7332f82020-10-23 21:45:51 +0300[diff] [blame]600 setContainerSize(constraints.maxWidth)
601 val width = sliderAdapter.size.toInt()
602 val placeable = measurables.first().measure(
603 Constraints.fixed(
604 width,
605 constraints.constrainHeight(scrollThickness)
606 )
607 )
608 layout(constraints.maxWidth, placeable.height) {
609 placeable.place(sliderAdapter.position.toInt(), 0)
610 }
Matvei Malkov79be98f2021-02-03 21:36:55 +0000[diff] [blame]611}
612
613/**
614 * The time that must elapse before a tap gesture sends onTapDown, if there's
615 * any doubt that the gesture is a tap.
616 */
Matvei Malkov2f2b9d82021-03-18 15:20:32 +0000[diff] [blame]617private const val PressTimeoutMillis: Long = 100L