Placeable.PlacementScope

PlacementScope()

open fun Ruler.current(defaultValue: Float): Float

import androidx.compose.foundation.layout.Box
import androidx.compose.ui.Modifier
import androidx.compose.ui.layout.layout

Box(
    Modifier.layout { measurable, constraints ->
        if (!constraints.hasBoundedHeight || !constraints.hasBoundedWidth) {
            // Can't use the ruler. We don't know our size
            val placeable = measurable.measure(constraints)
            layout(placeable.width, placeable.height) { placeable.place(0, 0) }
        } else {
            // Use the entire space available
            layout(constraints.maxWidth, constraints.maxHeight) {
                // Child is measured to fit above the IME
                val imePosition = SafeBottomRuler.current(-1f)
                val maxHeight: Int
                if (imePosition <= 0 || imePosition >= constraints.maxHeight) {
                    // IME ruler is outside the bounds of this layout
                    maxHeight = constraints.maxHeight
                } else {
                    maxHeight = imePosition.roundToInt()
                }
                val minHeight = constraints.minHeight.coerceAtMost(maxHeight)
                val childConstraints =
                    constraints.copy(minHeight = minHeight, maxHeight = maxHeight)
                val placeable = measurable.measure(childConstraints)
                placeable.place(0, 0)
            }
        }
    },
    content = content,
)

fun Placeable.place(position: IntOffset, zIndex: Float = 0.0f): Unit

fun Placeable.place(x: Int, y: Int, zIndex: Float = 0.0f): Unit

fun Placeable.placeRelative(position: IntOffset, zIndex: Float = 0.0f): Unit

fun Placeable.placeRelative(x: Int, y: Int, zIndex: Float = 0.0f): Unit

fun Placeable.placeRelativeWithLayer(
    position: IntOffset,
    layer: GraphicsLayer,
    zIndex: Float = 0.0f
): Unit

fun Placeable.placeRelativeWithLayer(
    position: IntOffset,
    zIndex: Float = 0.0f,
    layerBlock: GraphicsLayerScope.() -> Unit = DefaultLayerBlock
): Unit

fun Placeable.placeRelativeWithLayer(
    x: Int,
    y: Int,
    layer: GraphicsLayer,
    zIndex: Float = 0.0f
): Unit

fun Placeable.placeRelativeWithLayer(
    x: Int,
    y: Int,
    zIndex: Float = 0.0f,
    layerBlock: GraphicsLayerScope.() -> Unit = DefaultLayerBlock
): Unit

fun Placeable.placeWithLayer(
    position: IntOffset,
    layer: GraphicsLayer,
    zIndex: Float = 0.0f
): Unit

fun Placeable.placeWithLayer(
    position: IntOffset,
    zIndex: Float = 0.0f,
    layerBlock: GraphicsLayerScope.() -> Unit = DefaultLayerBlock
): Unit

fun Placeable.placeWithLayer(
    x: Int,
    y: Int,
    layer: GraphicsLayer,
    zIndex: Float = 0.0f
): Unit

fun Placeable.placeWithLayer(
    x: Int,
    y: Int,
    zIndex: Float = 0.0f,
    layerBlock: GraphicsLayerScope.() -> Unit = DefaultLayerBlock
): Unit

fun withMotionFrameOfReferencePlacement(block: Placeable.PlacementScope.() -> Unit): Unit

open val coordinates: LayoutCoordinates?

import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.layout.Layout
import androidx.compose.ui.layout.Placeable
import androidx.compose.ui.platform.LocalView
import androidx.compose.ui.unit.Constraints
import androidx.compose.ui.unit.IntOffset
import androidx.compose.ui.unit.round

// Layout so that the first item consumes to half of the width of the screen, if possible.
// The remainder of the layouts are positioned horizontally in the remaining space.
@Composable
fun FirstItemHalf(modifier: Modifier = Modifier, content: @Composable () -> Unit) {
    val view = LocalView.current

    Layout(
        content = content,
        modifier = modifier,
        measurePolicy = { measurables, constraints ->
            var width = constraints.minWidth
            var height = constraints.minHeight
            // If this doesn't have a fixed size, just layout horizontally
            var placeables: List<Placeable>? = null
            if (measurables.isNotEmpty()) {
                if (constraints.hasBoundedWidth && constraints.hasBoundedHeight) {
                    width = constraints.maxWidth
                    height = constraints.maxHeight
                } else {
                    placeables = measurables.map { it.measure(constraints) }
                    width = placeables.sumOf { it.width }
                    height = placeables.maxOf { it.height }
                }
            }
            layout(width, height) {
                if (placeables != null) {
                    var x = 0
                    placeables.forEach {
                        it.placeRelative(x, 0)
                        x += it.width
                    }
                } else if (measurables.isNotEmpty() && coordinates != null) {
                    val coordinates = coordinates!!
                    val positionInWindow = IntArray(2)
                    view.getLocationOnScreen(positionInWindow)
                    val topLeft =
                        coordinates.localToRoot(Offset.Zero).round() +
                            IntOffset(positionInWindow[0], positionInWindow[1])
                    val displayWidth = view.resources.displayMetrics.widthPixels
                    val halfWay = displayWidth / 2

                    val c0 =
                        if (topLeft.x < halfWay) {
                            // The first measurable should fit to half way across
                            Constraints.fixed(halfWay - topLeft.x, height)
                        } else {
                            // The first is already past the half way, so just divide it evenly
                            val measureWidth = width / measurables.size
                            Constraints.fixed(measureWidth, height)
                        }
                    val p0 = measurables[0].measure(c0)
                    p0.place(0, 0)

                    // The rest just fit in the remainder of the space
                    var x = p0.width
                    for (i in 1..measurables.lastIndex) {
                        val measureWidth = (width - x) / (measurables.size - i)
                        val p = measurables[i].measure(Constraints.fixed(measureWidth, height))
                        p.place(x, 0)
                        x += p.width
                    }
                }
            }
        },
    )
}

open val density: Float

open val fontScale: Float

protected abstract val parentLayoutDirection: LayoutDirection

protected abstract val parentWidth: Int

fun Placeable.PlacementScope.getDisplayCutoutBounds(): List<RectRulers>