commonMain.androidx.compose.foundation.lazy.LazyItemScopeImpl.kt Maven / Gradle / Ivy

Go to download
/*
 * Copyright 2021 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package androidx.compose.foundation.lazy

import androidx.compose.animation.core.FiniteAnimationSpec
import androidx.compose.foundation.lazy.layout.LazyLayoutAnimateItemElement
import androidx.compose.runtime.State
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.ui.Modifier
import androidx.compose.ui.layout.Measurable
import androidx.compose.ui.layout.MeasureResult
import androidx.compose.ui.layout.MeasureScope
import androidx.compose.ui.node.LayoutModifierNode
import androidx.compose.ui.node.ModifierNodeElement
import androidx.compose.ui.platform.InspectorInfo
import androidx.compose.ui.unit.Constraints
import androidx.compose.ui.unit.IntOffset
import androidx.compose.ui.util.fastRoundToInt

internal class LazyItemScopeImpl : LazyItemScope {

    private var maxWidthState = mutableIntStateOf(Int.MAX_VALUE)
    private var maxHeightState = mutableIntStateOf(Int.MAX_VALUE)

    fun setMaxSize(width: Int, height: Int) {
        maxWidthState.intValue = width
        maxHeightState.intValue = height
    }

    override fun Modifier.fillParentMaxSize(fraction: Float) =
        then(
            ParentSizeElement(
                widthState = maxWidthState,
                heightState = maxHeightState,
                fraction = fraction,
                inspectorName = "fillParentMaxSize"
            )
        )

    override fun Modifier.fillParentMaxWidth(fraction: Float) =
        then(
            ParentSizeElement(
                widthState = maxWidthState,
                fraction = fraction,
                inspectorName = "fillParentMaxWidth"
            )
        )

    override fun Modifier.fillParentMaxHeight(fraction: Float) =
        then(
            ParentSizeElement(
                heightState = maxHeightState,
                fraction = fraction,
                inspectorName = "fillParentMaxHeight"
            )
        )

    override fun Modifier.animateItem(
        fadeInSpec: FiniteAnimationSpec?,
        placementSpec: FiniteAnimationSpec?,
        fadeOutSpec: FiniteAnimationSpec?
    ): Modifier =
        if (fadeInSpec == null && placementSpec == null && fadeOutSpec == null) {
            this
        } else {
            this then LazyLayoutAnimateItemElement(fadeInSpec, placementSpec, fadeOutSpec)
        }
}

private class ParentSizeElement(
    val fraction: Float,
    val widthState: State? = null,
    val heightState: State? = null,
    val inspectorName: String
) : ModifierNodeElement() {
    override fun create(): ParentSizeNode {
        return ParentSizeNode(
            fraction = fraction,
            widthState = widthState,
            heightState = heightState
        )
    }

    override fun update(node: ParentSizeNode) {
        node.fraction = fraction
        node.widthState = widthState
        node.heightState = heightState
    }

    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (other !is ParentSizeElement) return false
        return fraction == other.fraction &&
            widthState == other.widthState &&
            heightState == other.heightState
    }

    override fun hashCode(): Int {
        var result = widthState?.hashCode() ?: 0
        result = 31 * result + (heightState?.hashCode() ?: 0)
        result = 31 * result + fraction.hashCode()
        return result
    }

    override fun InspectorInfo.inspectableProperties() {
        name = inspectorName
        value = fraction
    }
}

private class ParentSizeNode(
    var fraction: Float,
    var widthState: State? = null,
    var heightState: State? = null,
) : LayoutModifierNode, Modifier.Node() {

    override fun MeasureScope.measure(
        measurable: Measurable,
        constraints: Constraints
    ): MeasureResult {
        val width =
            widthState?.let {
                if (it.value != Constraints.Infinity) {
                    (it.value * fraction).fastRoundToInt()
                } else {
                    Constraints.Infinity
                }
            } ?: Constraints.Infinity

        val height =
            heightState?.let {
                if (it.value != Constraints.Infinity) {
                    (it.value * fraction).fastRoundToInt()
                } else {
                    Constraints.Infinity
                }
            } ?: Constraints.Infinity
        val childConstraints =
            Constraints(
                minWidth = if (width != Constraints.Infinity) width else constraints.minWidth,
                minHeight = if (height != Constraints.Infinity) height else constraints.minHeight,
                maxWidth = if (width != Constraints.Infinity) width else constraints.maxWidth,
                maxHeight = if (height != Constraints.Infinity) height else constraints.maxHeight,
            )
        val placeable = measurable.measure(childConstraints)
        return layout(placeable.width, placeable.height) { placeable.place(0, 0) }
    }
}