diff --git a/android/README.md b/android/README.md index ef360f7c..d2887d52 100644 --- a/android/README.md +++ b/android/README.md @@ -1159,3 +1159,89 @@ covered by the existing unit tests (`StageDetailSheetTest`, `FormatTest`) rather driven on the device; the narrow/wide gallery thumbnail failure for run 60's corrupt artifacts is a data issue in that run, not re-tested against a repaired copy. + +## Covered panes show a compact identity, with a minimum peek width (16 Oct 2026) + +A wide-window stack no longer squeezes a full pane into each covered peek: a +covered pane now renders only its compact identity (a title and at most one +status/subtitle, centred in its strip) and its full body — tab rail, list, +gallery, scroll body — is never drawn into a sliver. `android/` only; nothing in +the Pipelines server, its Go source, the Docker/compose files or the installer was +touched, no dependency was added, no run was started from the app, and the +attached Pixel 10 Pro Fold was never installed on or driven (the debug APK was +installed with `adb -s emulator-5554 install -r`). + +- **Compact covered panes.** `SlidingPaneStack`'s `pane` lambda now receives a + `covered: Boolean`; on a wide window a covered level is composed inside a box + constrained to its visible strip, and the caller renders only + `ui/components/PaneIdentity.kt` — a centred title plus at most one + status/subtitle line. The list (`PipelineListScreen`/`RunHistoryScreen`), both + detail screens and the stage pane each gained a `covered` branch that + early-returns after their data-loading effects, so nothing heavy is composed + into a sliver. The strip itself stays a separate, higher tappable sibling and + the compact identity rides with the pane's own slide. +- **A named minimum covered width, and a fold.** `MIN_COVERED_PANE_WIDTH_DP` + (`112.dp`) is the least width a covered pane's compact identity needs. + `peekStripsDp` shows at most `budget / MIN_COVERED_PANE_WIDTH_DP` covered peeks; + when a stack has more covered levels than that, the oldest levels fold into a + single edge indicator (`" more"`) rather than being squeezed below the + minimum, and the number of peeks shown shrinks instead of their width. The fixed + budget (`PEEK_BUDGET_DP`, `224.dp`) and the constant active-pane width are + unchanged. +- **Unchanged behaviour.** Tapping a covered pane's peek calls the same + `onPopTo(level)`, closing everything to its right; Back/gesture/back arrow and + the narrow (no-peek) layout are untouched. + +Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 8.11.1, +`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`): + +- `gradle :app:testDebugUnitTest` reported **134 tests, 0 failures, 0 errors**; + `gradle :app:assembleDebug` succeeded (17,992,288-byte debug APK, sha256 + `3923224136be7ef9bdd8eb87111fae1f6af0211a7ba070af0e5270e324a0fc93`). The + rewritten `SlidingPaneStackTest` has 10 cases (narrow spends no peek, the wide + active pane is constant width at every depth, two covered levels each keep the + minimum, a fourth level folds the oldest into one indicator carrying its count, + the newest level still peeks, the first strip clears the gesture inset, the + budget clamps, a tiny host never goes negative, strips are monotonic and + deterministic, and widths are host-less-offset). +- On `emulator-5554` (2076x2152, density 390 ≈ 852dp wide; **never** the attached + Pixel) against the live server `ws://10.0.2.2:8080/connect`, driven with + `adb shell input` and `uiautomator dump`: + - Wide, `uiautomator dump` of the peek strips: at two levels the single strip + was `[73,165]–[546,1859]` (`[30dp, 224dp]` after the ~30dp left gesture + inset); at three levels the two strips were `[73,165]–[273,1859]` and + `[273,165]–[546,1859]` (`[30dp,112dp]` and `[112dp,224dp]`), so the active + pane still starts at `224dp` (constant width) and each covered pane now keeps + at least `112dp` for its identity. + - Narrowest wide size (`wm size 1463x2152`, density 390 = 600dp): the same + `224dp` budget, strips `[73,127]–[273,1859]` and `[273,127]–[546,1859]`; both + compact identities stayed readable and the active pane was full. + - Tapping the detail peek (`409 1000`) at three levels popped to the detail + (only `Back to pipelines` left); tapping the list peek (`173 1000`) popped to + the list (no strips). `input keyevent 4` at depth 2 returned to depth 1 (one + `Back to pipelines` strip). + - Narrow (`wm size 1080x1920`, `wm density 480`, ≈360dp): opening a pipeline + showed **0** `Back to …` strips and the detail tabs as before. + - `adb -s emulator-5554 logcat -d` contained 0 `FATAL EXCEPTION`; no run was + started from the app. + - Screenshots were written to the run's artifacts directory: + `wide-2-levels.png` (the list covered as `Pipelines · 11 on this server`), + `wide-3-levels.png` (list and detail covered, stage active) and + `wide-narrowest.png` (600dp); `wide-2-levels-after-peek.png` is the state + after the peek tap. +- **APK publish.** `app/build/outputs/apk/debug/app-debug.apk` was copied to + `…/artifacts/65/1/pipelines-debug-wip-206953e.apk` (`206953e` = + `git rev-parse --short HEAD`); `shasum -a 256` matched. `curl -I + http://10.0.0.249:8080/artifacts/65/1/pipelines-debug-wip-206953e.apk` (LAN + address from `ipconfig getifaddr en0`) returned `HTTP/1.1 200 OK`, + `Content-Type: application/vnd.android.package-archive`, `Content-Length: + 17992288`; a streamed `GET | shasum -a 256` equalled the local file. At 17.2 MiB + it exceeds the server's 8 MiB per-file inventory cap, so it is served by direct + URL only. + +Not verified in this pass: the four-level / folded layout on a device — the app +has exactly three pane levels (`MasterPane.List/Detail/Stage`, `MAX_PANE_DEPTH = +2`), so the fold is unreachable and its rule is covered by the pure +`SlidingPaneStackTest` cases instead; a long covered detail title wraps to three +centred lines and ellipsizes (e.g. `Pipelines maintenance - plan implem…`) rather +than being rotated. diff --git a/android/app/src/main/java/net/awan/pipelines/ui/PipelinesApp.kt b/android/app/src/main/java/net/awan/pipelines/ui/PipelinesApp.kt index feb121b7..8717e753 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/PipelinesApp.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/PipelinesApp.kt @@ -211,7 +211,7 @@ private fun PipelineDestination(vm: AppViewModel, wide: Boolean, onOpenRun: (Lon wide = wide, onPopTo = { level -> selection = popTo(selection, level) }, backContentDescription = { level -> if (level == 0) "Back to pipelines" else "Back to pipeline" }, - pane = { level, paneModifier -> + pane = { level, covered, paneModifier -> when (level) { 0 -> PipelineListScreen( vm = vm, @@ -220,6 +220,7 @@ private fun PipelineDestination(vm: AppViewModel, wide: Boolean, onOpenRun: (Lon }, modifier = paneModifier, selectedId = selection.itemId.takeIf { depth >= 1 }, + covered = covered, ) 1 -> if (selection.itemId != 0L) { PipelineDetailScreen( @@ -235,6 +236,7 @@ private fun PipelineDestination(vm: AppViewModel, wide: Boolean, onOpenRun: (Lon onOpenStage = { key -> selection = selection.copy(pane = MasterPane.Stage, stageKey = key, stageVisit = 0) }, + covered = covered, ) } 2 -> selection.stageKey?.let { key -> @@ -246,6 +248,7 @@ private fun PipelineDestination(vm: AppViewModel, wide: Boolean, onOpenRun: (Lon onBack = onBack, wide = wide, modifier = paneModifier, + covered = covered, ) } } @@ -278,13 +281,14 @@ private fun RunsDestination( wide = wide, onPopTo = { level -> onSelectionChange(popTo(selection, level)) }, backContentDescription = { level -> if (level == 0) "Back to runs" else "Back to run" }, - pane = { level, paneModifier -> + pane = { level, covered, paneModifier -> when (level) { 0 -> RunHistoryScreen( vm = vm, onOpenRun = { runId -> onSelectionChange(PaneSelection(MasterPane.Detail, runId)) }, modifier = paneModifier, selectedRunId = selection.itemId.takeIf { depth >= 1 }, + covered = covered, ) 1 -> if (selection.itemId != 0L) { RunDetailScreen( @@ -300,6 +304,7 @@ private fun RunsDestination( selection.copy(pane = MasterPane.Stage, stageKey = key, stageVisit = visit), ) }, + covered = covered, ) } 2 -> selection.stageKey?.let { key -> @@ -311,6 +316,7 @@ private fun RunsDestination( onBack = onBack, wide = wide, modifier = paneModifier, + covered = covered, ) } } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/PaneIdentity.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/PaneIdentity.kt new file mode 100644 index 00000000..c56c0f83 --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/PaneIdentity.kt @@ -0,0 +1,54 @@ +package net.awan.pipelines.ui.components + +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.padding +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import net.awan.pipelines.ui.theme.pipelinesText + +/** + * A covered pane's compact identity: its title and, when there is one, a single + * status/subtitle line, both centred in the peek strip. A covered pane renders + * this instead of its full body, so its tab rail, list, gallery and scrollable + * body are never drawn squeezed into a sliver. + * + * The strip is narrow but the identity is the whole point of it, so the title + * wraps onto a few centered lines rather than becoming an unreadable ellipsis; + * it is the one place a title may legitimately run over more than one line. + */ +@Composable +fun PaneIdentity(title: String, subtitle: String? = null, modifier: Modifier = Modifier) { + val text = pipelinesText() + Box(modifier.fillMaxSize(), contentAlignment = Alignment.Center) { + Column( + modifier = Modifier.padding(horizontal = 8.dp, vertical = 12.dp), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(4.dp), + ) { + Text( + text = title, + style = text.cardTitle, + textAlign = TextAlign.Center, + maxLines = 3, + overflow = TextOverflow.Ellipsis, + ) + if (!subtitle.isNullOrBlank()) { + Text( + text = subtitle, + style = text.meta, + textAlign = TextAlign.Center, + maxLines = 2, + overflow = TextOverflow.Ellipsis, + ) + } + } + } +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/SlidingPaneStack.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/SlidingPaneStack.kt index 686318a5..ef4a1b1f 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/components/SlidingPaneStack.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/SlidingPaneStack.kt @@ -42,10 +42,15 @@ import net.awan.pipelines.ui.MAX_PANE_DEPTH * all covered panes together, however deep the stack gets. * [MIN_ACTIVE_PANE_WIDTH_DP] is the least width worth leaving to the active * (topmost) pane before the budget has to be reduced. + * [MIN_COVERED_PANE_WIDTH_DP] is the least width a covered pane's compact + * identity needs to stay readable and tappable; when the budget cannot give + * every covered pane this much, the oldest levels are folded into one edge + * indicator instead of being squeezed below it. */ internal val PEEK_WIDTH_DP = 56.dp internal val PEEK_BUDGET_DP = 224.dp internal val MIN_ACTIVE_PANE_WIDTH_DP = 320.dp +internal val MIN_COVERED_PANE_WIDTH_DP = 112.dp /** * The peek budget actually spent on a wide window: the fixed [PEEK_BUDGET_DP] @@ -57,37 +62,6 @@ internal val MIN_ACTIVE_PANE_WIDTH_DP = 320.dp internal fun peekBudgetDp(hostWidth: Dp, requested: Dp = PEEK_BUDGET_DP): Dp = requested.coerceAtMost((hostWidth - MIN_ACTIVE_PANE_WIDTH_DP).coerceAtLeast(0.dp)) -/** - * The open left offset of every pane `0..covered` on a wide window. `[0]` is the - * list at 0 and `[covered]` is the active pane at exactly [budget]; the covered - * panes therefore share that one fixed budget between them and the active pane - * keeps the constant width `hostWidth - budget` no matter how deep the stack is. - * The leftmost strip is widened first so that after [startInset] it still leaves - * [minPeek] tappable; the remaining budget is then split evenly between the other - * covered panes. A degenerate host clamps to whatever fits rather than - * overflowing. Pure, so the shared-budget geometry needs no device. - */ -internal fun paneOpenOffsetsDp( - covered: Int, - budget: Dp, - startInset: Dp, - minPeek: Dp, -): List { - if (covered <= 0) return listOf(0.dp) - if (budget <= 0.dp) return List(covered + 1) { 0.dp } - if (covered == 1) return listOf(0.dp, budget) - val offsets = ArrayList(covered + 1) - offsets += 0.dp - val first = minOf(budget, maxOf(budget / covered, startInset + minPeek)) - offsets += first - val rest = budget - first - val steps = covered - 1 - for (i in 2..covered) { - offsets += first + rest * (i - 1) / steps - } - return offsets -} - /** * The width of the pane whose open left edge is [offset] on a wide window: from * that offset to the host's right edge. The active pane therefore measures @@ -96,6 +70,71 @@ internal fun paneOpenOffsetsDp( internal fun paneWidthDp(hostWidth: Dp, offset: Dp): Dp = maxOf(0.dp, hostWidth - offset) +/** + * One covered strip of a wide-window stack, in left-to-right order. [level] is + * the pane whose compact identity it shows; a [folded] count greater than one + * marks a strip that stands in for that many older levels (one edge indicator + * with a count) instead of a single pane, so no covered pane is squeezed below + * the named minimum width. + */ +internal data class PeekStrip( + val level: Int, + val start: Dp, + val width: Dp, + val folded: Int = 1, +) + +/** + * The covered strips of a wide stack for [covered] covered levels and the fixed + * [budget]. Every shown pane keeps at least `minCovered`; the leftmost strip is + * widened first so that after [startInset] it still leaves [minPeek] tappable, + * and the rest of the budget is then split evenly between the other strips. + * + * When [covered] levels cannot each get `minCovered` out of [budget], one strip + * (the leftmost) is reserved as an edge indicator folding the oldest levels into + * a single count, and only the newest levels keep their own peek: the number of + * peeks shown shrinks rather than the width of each. The active pane's left edge + * is therefore still exactly the budget. Pure, so the shared-budget geometry and + * the fold rule need no device; an empty list means nothing is covered. + */ +internal fun peekStripsDp( + covered: Int, + budget: Dp, + startInset: Dp, + minPeek: Dp, + minCovered: Dp = MIN_COVERED_PANE_WIDTH_DP, +): List { + if (covered <= 0 || budget <= 0.dp) return emptyList() + // How many covered panes the budget can show at the minimum width. When some + // levels have to fold, one of those slots is spent on the edge indicator. + val capacity = if (minCovered > 0.dp) (budget.value / minCovered.value).toInt() else covered + val fold = covered > capacity + val shown = if (fold) (capacity - 1).coerceAtLeast(0) else covered + val folded = covered - shown + val slots = shown + if (fold) 1 else 0 + val first = minOf(budget, maxOf(budget / slots, startInset + minPeek)) + val rest = budget - first + val steps = slots - 1 + val starts = ArrayList(slots + 1) + starts += 0.dp + starts += first + for (i in 1 until slots) { + starts += first + rest * i / steps + } + val strips = ArrayList(slots) + var slot = 0 + if (fold) { + strips += PeekStrip(folded - 1, starts[0], starts[1] - starts[0], folded = folded) + slot = 1 + } + for (i in 0 until shown) { + val level = folded + i + val s = slot + i + strips += PeekStrip(level, starts[s], starts[s + 1] - starts[s]) + } + return strips +} + /** * The one shared sliding pane stack, adaptive to the window width. Both the * Pipelines and Runs destinations use it, so the motion and geometry live in @@ -109,13 +148,20 @@ internal fun paneWidthDp(hostWidth: Dp, offset: Dp): Dp = * keeps a constant width and the stack never consumes more than the budget * however deep it gets. * + * A covered pane shows a compact identity only (its pane composable is told + * [covered] and is expected to render just a title/status), constrained to the + * visible strip, so its full body is never drawn into a sliver. When the budget + * cannot give every covered pane the named minimum width, the oldest levels + * fold into a single edge indicator carrying their count rather than being + * squeezed. + * * [depth] is the number of visible panes minus one (0..[MAX_PANE_DEPTH]); * [pane] composes the level's content and is expected to render nothing for a - * level whose selection is empty (so a closing pane simply slides back out). - * On a wide window, tapping a covered pane's peek calls [onPopTo] with that - * pane's level, closing every pane to its right; [backContentDescription] names - * each strip. On a narrow window there is no strip and Back/gesture/the pane's - * own back control pop the level. + * level whose selection is empty (so a closing pane simply slides back out). On + * a wide window, tapping a covered pane's peek calls [onPopTo] with that pane's + * level, closing every pane to its right; [backContentDescription] names each + * strip. On a narrow window there is no strip and Back/gesture/the pane's own + * back control pop the level. * * Every pane is always composed and each level has its own long-lived * [animateDpAsState], so opening slides in and closing slides back out with no @@ -133,7 +179,7 @@ fun SlidingPaneStack( onPopTo: (Int) -> Unit, modifier: Modifier = Modifier, backContentDescription: (Int) -> String = { "Back" }, - pane: @Composable (level: Int, modifier: Modifier) -> Unit, + pane: @Composable (level: Int, covered: Boolean, modifier: Modifier) -> Unit, ) { BoxWithConstraints(modifier.fillMaxSize()) { // Measured once per layout. The insets are read once here and applied to @@ -146,64 +192,64 @@ fun SlidingPaneStack( val startInset = insetPadding.calculateLeftPadding(direction) val topInset = insetPadding.calculateTopPadding() val bottomInset = insetPadding.calculateBottomPadding() + // The strip/compact identity area: the host clear of the top/bottom insets. + val stripHeight = maxOf(0.dp, maxHeight - topInset - bottomInset) // Narrow: no peek at all (budget 0, every pane fills the host). Wide: one - // fixed budget shared between the covered panes. The platform's minimum - // interactive size is the floor for a tappable strip, never a literal. + // fixed budget shared between the covered panes, folded when it cannot + // give each the named minimum. The platform's minimum interactive size is + // the floor for a tappable strip, never a literal. val minPeek = maxOf(PEEK_WIDTH_DP, LocalMinimumInteractiveComponentSize.current) val budget = if (wide) peekBudgetDp(hostWidth) else 0.dp - val offsets = paneOpenOffsetsDp( - covered = depth, - budget = budget, - startInset = startInset, - minPeek = minPeek, - ) + val strips = peekStripsDp(depth, budget, startInset, minPeek) + val stripByLevel = strips.associateBy { it.level } + val folded = strips.firstOrNull()?.takeIf { it.folded > 1 }?.folded ?: 0 + // The active pane always opens at the whole budget (or 0 when narrow). + val activeStart = strips.fold(0.dp) { acc, strip -> acc + strip.width } - // Pane 0 fills the host; it is blocked as soon as anything covers it. - pane( - 0, - Modifier - .fillMaxSize() - .then(if (depth >= 1) Modifier.blockPointerInput() else Modifier), - ) - - // Panes 1..MAX are always composed (the animator stays warm); a level - // beyond the depth sits off-screen and the caller renders nothing. - for (level in 1..MAX_PANE_DEPTH) { - val covered = level - 1 - - // The covered pane's tappable peek (wide windows only): the strip - // between this pane's offset and the next pane's, clear of the - // status/nav bars and of the left gesture area. Tapping it closes - // every pane to its right. - if (budget > 0.dp && covered < depth) { - val stripStart = offsets[covered] - val stripEnd = offsets[covered + 1] - val stripOffset = if (covered == 0) startInset else stripStart - val stripWidth = if (covered == 0) stripEnd - startInset else stripEnd - stripStart - Box( - Modifier - .align(Alignment.TopStart) - .offset(x = stripOffset, y = topInset) - .width(maxOf(0.dp, stripWidth)) - .height(maxOf(0.dp, maxHeight - topInset - bottomInset)) - .clickable( - role = Role.Button, - onClickLabel = backContentDescription(covered), - onClick = { onPopTo(covered) }, - ) - .semantics { - contentDescription = backContentDescription(covered) - role = Role.Button - }, - ) + // The folded older levels as one edge indicator with a count, clear of the + // status/nav bars and of the left gesture area; tapping it jumps back to + // the newest folded level. + if (folded > 0) { + val strip = strips.first() + Box( + Modifier + .align(Alignment.TopStart) + .offset(x = startInset, y = topInset) + .width(maxOf(0.dp, strip.width - startInset)) + .height(stripHeight) + .clickable( + role = Role.Button, + onClickLabel = backContentDescription(folded - 1), + onClick = { onPopTo(folded - 1) }, + ) + .semantics { + contentDescription = backContentDescription(folded - 1) + role = Role.Button + }, + ) { + PaneIdentity("$folded more", null, Modifier.fillMaxSize()) } + } + + // Panes 0..MAX are always composed in order (the animator stays warm); a + // level beyond the depth sits off-screen and the caller renders nothing. + for (level in 0..MAX_PANE_DEPTH) { + val covered = level < depth + // A level folded into the edge indicator is not drawn on its own. + if (covered && level < folded) continue + val strip = if (covered) stripByLevel[level] else null // An open pane sits at its shared-budget offset; a closed one waits // exactly off the right edge. Its width is already the width it will // have when open, so it slides rather than grows. - val openOffset = if (level <= depth) offsets[level] else hostWidth - val openWidth = paneWidthDp(hostWidth, if (level <= depth) offsets[level] else budget) + val openOffset = when { + level > depth -> hostWidth + level == depth -> activeStart + strip != null -> strip.start + else -> 0.dp + } + val openWidth = paneWidthDp(hostWidth, if (level <= depth) openOffset else budget) val offset by animateDpAsState( targetValue = openOffset, animationSpec = spring(), @@ -216,7 +262,48 @@ fun SlidingPaneStack( .fillMaxHeight() .then(if (level < depth) Modifier.blockPointerInput() else Modifier), ) { - pane(level, Modifier.fillMaxSize()) + if (strip != null) { + // Constrain the compact identity to the visible strip so it is + // centred in the space the covered pane actually has. It rides + // with the pane's own offset and so slides in and out with it. + val stripInset = if (level == 0) startInset else 0.dp + Box( + Modifier + .align(Alignment.TopStart) + .offset(x = stripInset, y = topInset) + .width(maxOf(0.dp, strip.width - stripInset)) + .height(stripHeight), + ) { + pane(level, true, Modifier.fillMaxSize()) + } + } else { + pane(level, false, Modifier.fillMaxSize()) + } + } + + // The covered pane's tappable peek (wide windows only): the strip + // between this pane's offset and the next pane's, clear of the + // status/nav bars and of the left gesture area. It sits above the + // pane's compact identity so tapping it closes every pane to its + // right; it never overlaps the next pane. + if (strip != null) { + val stripInset = if (level == 0) startInset else 0.dp + Box( + Modifier + .align(Alignment.TopStart) + .offset(x = strip.start + stripInset, y = topInset) + .width(maxOf(0.dp, strip.width - stripInset)) + .height(stripHeight) + .clickable( + role = Role.Button, + onClickLabel = backContentDescription(level), + onClick = { onPopTo(level) }, + ) + .semantics { + contentDescription = backContentDescription(level) + role = Role.Button + }, + ) } } } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/StageDetailPane.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/StageDetailPane.kt index 804fe27f..5ceb488f 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/StageDetailPane.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/StageDetailPane.kt @@ -2,6 +2,7 @@ package net.awan.pipelines.ui.graph import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.padding import androidx.compose.foundation.rememberScrollState @@ -41,6 +42,7 @@ import net.awan.pipelines.ui.AppViewModel import net.awan.pipelines.ui.components.CodeBlock import net.awan.pipelines.ui.components.DetailTabBody import net.awan.pipelines.ui.components.KeyValueRow +import net.awan.pipelines.ui.components.PaneIdentity import net.awan.pipelines.ui.components.SectionHeader import net.awan.pipelines.ui.components.rememberSectionExpansion import net.awan.pipelines.ui.displayMap @@ -289,7 +291,19 @@ fun StageDetailPane( onBack: () -> Unit, wide: Boolean = false, modifier: Modifier = Modifier, + covered: Boolean = false, ) { + // A covered pane shows its compact identity only; the visit tab row and the + // stage body must never be drawn squeezed into the peek strip. + if (covered) { + val stage = graph.stages.firstOrNull { it.key == stageKey } + PaneIdentity( + title = GraphSemantics.nodeLabel(stageKey), + subtitle = if (stage != null) effectiveStageType(stage.type) else "terminal", + modifier = modifier.fillMaxSize(), + ) + return + } Scaffold( modifier = modifier, topBar = { @@ -449,6 +463,7 @@ fun RunStagePane( onBack: () -> Unit, wide: Boolean, modifier: Modifier = Modifier, + covered: Boolean = false, ) { val state by vm.runDetail.collectAsStateWithLifecycle() val configuredServerUrl by vm.configuredServerUrl.collectAsStateWithLifecycle() @@ -466,6 +481,7 @@ fun RunStagePane( onBack = onBack, wide = wide, modifier = modifier, + covered = covered, ) } @@ -479,6 +495,7 @@ fun PipelineStagePane( onBack: () -> Unit, wide: Boolean, modifier: Modifier = Modifier, + covered: Boolean = false, ) { val state by vm.pipelineDetail.collectAsStateWithLifecycle() val detail = state.data?.takeIf { it.id == pipelineId && it.version == version } @@ -488,6 +505,7 @@ fun PipelineStagePane( onBack = onBack, wide = wide, modifier = modifier, + covered = covered, ) } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineDetailScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineDetailScreen.kt index 0cd4793b..3b0d8117 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineDetailScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineDetailScreen.kt @@ -53,6 +53,7 @@ import net.awan.pipelines.ui.components.DetailTabs import net.awan.pipelines.ui.components.ErrorState import net.awan.pipelines.ui.components.KeyValueRow import net.awan.pipelines.ui.components.LoadingState +import net.awan.pipelines.ui.components.PaneIdentity import net.awan.pipelines.ui.components.collapsibleSection import net.awan.pipelines.ui.components.pipelineDetailTabs import net.awan.pipelines.ui.components.rememberSectionExpansion @@ -75,6 +76,7 @@ fun PipelineDetailScreen( onOpenStage: (String) -> Unit, modifier: Modifier = Modifier, wide: Boolean = false, + covered: Boolean = false, ) { val state by vm.pipelineDetail.collectAsStateWithLifecycle() var showStart by remember { mutableStateOf(false) } @@ -83,6 +85,17 @@ fun PipelineDetailScreen( val detail = state.data?.takeIf { it.id == pipelineId } + // A covered pane shows its compact identity only; the tab rail and section + // body must never be drawn squeezed into the peek strip. + if (covered) { + PaneIdentity( + title = detail?.name ?: "Pipeline", + subtitle = detail?.let { "v$version · ${it.graph.stages.size} stages" }, + modifier = modifier.fillMaxSize(), + ) + return + } + Scaffold( modifier = modifier, topBar = { diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt index 82fa9005..8b8efac9 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt @@ -35,6 +35,7 @@ import net.awan.pipelines.ui.components.EmptyState import net.awan.pipelines.ui.components.ErrorState import net.awan.pipelines.ui.components.ListRow import net.awan.pipelines.ui.components.LoadingState +import net.awan.pipelines.ui.components.PaneIdentity import net.awan.pipelines.ui.theme.pipelinesText @OptIn(ExperimentalMaterial3Api::class) @@ -44,12 +45,25 @@ fun PipelineListScreen( onOpen: (id: Long, version: Int) -> Unit, modifier: Modifier = Modifier, selectedId: Long? = null, + covered: Boolean = false, ) { val state by vm.pipelines.collectAsStateWithLifecycle() var query by remember { mutableStateOf("") } LaunchedEffect(Unit) { vm.refreshPipelines() } + // A covered pane shows its compact identity only; the search field and list + // must never be drawn squeezed into the peek strip. + if (covered) { + val count = state.data?.size ?: 0 + PaneIdentity( + title = "Pipelines", + subtitle = if (count > 0) "$count on this server" else null, + modifier = modifier.fillMaxSize(), + ) + return + } + Scaffold( modifier = modifier, topBar = { diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt index b2a8842d..21de11a4 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt @@ -56,6 +56,7 @@ import net.awan.pipelines.ui.components.DetailTabs import net.awan.pipelines.ui.components.ErrorState import net.awan.pipelines.ui.components.KeyValueRow import net.awan.pipelines.ui.components.LoadingState +import net.awan.pipelines.ui.components.PaneIdentity import net.awan.pipelines.ui.components.RunStatusIcon import net.awan.pipelines.ui.components.StatusChip import net.awan.pipelines.ui.components.collapsibleSection @@ -82,6 +83,7 @@ fun RunDetailScreen( onOpenStage: (String, Int) -> Unit, modifier: Modifier = Modifier, wide: Boolean = false, + covered: Boolean = false, ) { val state by vm.runDetail.collectAsStateWithLifecycle() val evidenceState by vm.evidence.collectAsStateWithLifecycle() @@ -111,6 +113,17 @@ fun RunDetailScreen( } } + // A covered pane shows its compact identity only; the tab rail, timeline and + // graphs must never be drawn squeezed into the peek strip. + if (covered) { + PaneIdentity( + title = run?.name ?: "Run", + subtitle = run?.status?.takeIf { it.isNotBlank() }, + modifier = modifier.fillMaxSize(), + ) + return + } + Scaffold( modifier = modifier, topBar = { diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt index b8ba1512..8455b8d3 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt @@ -50,6 +50,7 @@ import net.awan.pipelines.ui.components.RunStatusIcon import net.awan.pipelines.ui.components.ErrorState import net.awan.pipelines.ui.components.ListRow import net.awan.pipelines.ui.components.LoadingState +import net.awan.pipelines.ui.components.PaneIdentity import net.awan.pipelines.ui.components.runStateColor import net.awan.pipelines.ui.components.runStateOf import net.awan.pipelines.ui.formatDuration @@ -65,10 +66,23 @@ fun RunHistoryScreen( modifier: Modifier = Modifier, filterPipelineId: Long? = null, selectedRunId: Long? = null, + covered: Boolean = false, ) { val state by vm.runs.collectAsStateWithLifecycle() LaunchedEffect(Unit) { vm.refreshRuns() } + // A covered pane shows its compact identity only; the usage block, sticky day + // headers and run rows must never be drawn squeezed into the peek strip. + if (covered) { + val count = state.data?.runs?.size ?: 0 + PaneIdentity( + title = if (filterPipelineId == null) "Runs" else "Runs for this pipeline", + subtitle = if (count > 0) "$count recorded" else null, + modifier = modifier.fillMaxSize(), + ) + return + } + Scaffold( modifier = modifier, topBar = { diff --git a/android/app/src/test/java/net/awan/pipelines/ui/components/SlidingPaneStackTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/components/SlidingPaneStackTest.kt index 3799f08b..9bcc0424 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/components/SlidingPaneStackTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/components/SlidingPaneStackTest.kt @@ -7,28 +7,27 @@ import org.junit.Assert.assertTrue import org.junit.Test /** - * The pane geometry is pure, so the adaptive width rules are checked here without - * a device: a narrow window spends no peek at all, and a wide window spends one - * fixed budget shared between the covered panes however deep the stack gets. + * The pane geometry is pure, so the adaptive width and fold rules are checked + * here without a device: a narrow window spends no peek at all, a wide window + * spends one fixed budget shared between the covered panes however deep the + * stack gets, every shown peek keeps the named minimum covered width, and when + * the budget cannot give the whole stack that much the oldest levels fold into a + * single edge indicator rather than being squeezed. */ class SlidingPaneStackTest { private fun assertDp(expected: Dp, actual: Dp, delta: Float = 0.01f) = assertEquals(expected.value, actual.value, delta) + private fun totalWidth(strips: List): Dp = + strips.fold(0.dp) { acc, strip -> acc + strip.width } + @Test fun narrowWindowSpendsNoPeekAtAnyDepth() { - // Budget 0 is the narrow model: no stack and no leftover strip, so every - // pane's open offset is 0 (the host's left edge). + // Budget 0 is the narrow model: no stack and no leftover strip, so there + // are no covered strips and every pane opens at the host's left edge. for (covered in 0..4) { - val offsets = paneOpenOffsetsDp( - covered = covered, - budget = 0.dp, - startInset = 30.dp, - minPeek = PEEK_WIDTH_DP, - ) - assertEquals(covered + 1, offsets.size) - offsets.forEach { assertDp(0.dp, it) } + assertTrue(peekStripsDp(covered, 0.dp, 30.dp, PEEK_WIDTH_DP).isEmpty()) } } @@ -37,41 +36,59 @@ class SlidingPaneStackTest { val host = 800.dp val budget = peekBudgetDp(host) assertDp(PEEK_BUDGET_DP, budget) - // The active (topmost) pane's left edge is exactly the budget, so its - // width is host - budget no matter how many levels are open. + // The covered strips always sum to exactly the budget, so the active + // (topmost) pane's left edge — and its width — never depend on depth. for (covered in 1..4) { - val offsets = paneOpenOffsetsDp(covered, budget, startInset = 0.dp, minPeek = PEEK_WIDTH_DP) - assertDp(budget, offsets.last()) - assertDp(host - budget, paneWidthDp(host, offsets.last())) + val strips = peekStripsDp(covered, budget, startInset = 0.dp, minPeek = PEEK_WIDTH_DP) + assertDp(budget, totalWidth(strips)) + assertDp(host - budget, paneWidthDp(host, totalWidth(strips))) } } @Test - fun fourLevelsShareTheOneFixedBudget() { - val offsets = paneOpenOffsetsDp( - covered = 3, - budget = PEEK_BUDGET_DP, - startInset = 0.dp, - minPeek = PEEK_WIDTH_DP, - ) - // Four levels: the list plus three covered panes plus the active one. - assertEquals(4, offsets.size) - assertDp(PEEK_BUDGET_DP, offsets.last()) - val strips = offsets.zipWithNext { a, b -> b - a } - assertEquals(3, strips.size) - // The three covered panes share the budget between them, not three peeks. - assertDp(PEEK_BUDGET_DP, strips.fold(0.dp) { acc, strip -> acc + strip }) - strips.forEach { assertTrue("peek too thin to tap: $it", it >= PEEK_WIDTH_DP) } + fun twoCoveredLevelsEachKeepTheMinimumCoveredWidth() { + val strips = peekStripsDp(2, PEEK_BUDGET_DP, startInset = 0.dp, minPeek = PEEK_WIDTH_DP) + // Three levels (list + detail + stage): two covered panes, no fold, and + // each has at least the named minimum so its compact identity reads. + assertEquals(2, strips.size) + assertEquals(listOf(0, 1), strips.map { it.level }) + strips.forEach { assertTrue("peek below the minimum: $it", it.width >= MIN_COVERED_PANE_WIDTH_DP) } + assertTrue(strips.all { it.folded == 1 }) + } + + @Test + fun aFourthLevelFoldsTheOldestIntoOneIndicator() { + // Four levels (three covered) with a budget of two minimums: the oldest + // levels collapse into one edge indicator carrying their count instead of + // squeezing all three, and one peek still shows the newest covered pane. + val strips = peekStripsDp(3, PEEK_BUDGET_DP, startInset = 0.dp, minPeek = PEEK_WIDTH_DP) + assertEquals(2, strips.size) + assertEquals(2, strips.first().folded) + assertEquals(1, strips.last().folded) + assertEquals(2, strips.last().level) + assertTrue(strips.all { it.width >= MIN_COVERED_PANE_WIDTH_DP }) + assertDp(PEEK_BUDGET_DP, totalWidth(strips)) + } + + @Test + fun foldedLevelsAreTheOldestAndTheNewestStillPeeks() { + val covered = 4 + val strips = peekStripsDp(covered, PEEK_BUDGET_DP, startInset = 0.dp, minPeek = PEEK_WIDTH_DP) + // The newest covered level keeps its own peek; all older ones fold. + assertEquals(covered - 1, strips.last().level) + assertEquals(3, strips.first().folded) } @Test fun firstStripStaysTappableAfterTheGestureInset() { val startInset = 30.dp - val offsets = paneOpenOffsetsDp(3, PEEK_BUDGET_DP, startInset, PEEK_WIDTH_DP) + val strips = peekStripsDp(2, PEEK_BUDGET_DP, startInset, PEEK_WIDTH_DP) // The leftmost strip is widened so the tappable part (after the inset) // still measures at least the named minimum. - val firstStrip = offsets[1] - offsets[0] - assertTrue(firstStrip - startInset >= PEEK_WIDTH_DP) + assertTrue(strips.first().width - startInset >= PEEK_WIDTH_DP) + // Even when the fold forces the smallest split, the widening holds. + val folded = peekStripsDp(4, PEEK_BUDGET_DP, 80.dp, PEEK_WIDTH_DP) + assertTrue(folded.first().width - 80.dp >= PEEK_WIDTH_DP) } @Test @@ -87,19 +104,25 @@ class SlidingPaneStackTest { @Test fun tinyHostNeverProducesNegativeGeometry() { assertDp(0.dp, peekBudgetDp(100.dp)) - val offsets = paneOpenOffsetsDp(3, peekBudgetDp(100.dp), 0.dp, PEEK_WIDTH_DP) - offsets.zipWithNext { a, b -> assertTrue(b >= a) } - offsets.forEach { assertTrue(paneWidthDp(100.dp, it) >= 0.dp) } + val empty = peekStripsDp(3, peekBudgetDp(100.dp), 0.dp, PEEK_WIDTH_DP) + assertTrue(empty.isEmpty()) + assertTrue(paneWidthDp(100.dp, 0.dp) >= 0.dp) + // A tiny non-zero budget still yields one usable strip, never negative. + val tiny = peekStripsDp(3, 40.dp, 0.dp, PEEK_WIDTH_DP) + assertEquals(1, tiny.size) + assertTrue(tiny.first().width >= 0.dp) + assertTrue(paneWidthDp(100.dp, totalWidth(tiny)) >= 0.dp) } @Test - fun offsetsAreMonotonicAndDeterministic() { - // Same inputs give the same offsets (opening and closing are mirrors), - // and the panes never overlap in the wrong order. - val a = paneOpenOffsetsDp(3, PEEK_BUDGET_DP, 30.dp, PEEK_WIDTH_DP) - val b = paneOpenOffsetsDp(3, PEEK_BUDGET_DP, 30.dp, PEEK_WIDTH_DP) + fun stripsAreMonotonicAndDeterministic() { + // Same inputs give the same strips (opening and closing are mirrors), + // the strips never overlap, and they never run past the budget. + val a = peekStripsDp(3, PEEK_BUDGET_DP, 30.dp, PEEK_WIDTH_DP) + val b = peekStripsDp(3, PEEK_BUDGET_DP, 30.dp, PEEK_WIDTH_DP) assertEquals(a, b) - a.zipWithNext { x, y -> assertTrue(y >= x) } + a.zipWithNext { x, y -> assertTrue(y.start >= x.start + x.width) } + assertTrue(a.all { it.width >= 0.dp }) } @Test