Ausrichtungslinien in Jetpack Compose

Mit dem Compose-Layoutmodell können Sie mit AlignmentLine benutzerdefinierte Ausrichtungslinien erstellen, die von übergeordneten Layouts verwendet werden können, um ihre untergeordneten Elemente auszurichten und zu positionieren. Beispielsweise kann Row die benutzerdefinierten Ausrichtungslinien seiner untergeordneten Elemente verwenden, um sie auszurichten.

Wenn ein Layout einen Wert für ein bestimmtes AlignmentLine bereitstellt, können die übergeordneten Elemente des Layouts diesen Wert nach der Messung mit dem Operator Placeable.get für die entsprechende Placeable-Instanz lesen. Anhand der Position des AlignmentLine können die Eltern dann die Positionierung der untergeordneten Elemente festlegen.

Einige Composeables in Compose haben bereits Ausrichtungslinien. Beispielsweise stellt die komponierbare Funktion BasicText die Ausrichtungslinien FirstBaseline und LastBaseline bereit.

Im folgenden Beispiel liest ein benutzerdefiniertes LayoutModifier namens firstBaselineToTop den FirstBaseline, um dem Text ab der ersten Referenzlinie einen Abstand hinzuzufügen.

Zeigt den Unterschied zwischen dem Hinzufügen eines normalen Abstands zu einem Element und dem Anwenden eines Abstands auf die Grundlinie eines Textelements.
Abbildung 1: Zeigt den Unterschied zwischen dem Hinzufügen eines normalen Abstands zu einem Element und dem Anwenden eines Abstands auf die Grundlinie eines Textelements.

fun Modifier.firstBaselineToTop(
    firstBaselineToTop: Dp,
) = layout { measurable, constraints ->
    // Measure the composable
    val placeable = measurable.measure(constraints)

    // Check the composable has a first baseline
    check(placeable[FirstBaseline] != AlignmentLine.Unspecified)
    val firstBaseline = placeable[FirstBaseline]

    // Height of the composable with padding - first baseline
    val placeableY = firstBaselineToTop.roundToPx() - firstBaseline
    val height = placeable.height + placeableY
    layout(placeable.width, height) {
        // Where the composable gets placed
        placeable.placeRelative(0, placeableY)
    }
}

@Preview
@Composable
private fun TextWithPaddingToBaseline() {
    MaterialTheme {
        Text("Hi there!", Modifier.firstBaselineToTop(32.dp))
    }
}

Um die FirstBaseline im Beispiel zu lesen, wird in der Messphase placeable [FirstBaseline] verwendet.

Im folgenden Beispiel wird paddingFrom verwendet, um die erste Grundlinie des Text 32 dp vom oberen Rand zu platzieren, wie im Beispiel firstBaselineToTop. Wenn Sie den Abstand von der ersten und letzten Grundlinie des Texts aus festlegen möchten, verwenden Sie paddingFromBaseline.

@Composable
private fun TextWithPaddingFromBaseline() {
    MaterialTheme {
        Text("Hi there!", Modifier.paddingFrom(FirstBaseline, before = 32.dp))
    }
}

„Hi there!“ mit 32 dp Abstand über der ersten Grundlinie.
Abbildung 2: Text mit 32 dp Abstand vor der ersten Grundlinie.

Untergeordnete Elemente einer Zeile ausrichten

In einer Row richten die Modifikatoren alignByBaseline und alignBy untergeordnete Elemente an einer Ausrichtungslinie aus. Beide Modifikatoren sind Mitglieder von RowScope. Sie können sie also nur innerhalb eines RowScope verwenden, z. B. im Inhalt eines Row. Wenden Sie den Modifikator auf jedes untergeordnete Element an, das ausgerichtet werden soll. Ein Kind ohne dieses Attribut und ohne align folgt der verticalAlignment der Row.

Im folgenden Beispiel werden zwei Texte unterschiedlicher Größe an ihren ersten Grundlinien ausgerichtet:

@Composable
private fun TitleWithSubtitle() {
    MaterialTheme {
        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
            Text(
                "Title",
                modifier = Modifier.alignByBaseline(),
                style = MaterialTheme.typography.headlineMedium
            )
            Text(
                "Subtitle",
                modifier = Modifier.alignByBaseline(),
                style = MaterialTheme.typography.bodySmall
            )
        }
    }
}

Titeltext und kleinerer Untertiteltext, die an ihren Grundlinien ausgerichtet sind.
Abbildung 3: Zwei Text-Elemente unterschiedlicher Größe, die an ihren ersten Grundlinien ausgerichtet sind.

alignByBaseline ist mit alignBy(FirstBaseline) identisch. Wenn Sie eine Position ausrichten möchten, die keine Ausrichtungslinie ist, übergeben Sie einen Block an alignBy. Der Block empfängt das gemessene untergeordnete Element und gibt den Abstand in Pixeln vom oberen Rand des untergeordneten Elements zur Linie zurück, an der es ausgerichtet werden soll. Im folgenden Beispiel befindet sich die Mitte eines kleinen Felds auf der Grundlinie des daneben stehenden Texts:

@Composable
private fun BoxMiddleOnBaseline() {
    MaterialTheme {
        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
            Box(
                modifier = Modifier
                    .size(8.dp)
                    .background(Color.Gray)
                    // Aligns the middle of the box with the text baseline.
                    .alignBy { it.measuredHeight / 2 }
            )
            Text(
                "Label",
                modifier = Modifier.alignByBaseline()
            )
        }
    }
}

Kleines graues Quadrat, das vertikal auf der Grundlinie des Labeltextes zentriert ist.
Abbildung 4: Ein graues Box, dessen vertikale Mitte an der Baseline des angrenzenden Text ausgerichtet ist.

Die untergeordneten Elemente, die diese Modifikatoren verwenden, bilden eine Gruppe. Der Row platziert mindestens ein untergeordnetes Element der Gruppe so, als hätte es Alignment.Top, und positioniert die anderen so, dass ihre Linien übereinstimmen. Ein untergeordnetes Element, das sich allein in der Gruppe befindet, wird so platziert, als hätte es Alignment.Top, sodass es an nichts ausgerichtet wird. alignBy ist eine Form von align. Die beiden Modifikatoren können also nicht zusammen für dasselbe untergeordnete Element verwendet werden.

paddingFrom und alignBy lösen unterschiedliche Probleme: paddingFrom fügt einem Element basierend auf seiner eigenen Ausrichtungslinie Padding hinzu und alignBy richtet gleichgeordnete Elemente zueinander aus.

In einem Column nimmt alignBy einen VerticalAlignmentLine oder einen Block auf und richtet die untergeordneten Elemente horizontal aus. ColumnScope hat keine alignByBaseline.

Benutzerdefinierte Ausrichtungslinien erstellen

Wenn Sie ein benutzerdefiniertes Layout- oder LayoutModifier-Composable erstellen, können Sie benutzerdefinierte Ausrichtungslinien angeben, damit andere übergeordnete Composables sie verwenden können, um ihre untergeordneten Elemente entsprechend auszurichten und zu positionieren.

Im folgenden Beispiel wird ein benutzerdefiniertes BarChart-Composable mit zwei Ausrichtungslinien (MaxChartValue und MinChartValue) gezeigt, damit andere Composables am maximalen und minimalen Datenwert des Diagramms ausgerichtet werden können. Zwei Textelemente, Max und Min, wurden an der Mitte der benutzerdefinierten Ausrichtungslinien ausgerichtet.

BarChart-Komposition mit Text, der am maximalen und minimalen Datenwert ausgerichtet ist.
Abbildung 5. BarChart-Composable mit Text, der am maximalen und minimalen Datenwert ausgerichtet ist.

Benutzerdefinierte Ausrichtungslinien werden als Variablen auf oberster Ebene in Ihrem Projekt definiert.

/**
 * AlignmentLine defined by the maximum data value in a [BarChart]
 */
private val MaxChartValue = HorizontalAlignmentLine(merger = { old, new ->
    min(old, new)
})

/**
 * AlignmentLine defined by the minimum data value in a [BarChart]
 */
private val MinChartValue = HorizontalAlignmentLine(merger = { old, new ->
    max(old, new)
})

Die benutzerdefinierten Ausrichtungslinien zum Erstellen unseres Beispiels sind vom Typ HorizontalAlignmentLine, da sie zum vertikalen Ausrichten von untergeordneten Elementen verwendet werden. Eine Zusammenführungsrichtlinie wird als Parameter übergeben, falls mehrere Layouts einen Wert für diese Ausrichtungslinien bereitstellen. Da die Koordinaten des Compose-Layoutsystems und die Canvas-Koordinaten [0, 0] darstellen, sind die obere linke Ecke und die x- und y-Achse nach unten positiv, sodass der MaxChartValue-Wert immer kleiner als MinChartValue ist. Daher ist die Zusammenführungsrichtlinie für die Referenzlinie des maximalen Diagrammdatenwerts min und für die Referenzlinie des minimalen Diagrammdatenwerts max.

Wenn Sie eine benutzerdefinierte Layout oder LayoutModifier erstellen, geben Sie benutzerdefinierte Ausrichtungslinien in der Methode MeasureScope.layout an, die einen alignmentLines: Map<AlignmentLine, Int>-Parameter akzeptiert.

@Composable
private fun BarChart(
    dataPoints: List<Int>,
    modifier: Modifier = Modifier,
) {
    val maxValue: Float = remember(dataPoints) { dataPoints.maxOrNull()!! * 1.2f }

    BoxWithConstraints(modifier = modifier) {
        val density = LocalDensity.current
        with(density) {
            // ...
            // Calculate baselines
            val maxYBaseline = // ...
            val minYBaseline = // ...
            Layout(
                content = {},
                modifier = Modifier.drawBehind {
                    // ...
                }
            ) { _, constraints ->
                with(constraints) {
                    layout(
                        width = if (hasBoundedWidth) maxWidth else minWidth,
                        height = if (hasBoundedHeight) maxHeight else minHeight,
                        // Custom AlignmentLines are set here. These are propagated
                        // to direct and indirect parent composables.
                        alignmentLines = mapOf(
                            MinChartValue to minYBaseline.roundToInt(),
                            MaxChartValue to maxYBaseline.roundToInt()
                        )
                    ) {}
                }
            }
        }
    }
}

Direkte und indirekte übergeordnete Elemente dieser komponierbaren Funktion können die Ausrichtungslinien nutzen. Die folgende zusammensetzbare Funktion erstellt ein benutzerdefiniertes Layout, das zwei Text-Slots und Datenpunkte als Parameter verwendet und die beiden Texte an den maximalen und minimalen Diagrammdatenwerten ausrichtet. Die Vorschau dieser zusammensetzbaren Funktion ist in Abbildung 5 zu sehen.

@Composable
private fun BarChartMinMax(
    dataPoints: List<Int>,
    maxText: @Composable () -> Unit,
    minText: @Composable () -> Unit,
    modifier: Modifier = Modifier,
) {
    Layout(
        content = {
            maxText()
            minText()
            // Set a fixed size to make the example easier to follow
            BarChart(dataPoints, Modifier.size(200.dp))
        },
        modifier = modifier
    ) { measurables, constraints ->
        check(measurables.size == 3)
        val placeables = measurables.map {
            it.measure(constraints.copy(minWidth = 0, minHeight = 0))
        }

        val maxTextPlaceable = placeables[0]
        val minTextPlaceable = placeables[1]
        val barChartPlaceable = placeables[2]

        // Obtain the alignment lines from BarChart to position the Text
        val minValueBaseline = barChartPlaceable[MinChartValue]
        val maxValueBaseline = barChartPlaceable[MaxChartValue]
        layout(constraints.maxWidth, constraints.maxHeight) {
            maxTextPlaceable.placeRelative(
                x = 0,
                y = maxValueBaseline - (maxTextPlaceable.height / 2)
            )
            minTextPlaceable.placeRelative(
                x = 0,
                y = minValueBaseline - (minTextPlaceable.height / 2)
            )
            barChartPlaceable.placeRelative(
                x = max(maxTextPlaceable.width, minTextPlaceable.width) + 20,
                y = 0
            )
        }
    }
}
@Preview
@Composable
private fun ChartDataPreview() {
    MaterialTheme {
        BarChartMinMax(
            dataPoints = listOf(4, 24, 15),
            maxText = { Text("Max") },
            minText = { Text("Min") },
            modifier = Modifier.padding(24.dp)
        )
    }
}