peachsim 0.1.669 → 0.1.671

package/kotlin/AppSources/androidx/activity/compose/internal/BackHandlerCompat.kt

@@ -0,0 +1,38 @@
+package androidx.activity.compose.internal
+
+import androidx.activity.BackEventCompat
+import androidx.activity.OnBackPressedCallback
+import androidx.navigationevent.NavigationEvent
+import androidx.navigationevent.NavigationEventHandler
+import androidx.navigationevent.NavigationEventInfo
+
+// activity-compose 1.13.0's BackHandlerCompat: one back handler as both a
+// navigation event handler and a back callback, for whichever dispatcher the
+// composition provides
+internal abstract class BackHandlerCompat(val info: NavigationEventInfo) {
+    open fun onBackStarted(event: BackEventCompat) {}
+    open fun onBackProgressed(event: BackEventCompat) {}
+    abstract fun onBackCompleted()
+    open fun onBackCancelled() {}
+
+    open var isBackEnabled: Boolean
+        get() = onBackPressedCallback.isEnabled && navigationEventHandler.isBackEnabled
+        set(value) {
+            onBackPressedCallback.isEnabled = value
+            navigationEventHandler.isBackEnabled = value
+        }
+
+    val onBackPressedCallback = object : OnBackPressedCallback(enabled = false) {
+        override fun handleOnBackStarted(backEvent: BackEventCompat) = this@BackHandlerCompat.onBackStarted(backEvent)
+        override fun handleOnBackProgressed(backEvent: BackEventCompat) = this@BackHandlerCompat.onBackProgressed(backEvent)
+        override fun handleOnBackPressed() = this@BackHandlerCompat.onBackCompleted()
+        override fun handleOnBackCancelled() = this@BackHandlerCompat.onBackCancelled()
+    }
+
+    val navigationEventHandler = object : NavigationEventHandler<NavigationEventInfo>(info, isBackEnabled = false) {
+        override fun onBackStarted(event: NavigationEvent) = this@BackHandlerCompat.onBackStarted(BackEventCompat(event))
+        override fun onBackProgressed(event: NavigationEvent) = this@BackHandlerCompat.onBackProgressed(BackEventCompat(event))
+        override fun onBackCompleted() = this@BackHandlerCompat.onBackCompleted()
+        override fun onBackCancelled() = this@BackHandlerCompat.onBackCancelled()
+    }
+}

package/kotlin/AppSources/androidx/activity/compose/internal/BackHandlerDispatcherCompat.kt

@@ -0,0 +1,27 @@
+package androidx.activity.compose.internal
+
+import androidx.activity.OnBackPressedDispatcher
+import androidx.navigationevent.NavigationEventDispatcher
+
+// activity-compose 1.13.0's BackHandlerDispatcherCompat: the navigation event
+// dispatcher when there is one, else the back dispatcher
+internal class BackHandlerDispatcherCompat(
+    private val navigationEventDispatcher: NavigationEventDispatcher?,
+    private val onBackPressedDispatcher: OnBackPressedDispatcher?,
+) {
+    init {
+        requireNotNull(navigationEventDispatcher ?: onBackPressedDispatcher) {
+            "At least one dispatcher (NavigationEventDispatcher or OnBackPressedDispatcher) must be non-null."
+        }
+    }
+
+    fun addHandler(handler: BackHandlerCompat) {
+        if (navigationEventDispatcher != null) navigationEventDispatcher.addHandler(handler.navigationEventHandler)
+        else checkNotNull(onBackPressedDispatcher).addCallback(handler.onBackPressedCallback)
+    }
+
+    fun removeHandler(handler: BackHandlerCompat) {
+        if (navigationEventDispatcher != null) handler.navigationEventHandler.remove()
+        else handler.onBackPressedCallback.remove()
+    }
+}

package/kotlin/AppSources/dev/peach/app/PeachApp.kt

@@ -30,8 +30,6 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.text.font.FontFamily
 import androidx.lifecycle.Lifecycle
-import androidx.navigationevent.NavigationEventDispatcher
-import androidx.navigationevent.NavigationEventDispatcherOwner
 import PeachComposeMount
 import addMount
 import mounts
@@ -55,6 +53,9 @@ internal class PeachAppSpec(
     // the activity's configChanges includes uiMode: it takes a night mode
     // change in onConfigurationChanged rather than relaunching
     val handlesUiMode: Boolean,
+    // how the activity's window meets the keyboard, pan, resize or nothing:
+    // adjustPan and an unspecified adjust on a compose window pan
+    val softInputAdjust: String,
     // the app's view models, each built with the constructor the device's
     // default factory finds for it
     val viewModels: ViewModelProvider.Factory,
@@ -98,9 +99,7 @@ private class ActivityOwners(activity: ComponentActivity) : PlatformArchitecture
     override val lifecycleOwner = activity
     override val viewModelStoreOwner = activity
     override val savedStateRegistryOwner = activity
-    override val navigationEventDispatcherOwner = object : NavigationEventDispatcherOwner {
-        override val navigationEventDispatcher = NavigationEventDispatcher()
-    }
+    override val navigationEventDispatcherOwner = activity
 }
 
 // the device and the application one started app process keeps, and what
@@ -167,6 +166,7 @@ internal fun peachStartApp(
         return app.activity.window.describe().put("ok", true).put("id", app.mountId)
             .put("wrapWidth", params?.width == ViewGroup.LayoutParams.WRAP_CONTENT)
             .put("wrapHeight", params?.height == ViewGroup.LayoutParams.WRAP_CONTENT)
+            .put("softInputAdjust", spec.softInputAdjust)
             .toString()
     } catch (error: Throwable) {
         return JSONObject().put("ok", false).put("code", "E_KOTLIN_APP")

package/kotlin/ComposeSources/PeachComposeHost.kt

@@ -24,6 +24,7 @@ import androidx.compose.ui.platform.PlatformArchitectureComponentsOwner
 import androidx.compose.ui.platform.PlatformWindowInsets
 import androidx.compose.ui.platform.PlatformContext
 import androidx.compose.ui.platform.PlatformTextInputMethodRequest
+import androidx.compose.ui.platform.ViewConfiguration
 import androidx.compose.ui.platform.WindowInfo
 import androidx.compose.ui.platform.registerSkikoComposeImplementation
 import androidx.compose.ui.scene.CanvasLayersComposeScene
@@ -63,7 +64,10 @@ import androidx.compose.ui.unit.LayoutDirection
 import dev.onejs.one.OneNativeSourceViewDispatch
 import kotlin.io.encoding.Base64
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.awaitCancellation
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.job
 import org.jetbrains.skiko.SystemTheme
 import org.jetbrains.skia.BackendRenderTarget
 import org.jetbrains.skia.Bitmap
@@ -85,6 +89,20 @@ import org.json.JSONObject
 // owners and window insets come from the hosting window: an activity's
 // ComposeView passes the activity and the insets its window delivers; an
 // imported composable keeps the empty defaults.
+// the values android.view.ViewConfiguration gives a window: config.xml's dp
+// dimensions resolved as getDimensionPixelSize does, rounding half up
+internal class AndroidViewConfiguration(private val density: Float) : ViewConfiguration {
+    private fun pixels(dp: Float) = (dp * density + 0.5f).toInt().toFloat()
+    override val longPressTimeoutMillis: Long = 400
+    override val doubleTapTimeoutMillis: Long = 300
+    override val doubleTapMinTimeMillis: Long = 40
+    override val touchSlop: Float = pixels(8f)
+    override val handwritingSlop: Float = pixels(2f)
+    override val maximumFlingVelocity: Float = pixels(8000f)
+    override val minimumFlingVelocity: Float = pixels(50f)
+    override val handwritingGestureLineMargin: Float = pixels(16f)
+}
+
 internal class PeachComposePlatform(
     val density: Density,
     override val localeList: LocaleList,
@@ -101,6 +119,9 @@ internal class PeachComposePlatform(
         override val containerSize: IntSize get() = size
         override val containerDpSize: DpSize get() = with(density) { DpSize(size.width.toDp(), size.height.toDp()) }
     }
+    // android's ViewConfiguration: AOSP's dp defaults as the device's pixels,
+    // where the skiko default is a desktop's
+    override val viewConfiguration: ViewConfiguration = AndroidViewConfiguration(density.density)
     override val inputModeManager: InputModeManager = object : InputModeManager {
         override var inputMode: InputMode by mutableStateOf(InputMode.Touch)
         override fun requestInputMode(inputMode: InputMode): Boolean {
@@ -116,19 +137,22 @@ internal class PeachComposePlatform(
 
     // the input method session the focused text field holds, android's
     // InputConnection. each session gets a new token, so the host can tell a
-    // late close from the session that replaced it
-    var input: PeachInputSession? = null
-        private set
+    // late close from the session that replaced it. a field that detaches
+    // cancels its session at once, though the cancelled coroutine finishes
+    // later; from the cancel on the session is closed, as compose web only
+    // reads a request inside the session's own coroutines
+    private var session: PeachInputSession? = null
+    val input get() = session?.takeIf { it.job.isActive }
     var onInputChange: () -> Unit = {}
     private var nextInput = 1
 
     override suspend fun startInputMethod(request: PlatformTextInputMethodRequest): Nothing {
-        val session = PeachInputSession(nextInput++, request)
-        input = session
+        val opened = PeachInputSession(nextInput++, request, currentCoroutineContext().job)
+        session = opened
         onInputChange()
         try { awaitCancellation() }
         finally {
-            if (input === session) input = null
+            if (session === opened) session = null
             onInputChange()
         }
     }
@@ -147,7 +171,7 @@ internal class PeachComposePlatform(
     }
 }
 
-internal class PeachInputSession(val token: Int, val request: PlatformTextInputMethodRequest) {
+internal class PeachInputSession(val token: Int, val request: PlatformTextInputMethodRequest, val job: Job) {
     var keyboard = true
         private set
     // each show or hide compose asks for, so a repeat still reaches the keyboard

package/kotlin/fixtures/kotlin-app/app/build.gradle.kts

@@ -23,7 +23,7 @@ android {
 }
 
 dependencies {
-    implementation("androidx.activity:activity-compose:1.9.3")
+    implementation("androidx.activity:activity-compose:1.13.0")
     implementation("androidx.compose.ui:ui:1.13.0-alpha02")
     implementation("androidx.compose.foundation:foundation:1.13.0-alpha02")
     implementation("androidx.compose.material3:material3:1.5.0-alpha27")

package/kotlin/fixtures/kotlin-app-variants/Browse.kt

@@ -0,0 +1,73 @@
+package dev.contrast.kotlinapp
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.foundation.text.input.rememberTextFieldState
+import androidx.compose.material3.ExpandedFullScreenSearchBar
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.SearchBar
+import androidx.compose.material3.SearchBarDefaults
+import androidx.compose.material3.Text
+import androidx.compose.material3.carousel.HorizontalMultiBrowseCarousel
+import androidx.compose.material3.carousel.rememberCarouselState
+import androidx.compose.material3.rememberSearchBarState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.launch
+
+// a search bar that expands over the screen and a multi browse carousel a
+// swipe advances, reported in one line
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun Browse() {
+    val search = rememberSearchBarState()
+    val field = rememberTextFieldState()
+    val scope = rememberCoroutineScope()
+    var searched by remember { mutableStateOf("") }
+    val carousel = rememberCarouselState { 8 }
+    val colors = listOf(0xFF6750A4, 0xFF7D5260, 0xFF625B71, 0xFF386A20, 0xFF00639B, 0xFF8C4A00, 0xFF984061, 0xFF006A6A)
+    Column(
+        Modifier.fillMaxSize().background(Color(0xFFE8EEF8)).safeDrawingPadding().padding(16.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+    ) {
+        Text("Browse: ${carousel.currentItem} searched $searched ${search.currentValue}")
+        val input = @Composable {
+            SearchBarDefaults.InputField(
+                searchBarState = search,
+                textFieldState = field,
+                onSearch = { searched = it; scope.launch { search.animateToCollapsed() } },
+                placeholder = { Text("Find") },
+            )
+        }
+        SearchBar(state = search, inputField = input)
+        ExpandedFullScreenSearchBar(state = search, inputField = input) {
+            Text("Suggestion", Modifier.padding(16.dp))
+        }
+        HorizontalMultiBrowseCarousel(
+            state = carousel,
+            preferredItemWidth = 186.dp,
+            modifier = Modifier.fillMaxWidth().height(200.dp),
+            itemSpacing = 8.dp,
+        ) { index ->
+            Box(
+                Modifier.fillMaxSize().maskClip(SearchBarDefaults.inputFieldShape).background(Color(colors[index])),
+                contentAlignment = Alignment.Center,
+            ) { Text("Item $index", color = Color.White) }
+        }
+    }
+}

package/kotlin/fixtures/kotlin-app-variants/Focus.kt

@@ -0,0 +1,62 @@
+package dev.contrast.kotlinapp
+
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.ime
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.foundation.text.input.rememberTextFieldState
+import androidx.compose.material3.Button
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextField
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.focus.onFocusChanged
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.dp
+
+// two fields focused from code, one with showKeyboardOnFocus off, and whether
+// the keyboard came up for each
+@OptIn(ExperimentalFoundationApi::class)
+@Composable
+fun Focus() {
+    val alpha = remember { FocusRequester() }
+    val beta = remember { FocusRequester() }
+    var alphaFocused by remember { mutableStateOf(false) }
+    var betaFocused by remember { mutableStateOf(false) }
+    Column(
+        Modifier.fillMaxSize().background(Color(0xFFE8EEF8)).safeDrawingPadding().padding(16.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+    ) {
+        val ime = WindowInsets.ime.getBottom(LocalDensity.current) > 0
+        Text("Focus: alpha $alphaFocused beta $betaFocused ime $ime")
+        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+            Button(onClick = { alpha.requestFocus() }) { Text("Focus alpha") }
+            Button(onClick = { beta.requestFocus() }) { Text("Focus beta") }
+        }
+        TextField(
+            rememberTextFieldState(),
+            Modifier.focusRequester(alpha).onFocusChanged { alphaFocused = it.isFocused },
+            label = { Text("Alpha") },
+        )
+        TextField(
+            rememberTextFieldState(),
+            Modifier.focusRequester(beta).onFocusChanged { betaFocused = it.isFocused },
+            label = { Text("Beta") },
+            keyboardOptions = KeyboardOptions(showKeyboardOnFocus = false),
+        )
+    }
+}

package/kotlin/fixtures/kotlin-app-variants/Lists.kt

@@ -0,0 +1,57 @@
+package dev.contrast.kotlinapp
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.aspectRatio
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.lazy.LazyRow
+import androidx.compose.foundation.lazy.grid.GridCells
+import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
+import androidx.compose.foundation.lazy.grid.rememberLazyGridState
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+
+// a lazy row a horizontal drag scrolls and a lazy grid a vertical drag
+// scrolls, each reporting its first visible item and offset in dp
+@Composable
+fun Lists() {
+    val row = rememberLazyListState()
+    val grid = rememberLazyGridState()
+    val colors = listOf(Color(0xFF3F51B5), Color(0xFFE91E63), Color(0xFF009688), Color(0xFFFF9800))
+    Column(
+        Modifier.fillMaxSize().background(Color(0xFFE8EEF8)).safeDrawingPadding().padding(16.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+    ) {
+        Text("Row: ${row.firstVisibleItemIndex} ${row.firstVisibleItemScrollOffset} grid ${grid.firstVisibleItemIndex} ${grid.firstVisibleItemScrollOffset}")
+        LazyRow(Modifier.fillMaxWidth().height(96.dp), state = row, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+            items(30) { i ->
+                Box(Modifier.size(96.dp).background(colors[i % 4]), contentAlignment = Alignment.Center) { Text("R$i", color = Color.White) }
+            }
+        }
+        LazyVerticalGrid(
+            GridCells.Fixed(3),
+            Modifier.fillMaxWidth().weight(1f),
+            state = grid,
+            contentPadding = PaddingValues(4.dp),
+            horizontalArrangement = Arrangement.spacedBy(8.dp),
+            verticalArrangement = Arrangement.spacedBy(8.dp),
+        ) {
+            items(90) { i ->
+                Box(Modifier.aspectRatio(1f).background(colors[(i + 1) % 4]), contentAlignment = Alignment.Center) { Text("G$i", color = Color.White) }
+            }
+        }
+    }
+}

package/kotlin/fixtures/kotlin-app-variants/Nav.kt

@@ -0,0 +1,47 @@
+package dev.contrast.kotlinapp
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.material3.Button
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import androidx.navigation.compose.NavHost
+import androidx.navigation.compose.composable
+import androidx.navigation.compose.currentBackStackEntryAsState
+import androidx.navigation.compose.rememberNavController
+
+// a NavHost with a home destination holding saveable state and a detail
+// destination the system back pops
+@Composable
+fun Nav() {
+    val nav = rememberNavController()
+    val entry by nav.currentBackStackEntryAsState()
+    Column(
+        Modifier.fillMaxSize().background(Color(0xFFE8EEF8)).safeDrawingPadding().padding(16.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+    ) {
+        Text("Route: ${entry?.destination?.route}")
+        NavHost(nav, startDestination = "home") {
+            composable("home") {
+                var taps by rememberSaveable { mutableIntStateOf(0) }
+                Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
+                    Text("Home taps $taps")
+                    Button(onClick = { taps++ }) { Text("Tap") }
+                    Button(onClick = { nav.navigate("detail") }) { Text("Open detail") }
+                }
+            }
+            composable("detail") { Text("Detail screen") }
+        }
+    }
+}

package/kotlin/fixtures/kotlin-app-variants/Nested.kt

@@ -0,0 +1,64 @@
+package dev.contrast.kotlinapp
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.nestedscroll.NestedScrollConnection
+import androidx.compose.ui.input.nestedscroll.NestedScrollSource
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.dp
+import kotlin.math.roundToInt
+
+// a header a nested scroll connection collapses before a verticalScroll
+// column moves, and a horizontalScroll row inside that column
+@Composable
+fun Nested() {
+    val maxHeader = with(LocalDensity.current) { 160.dp.toPx() }
+    var header by remember { mutableFloatStateOf(maxHeader) }
+    val column = rememberScrollState()
+    val row = rememberScrollState()
+    val connection = remember {
+        object : NestedScrollConnection {
+            override fun onPreScroll(available: Offset, source: NestedScrollSource): Offset {
+                if (available.y >= 0) return Offset.Zero
+                val next = (header + available.y).coerceAtLeast(0f)
+                val used = next - header
+                header = next
+                return Offset(0f, used)
+            }
+        }
+    }
+    val colors = listOf(Color(0xFF3F51B5), Color(0xFFE91E63), Color(0xFF009688), Color(0xFFFF9800))
+    Column(Modifier.fillMaxSize().background(Color(0xFFE8EEF8)).safeDrawingPadding().nestedScroll(connection)) {
+        Text("Nested: header ${header.roundToInt()} column ${column.value} row ${row.value}", Modifier.padding(16.dp))
+        Box(Modifier.fillMaxWidth().height(with(LocalDensity.current) { header.toDp() }).background(Color(0xFF673AB7)))
+        Column(Modifier.fillMaxWidth().weight(1f).verticalScroll(column).padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            Row(Modifier.horizontalScroll(row), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                repeat(12) { i -> Box(Modifier.size(96.dp).background(colors[i % 4]), contentAlignment = Alignment.Center) { Text("H$i", color = Color.White) } }
+            }
+            repeat(20) { i -> Box(Modifier.fillMaxWidth().height(64.dp).background(colors[(i + 2) % 4]), contentAlignment = Alignment.Center) { Text("V$i", color = Color.White) } }
+        }
+    }
+}

package/kotlin/fixtures/kotlin-app-variants/Pan.kt

@@ -0,0 +1,38 @@
+package dev.contrast.kotlinapp
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.onFocusChanged
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+
+// a field at the bottom of a window that fits system windows, which the
+// keyboard would cover: android pans the window to keep it in view
+@Composable
+fun Pan() {
+    var text by remember { mutableStateOf("") }
+    var focused by remember { mutableStateOf(false) }
+    Column(Modifier.fillMaxSize().background(Color(0xFFE8EEF8)).padding(16.dp)) {
+        Text("Top line")
+        Spacer(Modifier.weight(1f))
+        Text("Pan: focused $focused")
+        OutlinedTextField(
+            value = text,
+            onValueChange = { text = it },
+            label = { Text("Reply") },
+            modifier = Modifier.fillMaxWidth().padding(top = 12.dp).onFocusChanged { focused = it.isFocused },
+        )
+    }
+}

package/kotlin/fixtures/kotlin-app-variants/Pickers.kt

@@ -0,0 +1,44 @@
+package dev.contrast.kotlinapp
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.material3.Button
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.PlainTooltip
+import androidx.compose.material3.Text
+import androidx.compose.material3.TimePicker
+import androidx.compose.material3.TooltipBox
+import androidx.compose.material3.TooltipDefaults
+import androidx.compose.material3.rememberTimePickerState
+import androidx.compose.material3.rememberTooltipState
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+
+// a persistent tooltip a long press shows and a 12 hour time picker whose dial
+// a tap sets, both reported in one line
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun Pickers() {
+    val time = rememberTimePickerState(initialHour = 9, initialMinute = 30, is24Hour = false)
+    val tip = rememberTooltipState(isPersistent = true)
+    Column(
+        Modifier.fillMaxSize().background(Color(0xFFE8EEF8)).safeDrawingPadding().padding(16.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+    ) {
+        Text("Time: ${time.hour}:${time.minute} tip ${tip.isVisible}")
+        TooltipBox(
+            positionProvider = TooltipDefaults.rememberPlainTooltipPositionProvider(),
+            tooltip = { PlainTooltip { Text("Saves the draft") } },
+            state = tip,
+        ) {
+            Button(onClick = {}) { Text("Save") }
+        }
+        TimePicker(time)
+    }
+}

package/kotlin/fixtures/kotlin-app-variants/Press.kt

@@ -0,0 +1,43 @@
+package dev.contrast.kotlinapp
+
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.background
+import androidx.compose.foundation.combinedClickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+
+// a target combinedClickable counts taps and long presses on, so a hold just
+// past the long press timeout tells which timeout the window uses
+@OptIn(ExperimentalFoundationApi::class)
+@Composable
+fun Press() {
+    var clicks by remember { mutableStateOf(0) }
+    var longs by remember { mutableStateOf(0) }
+    Column(
+        Modifier.fillMaxSize().background(Color(0xFFE8EEF8)).safeDrawingPadding().padding(16.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+    ) {
+        Text("Press: clicks $clicks long $longs")
+        Box(
+            Modifier.fillMaxWidth().height(200.dp).background(Color(0xFFCFD8DC))
+                .combinedClickable(onLongClick = { longs += 1 }) { clicks += 1 },
+            contentAlignment = Alignment.Center,
+        ) { Text("Target") }
+    }
+}