---
title: "LayoutModifier"
description: "A [Modifier.Element] that changes how its wrapped content is measured and laid out. It has the
same measurement and layout functionality as the [androidx.compose.ui.layout.Layout] component,
while wrapping exactly one layout due to it being a modifier. In contrast, the
[androidx.compose.ui.layout.Layout] component is used to define the layout behavior of multiple
children."
type: "interface"
---

<div class='type'>Interface</div>


<a id='references'></a>

<div class='sourceset sourceset-common'>Common</div>



```kotlin
@JvmDefaultWithCompatibility
interface LayoutModifier : Modifier.Element
```


A `Modifier.Element` that changes how its wrapped content is measured and laid out. It has the
same measurement and layout functionality as the `androidx.compose.ui.layout.Layout` component,
while wrapping exactly one layout due to it being a modifier. In contrast, the
`androidx.compose.ui.layout.Layout` component is used to define the layout behavior of multiple
children.


## Functions

```kotlin
fun MeasureScope.measure(measurable: Measurable, constraints: Constraints): MeasureResult
```


The function used to measure the modifier. The `measurable` corresponds to the wrapped
content, and it can be measured with the desired constraints according to the logic of the
`LayoutModifier`. The modifier needs to choose its own size, which can depend on the size
chosen by the wrapped content (the obtained `Placeable`), if the wrapped content was
measured. The size needs to be returned as part of a `MeasureResult`, alongside the placement
logic of the `Placeable`, which defines how the wrapped content should be positioned inside
the `LayoutModifier`. A convenient way to create the `MeasureResult` is to use the
`MeasureScope.layout` factory function.

A `LayoutModifier` uses the same measurement and layout concepts and principles as a
`Layout`, the only difference is that they apply to exactly one child. For a more detailed
explanation of measurement and layout, see `MeasurePolicy`.


```kotlin
fun IntrinsicMeasureScope.minIntrinsicWidth(measurable: IntrinsicMeasurable, height: Int): Int
```


The function used to calculate `IntrinsicMeasurable.minIntrinsicWidth`.


```kotlin
fun IntrinsicMeasureScope.minIntrinsicHeight(measurable: IntrinsicMeasurable, width: Int): Int
```


The lambda used to calculate `IntrinsicMeasurable.minIntrinsicHeight`.


```kotlin
fun IntrinsicMeasureScope.maxIntrinsicWidth(measurable: IntrinsicMeasurable, height: Int): Int
```


The function used to calculate `IntrinsicMeasurable.maxIntrinsicWidth`.


```kotlin
fun IntrinsicMeasureScope.maxIntrinsicHeight(measurable: IntrinsicMeasurable, width: Int): Int
```


The lambda used to calculate `IntrinsicMeasurable.maxIntrinsicHeight`.



## Code Examples

### LayoutModifierSample
```kotlin
@Composable
fun LayoutModifierSample() {
    val verticalPadding =
        object : LayoutModifier {
            override fun MeasureScope.measure(
                measurable: Measurable,
                constraints: Constraints,
            ): MeasureResult {
                // an example modifier that adds 50 pixels of vertical padding.
                val padding = 50
                val placeable = measurable.measure(constraints.offset(vertical = -padding))
                return layout(placeable.width, placeable.height + padding) {
                    placeable.placeRelative(0, padding)
                }
            }
        }
    Box(Modifier.background(Color.Gray).then(verticalPadding)) {
        Box(Modifier.fillMaxSize().background(Color.DarkGray))
    }
}
```