From 1a890d8c31bc61623b4dc51424053cf6e549953b Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Thu, 15 Oct 2026 02:34:15 +0100 Subject: [PATCH] Draw workflow-graph edges as straight runs and give the graph a bigger panel A user reading the graph on their phone said it was not clear what happened, and asked for the TUI's straight arrows and a larger panel. - Edges are now axis-aligned orthogonal polylines instead of Bezier curves: the stage-to-stage runs and the routes into the bottom-row #success/#failure terminals are horizontal/vertical segments joined at right angles, matching the Go TUI's routing, and every arrowhead now points along the direction of its final segment instead of the straight source-to-target chord (which pointed wrongly as soon as a route turned a corner). Routing is a pure function. - The graph panel is a sensible share of the window height on both screens instead of 360dp/340dp, and a new expand/collapse control beside 'Fit graph to view' grows it to nearly the full height. Verified: :app:assembleDebug and :app:testDebugUnitTest succeed offline with 42 tests and 0 failures (WorkflowGraphTest 15 to 23, covering the orthogonal routing and arrowhead direction), and the app was driven on the emulator with before/after screenshots of a pipeline graph, a run graph with the executed route highlighted, a panned state and the expanded panel. --- android/README.md | 36 ++- .../awan/pipelines/ui/graph/WorkflowGraph.kt | 210 +++++++++++++++--- .../ui/screens/PipelineDetailScreen.kt | 6 +- .../pipelines/ui/screens/RunDetailScreen.kt | 16 +- .../pipelines/ui/graph/WorkflowGraphTest.kt | 138 ++++++++++++ 5 files changed, 352 insertions(+), 54 deletions(-) diff --git a/android/README.md b/android/README.md index 5f06568d..32900f21 100644 --- a/android/README.md +++ b/android/README.md @@ -86,7 +86,21 @@ stops it. arrows entering their top borders (an `error -> #failure` route leaves its source's bottom); labelled outcome edges (`error*` marks the implicit fallback), loops and branches, pan/zoom, and run highlighting (executed routes - highlighted, others dimmed) plus a screen-reader description. + highlighted, others dimmed) plus a screen-reader description. Edges are drawn as + axis-aligned orthogonal polylines like the TUI (`routePoints` computes the + path once per layout and stores it on `EdgeLayout.points`), and each arrowhead + points along its route's final segment rather than the from-to chord. +- One shared graph-panel height (`collapsedGraphHeight`/`expandedGraphHeight`) + replaces the former 360.dp and 340.dp literals, so both detail screens render + the graph at the same size: about 58% of the window height floored at a height + that still fits a 4-stage graph with its terminal row. The graph's TopEnd + control cluster pairs "Fit graph to view" with an expand/collapse toggle that + grows the panel to about the full window height; the expanded state is stored + in `rememberSaveable` and the panel refits on resize. Because the panel lives + inside each screen's `verticalScroll` column, growing it only extends it below + the fold, so expanding also requests `BringIntoViewRequester` to scroll the + taller panel back into the visible viewport instead of leaving the graph + centred off-screen. - Dark-first Material 3 theme with an app-owned colour scheme (no dynamic/ wallpaper colour): the dark scheme is the default and the window background and system bars are dark so launching shows no light flash; a complete light scheme @@ -129,9 +143,10 @@ Verified on macOS with the host toolchain (JDK 17 from Android Studio, `ANDROID_HOME=/Users/alan/Library/Android/sdk`, Gradle 8.11.1 `--offline`): - `:app:compileDebugKotlin`, `:app:assembleDebug` and `:app:testDebugUnitTest` - all succeed; **34 unit tests, 0 failures** (protocol model, graph semantics, - server URL, workflow-graph layout including the terminal row, bottom exits and - back edges). Re-run with `--rerun-tasks` to confirm. + all succeed; **42 unit tests, 0 failures** (protocol model, graph semantics, + server URL, workflow-graph layout including the terminal row, bottom exits, + back edges, orthogonal routing/axis alignment, arrowhead direction and the + shared panel height). Re-run with `--rerun-tasks` to confirm. - The debug APK was installed and driven on the `Pixel_Fold_API_36` emulator (Android 16, `adb shell cmd uimode night yes`) against a live server at `ws://10.0.2.2:8080/connect` with workspace `/Users/alan/repos/pipelines`. @@ -140,6 +155,19 @@ Verified on macOS with the host toolchain (JDK 17 from Android Studio, `captures/style_pass/` (both git-ignored) and reviewed. - `adb logcat` for the app package contained no `FATAL EXCEPTION`, Compose or other runtime exception during the sweep. +- The orthogonal-edge / resizable-panel pass was verified the same way: a + baseline APK was built from the pre-change tree and installed, then the new + build was installed and driven to the 4-stage pipeline-detail graph and a + run-detail graph with the executed route highlighted. `captures/graph_pass/` + (git-ignored) holds `pipeline_detail_before/after` and `run_detail_before/after` + pairs plus a panned state and the expanded panel after tapping the toggle + (`pipeline_detail_expanded_after`, `run_detail_panned_after`, + `run_detail_expanded_after`). A review of that pass found the expanded panel + scrolled below the fold (blank) and the PNGs prefixed by an adb stderr warning, + so the expand now scrolls the panel into view and the after-captures were + re-taken with a display id (`adb exec-out screencap -p -d `) so no + warning leaks into the files. `adb logcat` showed no `FATAL EXCEPTION` and no + app/Compose exception during the sweep. Known limitations of that run: pinch-zoom could not be driven through `adb` (single-touch pan only) and one portrait Fold viewport was used. A follow-up pass diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt index 33fc26cf..5017343f 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt @@ -1,13 +1,20 @@ package net.awan.pipelines.ui.graph import androidx.compose.foundation.Canvas +import androidx.compose.foundation.ExperimentalFoundationApi import androidx.compose.foundation.background import androidx.compose.foundation.gestures.detectTransformGestures import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.relocation.BringIntoViewRequester +import androidx.compose.foundation.relocation.bringIntoViewRequester import androidx.compose.material.icons.Icons import androidx.compose.material.icons.filled.FitScreen +import androidx.compose.material.icons.filled.Fullscreen +import androidx.compose.material.icons.filled.FullscreenExit import androidx.compose.material3.Icon import androidx.compose.material3.IconButton import androidx.compose.material3.MaterialTheme @@ -18,6 +25,8 @@ import androidx.compose.runtime.mutableFloatStateOf import androidx.compose.runtime.mutableIntStateOf import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.saveable.rememberSaveable import androidx.compose.runtime.setValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier @@ -31,6 +40,7 @@ import androidx.compose.ui.graphics.drawscope.Stroke import androidx.compose.ui.graphics.drawscope.withTransform import androidx.compose.ui.input.pointer.pointerInput import androidx.compose.ui.layout.onSizeChanged +import androidx.compose.ui.platform.LocalConfiguration import androidx.compose.ui.platform.LocalDensity import androidx.compose.ui.semantics.contentDescription import androidx.compose.ui.semantics.semantics @@ -39,10 +49,12 @@ import androidx.compose.ui.text.TextStyle import androidx.compose.ui.text.drawText import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.rememberTextMeasurer +import androidx.compose.ui.unit.Dp import androidx.compose.ui.unit.IntSize import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.sp import kotlin.math.abs +import kotlinx.coroutines.launch import net.awan.pipelines.data.protocol.Graph import net.awan.pipelines.data.protocol.GraphEdge import net.awan.pipelines.data.protocol.GraphRoute @@ -77,6 +89,9 @@ internal data class EdgeLayout( // there are, so each label can get its own row instead of overprinting. val labelSlot: Int, val labelCount: Int, + // The axis-aligned polyline this edge is drawn along, computed once by + // [routePoints] during layout so drawing never re-routes per frame. + val points: List = emptyList(), ) internal data class GraphLayout( @@ -95,6 +110,7 @@ internal data class GraphLayout( * When [runState] is supplied, executed stages/routes are highlighted and the * rest dimmed; when it is null the full definition is shown. */ +@OptIn(ExperimentalFoundationApi::class) @Composable fun WorkflowGraph( graph: Graph, @@ -103,7 +119,13 @@ fun WorkflowGraph( selectedStage: String? = null, ) { val density = LocalDensity.current + val configuration = LocalConfiguration.current val textMeasurer = rememberTextMeasurer() + // The panel lives inside the screens' scrolling column, so growing it just + // extends it downwards below the fold. This lets an expand scroll the panel + // back into view instead of leaving the graph off-screen. + val bringIntoView = remember { BringIntoViewRequester() } + val scope = rememberCoroutineScope() val layout = remember(graph, density) { with(density) { layoutGraph(graph, this) } } @@ -147,6 +169,8 @@ fun WorkflowGraph( // reset affordance below clears this and re-applies the fit transform. var userAdjusted by remember { mutableStateOf(false) } var fitRequest by remember { mutableIntStateOf(0) } + // Survives recomposition/rotation so a panel the user opened stays open. + var expanded by rememberSaveable { mutableStateOf(false) } // Fit the whole graph into the viewport on first layout and whenever the // viewport itself changes size, unless the user has taken over the view. @@ -172,6 +196,18 @@ fun WorkflowGraph( Box( modifier = modifier + // Let an expand scroll the (now taller) panel back into the visible + // viewport of the enclosing scrolling column. + .bringIntoViewRequester(bringIntoView) + // The shared panel height lives here so both screens get the same + // size; the caller only supplies width/layout modifiers. + .height( + if (expanded) { + expandedGraphHeight(configuration.screenHeightDp) + } else { + collapsedGraphHeight(configuration.screenHeightDp) + }, + ) // Compose does not clip children by default: without this the panned/ // zoomed Canvas draws nodes and edges over sibling content outside the // graph viewport. Clip at the shared container so every caller is covered. @@ -208,15 +244,39 @@ fun WorkflowGraph( drawNodes(layout, colors, runState, selectedStage, textMeasurer) } } - IconButton( - onClick = { - userAdjusted = false - // Re-run the fit effect even when the viewport is unchanged. - fitRequest += 1 - }, + Row( modifier = Modifier.align(Alignment.TopEnd).padding(4.dp), ) { - Icon(Icons.Default.FitScreen, contentDescription = "Fit graph to view") + IconButton( + onClick = { + userAdjusted = false + // Re-run the fit effect even when the viewport is unchanged. + fitRequest += 1 + }, + ) { + Icon(Icons.Default.FitScreen, contentDescription = "Fit graph to view") + } + IconButton( + onClick = { + val nowExpanded = !expanded + expanded = nowExpanded + // Refit the resized panel, mirroring the Fit control. + userAdjusted = false + fitRequest += 1 + if (nowExpanded) { + // Growing the panel pushes it below the fold of the + // enclosing scrolling column; scroll it back so the + // expanded graph is visible without a manual pan. + scope.launch { bringIntoView.bringIntoView() } + } + }, + ) { + if (expanded) { + Icon(Icons.Default.FullscreenExit, contentDescription = "Collapse graph") + } else { + Icon(Icons.Default.Fullscreen, contentDescription = "Expand graph") + } + } } } } @@ -367,13 +427,79 @@ internal fun layoutGraph(graph: Graph, density: androidx.compose.ui.unit.Density targetRank = targetRank, labelSlot = labelSlot, labelCount = countsBySource[edge.source] ?: 1, - ) + ).let { it.copy(points = routePoints(it)) } } val height = pad * 2 + nodeHeight + (if (hasTerminal) terminalRowGap + nodeHeight else 0f) return GraphLayout(positions.values.toList(), edgeLayouts, width, height) } +/** + * The axis-aligned polyline an edge is drawn along: horizontal and vertical runs + * joined at right angles, mirroring internal/tui/graph_layout.go (source track -> + * lane -> target track). Pure and independent of drawing so tests can assert it + * and layout can precompute it once per edge. + * + * - `bottomExit` (error -> #failure) drops out of the source's bottom, runs + * across above the terminal and drops into its top border. + * - `topEntry` (any other terminal) leaves the source's right edge, drops into a + * lane just above the lower terminal row, then drops into the terminal top. + * - `backEdge` (loop) dips below the stages, runs back horizontally and enters + * the target's left edge. + * - a forward edge is a single horizontal segment when source and target share a + * y, otherwise an L across a shared mid-x. + * + * Consecutive equal points are collapsed so no zero-length segment is produced. + */ +internal fun routePoints(edge: EdgeLayout): List { + val raw = when { + edge.bottomExit -> { + val approachY = edge.to.y - BOTTOM_EXIT_APPROACH + listOf(edge.from, Offset(edge.from.x, approachY), Offset(edge.to.x, approachY), edge.to) + } + edge.topEntry -> { + val laneY = edge.to.y - LANE_APPROACH + listOf(edge.from, Offset(edge.from.x, laneY), Offset(edge.to.x, laneY), edge.to) + } + edge.backEdge -> { + val dipY = maxOf(edge.from.y, edge.to.y) + BACK_EDGE_DIP + val leadX = edge.to.x - BACK_EDGE_LEAD + listOf( + edge.from, + Offset(edge.from.x, dipY), + Offset(leadX, dipY), + Offset(leadX, edge.to.y), + edge.to, + ) + } + edge.from.y == edge.to.y -> listOf(edge.from, edge.to) + else -> { + val midX = (edge.from.x + edge.to.x) / 2f + listOf(edge.from, Offset(midX, edge.from.y), Offset(midX, edge.to.y), edge.to) + } + } + val points = ArrayList(raw.size) + for (point in raw) { + val last = points.lastOrNull() + if (last == null || last.x != point.x || last.y != point.y) points += point + } + return points +} + +/** + * Direction of the final non-degenerate segment of [points], used to orient an + * arrowhead along the incoming segment rather than the from-to chord (which is + * wrong once a route turns a corner). Returns [Offset.Zero] when there is no + * segment to derive a direction from. + */ +internal fun arrowDirection(points: List): Offset { + for (i in points.size - 1 downTo 1) { + val delta = points[i] - points[i - 1] + if (delta.x != 0f || delta.y != 0f) return delta + } + return Offset.Zero +} + /** * Column rank for every stage in declaration order, mirroring * tui.layoutSingleRowGraph: `graph.Stages` is the source order, so stages keep @@ -396,34 +522,17 @@ private fun DrawScope.drawEdgePaths( val executed = edge.isExecuted(runState) val color = outcomeColor(edge.edge, colors) val alpha = if (executed) 1f else 0.25f + // Routing already happened once in layoutGraph; drawing only replays the + // stored polyline, so there is no per-frame recompute. + val points = if (edge.points.isEmpty()) routePoints(edge) else edge.points + if (points.size < 2) continue val path = Path() - path.moveTo(edge.from.x, edge.from.y) - when { - // An error->#failure route drops out of the source bottom, runs down - // and across, then rises into the terminal top border. - edge.bottomExit -> { - val approachY = edge.to.y - BOTTOM_EXIT_APPROACH - path.lineTo(edge.from.x, approachY) - path.lineTo(edge.to.x, approachY) - path.lineTo(edge.to.x, edge.to.y) - } - // Terminal edges leave the source's right edge and curve down/right - // into the terminal's top border. - edge.topEntry -> { - val midX = (edge.from.x + edge.to.x) / 2f - path.cubicTo(midX, edge.from.y, midX, edge.to.y, edge.to.x, edge.to.y) - } - edge.backEdge -> { - val dip = maxOf(edge.from.y, edge.to.y) + BACK_EDGE_DIP - path.cubicTo(edge.from.x + 24f, dip, edge.to.x - 24f, dip, edge.to.x, edge.to.y) - } - else -> { - val midX = (edge.from.x + edge.to.x) / 2f - path.cubicTo(midX, edge.from.y, midX, edge.to.y, edge.to.x, edge.to.y) - } + path.moveTo(points.first().x, points.first().y) + for (i in 1 until points.size) { + path.lineTo(points[i].x, points[i].y) } drawPath(path, color = color.copy(alpha = alpha), style = Stroke(width = 3f)) - drawArrowHead(edge.from, edge.to, color.copy(alpha = alpha)) + drawArrowHead(points, color.copy(alpha = alpha)) } } @@ -470,8 +579,17 @@ private fun DrawScope.drawEdgeLabels( } } -private fun DrawScope.drawArrowHead(from: Offset, to: Offset, color: Color) { - val angle = kotlin.math.atan2((to.y - from.y).toDouble(), (to.x - from.x).toDouble()) +/** + * Draws an arrowhead at the tip of [points], oriented along the final segment's + * direction (see [arrowDirection]) instead of the from-to chord, so a route that + * turns a corner still gets an arrow pointing the way it actually travels. + */ +private fun DrawScope.drawArrowHead(points: List, color: Color) { + if (points.size < 2) return + val to = points.last() + val direction = arrowDirection(points) + if (direction.x == 0f && direction.y == 0f) return + val angle = kotlin.math.atan2(direction.y.toDouble(), direction.x.toDouble()) val size = 12f val left = Offset( x = to.x - size * kotlin.math.cos(angle - 0.5).toFloat(), @@ -593,6 +711,28 @@ private const val BACK_EDGE_DIP = 64f /** How far above a terminal's top border the bottom-exit route levels off. */ private const val BOTTOM_EXIT_APPROACH = 32f +/** How far above the target's left edge a loop route levels off before entering. */ +private const val BACK_EDGE_LEAD = 24f + +/** How far above the terminal row a top-entry route runs before dropping in. */ +private const val LANE_APPROACH = 32f + /** Breathing room left around a fitted graph, and the least content kept visible. */ private val FIT_PADDING = 16.dp private val MIN_VISIBLE = 48.dp + +/** + * Collapsed graph-panel height, shared by both detail screens (one source for + * the former 360.dp / 340.dp literals). ~58% of the window height so the graph + * is a substantial share of the screen, floored at a height that still fits a + * 4-stage layout plus its lower terminal row: pad*2 + node + terminal gap + node + * = 32*2 + 56 + 72 + 56 = 248px at density 1. + */ +internal fun collapsedGraphHeight(screenHeightDp: Int): Dp = + (screenHeightDp * 0.58f).dp.coerceAtLeast(GRAPH_PANEL_MIN_HEIGHT) + +/** Expanded graph-panel height: (approximately) the full available window height. */ +internal fun expandedGraphHeight(screenHeightDp: Int): Dp = (screenHeightDp * 0.92f).dp + +/** Floor that still fits a 4-stage graph with its terminal row (see above). */ +internal val GRAPH_PANEL_MIN_HEIGHT = 260.dp 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 e963a636..a13805cc 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 @@ -1,12 +1,10 @@ package net.awan.pipelines.ui.screens 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.rememberScrollState import androidx.compose.foundation.verticalScroll @@ -145,9 +143,7 @@ private fun PipelineDetailContent(detail: PipelineDetail, modifier: Modifier = M style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant, ) - Box(Modifier.fillMaxWidth().height(360.dp)) { - WorkflowGraph(graph = detail.graph, modifier = Modifier.fillMaxSize()) - } + WorkflowGraph(graph = detail.graph, modifier = Modifier.fillMaxWidth()) if (detail.source.isNotBlank()) { Text("Source", style = MaterialTheme.typography.titleMedium) 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 b7a6e7d9..fe85e808 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 @@ -1,12 +1,10 @@ package net.awan.pipelines.ui.screens 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.rememberScrollState import androidx.compose.foundation.verticalScroll @@ -238,14 +236,12 @@ private fun RunDetailContent( style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant, ) - Box(Modifier.fillMaxWidth().height(340.dp)) { - WorkflowGraph( - graph = run.graph, - modifier = Modifier.fillMaxSize(), - runState = runState, - selectedStage = runState.currentStage, - ) - } + WorkflowGraph( + graph = run.graph, + modifier = Modifier.fillMaxWidth(), + runState = runState, + selectedStage = runState.currentStage, + ) } else { Text("This server did not include the run graph.", style = MaterialTheme.typography.bodySmall) } diff --git a/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt index b23280ab..ce1d4fd6 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt @@ -9,6 +9,7 @@ import net.awan.pipelines.data.protocol.Stage import org.junit.Assert.assertEquals import org.junit.Assert.assertTrue import org.junit.Test +import kotlin.math.hypot class WorkflowGraphTest { @@ -187,4 +188,141 @@ class WorkflowGraphTest { assertTrue(single.width.isFinite() && single.height.isFinite()) assertTrue(single.nodes.single().terminal.not()) } + + /** + * Every route is drawn as an axis-aligned polyline anchored to the edge's + * from/to anchors, with no zero-length segment: pure geometry, no Compose + * runtime. Mirrors the TUI's right-angled tracks. + */ + @Test + fun everyRouteIsAxisAlignedAndAnchoredToItsEndpoints() { + val layout = layoutGraph(sampleGraph(), Density(1f)) + assertTrue(layout.edges.isNotEmpty()) + for (edge in layout.edges) { + val points = routePoints(edge) + assertTrue("route too short for ${edge.edge}", points.size >= 2) + assertEquals(edge.from, points.first()) + assertEquals(edge.to, points.last()) + for (i in 1 until points.size) { + val a = points[i - 1] + val b = points[i] + assertTrue("zero-length segment in ${edge.edge}", a.x != b.x || a.y != b.y) + assertTrue("segment not axis-aligned in ${edge.edge}", a.x == b.x || a.y == b.y) + } + } + } + + /** Layout precomputes the polyline once; drawing replays it without re-routing. */ + @Test + fun layoutStoresTheRoutePointsOnEachEdge() { + val layout = layoutGraph(sampleGraph(), Density(1f)) + for (edge in layout.edges) { + assertEquals(routePoints(edge), edge.points) + } + } + + /** + * The arrowhead direction is the final segment's delta, not the straight + * from-to chord, which no longer points the travel direction once a route + * turns a corner. + */ + @Test + fun arrowDirectionFollowsTheFinalSegmentNotTheChord() { + val layout = layoutGraph(sampleGraph(), Density(1f)) + val pointsFor: (String, String) -> List = { source, outcome -> + layout.edges.first { it.edge.source == source && it.edge.outcome == outcome }.points + } + // Every cornered route's arrow follows its final segment exactly. + for (edge in layout.edges.filter { it.bottomExit || it.topEntry || it.backEdge }) { + val points = edge.points + val last = points[points.size - 1] - points[points.size - 2] + assertEquals(last, arrowDirection(points)) + } + // The three canonical turn cases differ from the straight from-to chord. + for (points in listOf( + pointsFor("planner", "error"), // bottomExit + pointsFor("ui_reviewer", "approved"), // topEntry + pointsFor("reviewer", "rejected"), // backEdge + )) { + val last = points[points.size - 1] - points[points.size - 2] + val chord = points.last() - points.first() + val chordLength = hypot(chord.x, chord.y) + val dirLength = hypot(last.x, last.y) + assertTrue(dirLength > 0f) + val normalizedChord = Offset(chord.x / chordLength, chord.y / chordLength) + val normalizedDir = Offset(last.x / dirLength, last.y / dirLength) + assertTrue(normalizedChord != normalizedDir) + } + } + + @Test + fun terminalTopEntryRoutesDropVerticallyIntoTheTerminalTopCentre() { + val layout = layoutGraph(sampleGraph(), Density(1f)) + val success = layout.nodes.single { it.key == Protocol.SUCCESS_END } + val edge = layout.edges.first { it.edge.target == Protocol.SUCCESS_END && !it.bottomExit } + assertTrue(edge.topEntry) + val points = edge.points + val before = points[points.size - 2] + val tip = points.last() + assertEquals(before.x, tip.x, 0.001f) + assertTrue(tip.y > before.y) + assertEquals(success.x + success.width / 2f, tip.x, 0.001f) + assertEquals(success.y, tip.y, 0.001f) + } + + @Test + fun errorToFailureBottomExitEndsVerticalDownAtTheFailureTopCentre() { + val layout = layoutGraph(sampleGraph(), Density(1f)) + val failure = layout.nodes.single { it.key == Protocol.FAILURE_END } + val edge = layout.edges.first { it.edge.source == "planner" && it.edge.outcome == "error" } + assertTrue(edge.bottomExit) + val points = edge.points + val before = points[points.size - 2] + val tip = points.last() + assertEquals(before.x, tip.x, 0.001f) + assertTrue(tip.y > before.y) + assertEquals(failure.x + failure.width / 2f, tip.x, 0.001f) + assertEquals(failure.y, tip.y, 0.001f) + } + + @Test + fun backEdgeEndsWithAHorizontalSegmentIntoTheTargetLeftEdge() { + val layout = layoutGraph(sampleGraph(), Density(1f)) + val edge = layout.edges.first { it.edge.source == "reviewer" && it.edge.outcome == "rejected" } + assertTrue(edge.backEdge) + val implementer = layout.nodes.single { it.key == "implementer" } + val points = edge.points + val before = points[points.size - 2] + val tip = points.last() + assertEquals(before.y, tip.y, 0.001f) + assertTrue(tip.x > before.x) + assertEquals(implementer.x, tip.x, 0.001f) + assertEquals(implementer.y + implementer.height / 2f, tip.y, 0.001f) + } + + @Test + fun forwardEdgeBetweenStagesIsASingleHorizontalSegment() { + val layout = layoutGraph(sampleGraph(), Density(1f)) + val edge = layout.edges.first { it.edge.source == "planner" && it.edge.outcome == "success" } + assertEquals(edge.from.y, edge.to.y, 0.001f) + assertEquals(2, edge.points.size) + assertEquals(edge.from, edge.points.first()) + assertEquals(edge.to, edge.points.last()) + assertEquals(edge.points.first().y, edge.points.last().y, 0.001f) + } + + /** + * Both screens share one height helper: a fraction of the window height with + * a floor that still fits a 4-stage graph plus its terminal row. + */ + @Test + fun collapsedGraphPanelIsAFractionOfTheWindowWithAMinimumFloor() { + assertEquals(580f, collapsedGraphHeight(1000).value, 0.01f) + // Short windows fall back to the minimum that fits a 4-stage graph. + assertEquals(GRAPH_PANEL_MIN_HEIGHT, collapsedGraphHeight(200)) + assertTrue(collapsedGraphHeight(100).value >= GRAPH_PANEL_MIN_HEIGHT.value) + // Expanded is larger and approximately the full window height. + assertTrue(expandedGraphHeight(1000).value > collapsedGraphHeight(1000).value) + assertEquals(920f, expandedGraphHeight(1000).value, 0.01f) + } }