import 'package:flutter/cupertino.dart'; import 'package:flutter/foundation.dart' show listEquals; import 'package:flutter/material.dart'; import '../../../ui/adaptive/host.dart'; import '../domain/graph_definition.dart'; import '../domain/run_graph_state.dart'; import '../layout/layout_models.dart'; import '../painting/graph_edge_layer.dart'; import '../routing/route_models.dart'; import 'graph_canvas_style.dart'; import 'graph_stage_node.dart'; import 'measured_child.dart'; /// The run graph's canvas primitives: split route painting and measurement of /// the exact status-bearing nodes the run renderer places. /// /// This keeps the landed `GraphEdgePainter` geometry (paths and arrowheads) and /// adds only what run evidence needs: two route classes on one passive layer. /// No node is invented, no route is re-routed and no style is assumed here. /// A passive canvas that draws taken routes as solid, arrowed strokes and /// untaken routes as dashed, arrowless strokes behind them. /// /// The caller supplies the already-routed [executedRoutes] and /// [untakenRoutes], the graph-space [canvasSize] and its native theme colours. /// The layer never takes pointer input, so nodes and labels keep their gestures. class RunGraphEdgeLayer extends StatelessWidget { const RunGraphEdgeLayer({ super.key, required this.executedRoutes, required this.untakenRoutes, required this.canvasSize, required this.executedColor, required this.untakenColor, required this.strokeWidth, }); final List executedRoutes; final List untakenRoutes; final Size canvasSize; final Color executedColor; final Color untakenColor; final double strokeWidth; @override Widget build(BuildContext context) => CustomPaint( size: canvasSize, painter: RunGraphEdgePainter( executedRoutes: executedRoutes, untakenRoutes: untakenRoutes, executedColor: executedColor, untakenColor: untakenColor, strokeWidth: strokeWidth, ), ); } /// Paints a [RunGraphEdgeLayer]. /// /// Executed routes reuse the landed [GraphEdgePainter] path and arrow geometry; /// untaken routes are the same polyline broken into native-sized dashes and /// never receive an arrowhead. Public so the compositor and its tests share one /// decision about which class of route gets an arrow. class RunGraphEdgePainter extends CustomPainter { RunGraphEdgePainter({ required this.executedRoutes, required this.untakenRoutes, required this.executedColor, required this.untakenColor, required this.strokeWidth, }) : assert(strokeWidth > 0), _executed = GraphEdgePainter( routes: executedRoutes, color: executedColor, strokeWidth: strokeWidth, ), _executedLine = Paint() ..color = executedColor ..strokeWidth = strokeWidth ..style = PaintingStyle.stroke ..strokeJoin = StrokeJoin.round, _untakenLine = Paint() ..color = untakenColor ..strokeWidth = strokeWidth ..style = PaintingStyle.stroke ..strokeJoin = StrokeJoin.round, _arrow = Paint() ..color = executedColor ..style = PaintingStyle.fill; final List executedRoutes; final List untakenRoutes; final Color executedColor; final Color untakenColor; final double strokeWidth; final GraphEdgePainter _executed; final Paint _executedLine; final Paint _untakenLine; final Paint _arrow; /// Dash and gap lengths in graph space; a dash never becomes a route style. static const double dashLength = 12; static const double dashGap = 8; @override void paint(Canvas canvas, Size size) { if (executedRoutes.isEmpty && untakenRoutes.isEmpty) return; canvas.save(); canvas.clipRect(Offset.zero & size); for (final route in untakenRoutes) { if (route.points.length < 2) continue; canvas.drawPath(dashedPath(route), _untakenLine); } for (final route in executedRoutes) { if (route.points.length < 2) continue; canvas.drawPath(_executed.linePath(route), _executedLine); } for (final route in executedRoutes) { if (route.points.length < 2) continue; canvas.drawPath(_executed.arrowPath(route), _arrow); } canvas.restore(); } /// The route's polyline split into [dashLength] segments separated by /// [dashGap], following every orthogonal bend without smoothing. Path dashedPath(EdgeRoute route) { final source = _executed.linePath(route); final dashed = Path(); for (final metric in source.computeMetrics()) { var start = 0.0; while (start < metric.length) { final end = start + dashLength < metric.length ? start + dashLength : metric.length; dashed.addPath(metric.extractPath(start, end), Offset.zero); start = end + dashGap; } } return dashed; } /// Passive like the landed edge layer: every point misses. @override bool hitTest(Offset position) => false; @override bool shouldRepaint(RunGraphEdgePainter oldDelegate) => oldDelegate.executedColor != executedColor || oldDelegate.untakenColor != untakenColor || oldDelegate.strokeWidth != strokeWidth || !listEquals(oldDelegate.executedRoutes, executedRoutes) || !listEquals(oldDelegate.untakenRoutes, untakenRoutes); } /// The run canvas: split route classes behind status-bearing native nodes, with /// outcome labels only for routes the run actually took. /// /// [layout] and [routing] are the caller's measured geometry. The canvas never /// changes them and never assumes a node size; the caller supplies the pan/zoom /// viewport around this content. class RunGraphCanvas extends StatelessWidget { const RunGraphCanvas({ super.key, required this.nodes, required this.layout, required this.routing, required this.state, required this.style, required this.recordedStatuses, required this.onStageSelected, this.selectedStage, }); final List nodes; final GraphLayout layout; final GraphRouting routing; final RunGraphState state; final GraphCanvasStyle style; final Map recordedStatuses; final ValueChanged onStageSelected; final String? selectedStage; @override Widget build(BuildContext context) { final nodesByKey = { for (final node in nodes) node.key: node, }; final executed = []; final untaken = []; for (final route in routing.routes) { if (state.isRouteTaken(route.source, route.outcome, route.target)) { executed.add(route); } else { untaken.add(route); } } final executedIds = {for (final route in executed) route.id}; final size = Size(routing.width, routing.height); final activeStage = state.activeStage; final cupertino = usesCupertinoHost(context); final executedColor = cupertino ? CupertinoTheme.of(context).primaryColor : Theme.of(context).colorScheme.primary; return Stack( clipBehavior: Clip.none, children: [ Positioned.fill( child: RunGraphEdgeLayer( executedRoutes: executed, untakenRoutes: untaken, canvasSize: size, executedColor: executedColor, untakenColor: style.edgeColor, strokeWidth: style.edgeWidth, ), ), for (final box in layout.nodes) Positioned( left: box.x, top: box.y, width: box.width, height: box.height, child: RunGraphNode( node: nodesByKey[box.key]!, recordedStatus: recordedStatuses[box.key], selected: box.key == selectedStage, active: box.key == activeStage, opensVisit: !nodesByKey[box.key]!.terminal && state.isStageVisited(box.key), onSelected: onStageSelected, ), ), // A run labels only the routes that actually happened. for (final label in routing.labels) if (executedIds.contains(label.edgeId)) Positioned( left: label.x, top: label.y, child: _takenLabel( routing.routeFor(label.edgeId)!, executedColor, ), ), ], ); } } /// A taken route's label led by its place in the run (`2`, or `2, 5` for a /// loop), so the path reads in order. extension on RunGraphCanvas { Widget _takenLabel(EdgeRoute route, Color color) { final order = state.routeOrder(route.source, route.outcome, route.target); final text = Text(route.label, style: style.labelStyle); if (order.isEmpty) return text; return Row( mainAxisSize: MainAxisSize.min, children: [ Container( key: ValueKey('run-route-order:${route.id}'), padding: const EdgeInsets.symmetric(horizontal: 5, vertical: 1), decoration: BoxDecoration( color: color, borderRadius: BorderRadius.circular(8), ), child: Text( order.join(', '), style: const TextStyle( color: Color(0xFFFFFFFF), fontSize: 10, fontWeight: FontWeight.w700, ), ), ), const SizedBox(width: 4), text, ], ); } } /// One placed run node. A visited stage is the native control with its recorded /// status; an unvisited node and a terminal are labels with no tap target or /// button semantics, because neither owns a recorded visit to open. [active] /// marks the run's recorded current stage while it executes; it only adds the /// live halo, never a visit or a control. class RunGraphNode extends StatelessWidget { const RunGraphNode({ super.key, required this.node, required this.recordedStatus, required this.opensVisit, required this.onSelected, this.selected = false, this.active = false, }); final GraphNode node; final String? recordedStatus; final bool opensVisit; final bool selected; final bool active; final ValueChanged onSelected; @override Widget build(BuildContext context) { final status = recordedStatus; if (opensVisit) { return GraphStageNode( node: node, recordedStatus: status, selected: selected, active: active, onSelected: onSelected, ); } return Semantics( container: true, label: status == null ? node.label : '${node.label}\n$status', child: ExcludeSemantics( child: IgnorePointer( child: GraphStageNode( node: node, recordedStatus: status, active: active, onSelected: (_) {}, ), ), ), ); } } /// Measures the status-bearing run nodes and every route label offstage. /// /// A visited node is taller than the same node without its recorded status, so /// the measurement must use the exact widget the canvas places. Sizes are /// reported after layout and callers schedule the placement frame. class RunGraphMeasurements extends StatelessWidget { const RunGraphMeasurements({ super.key, required this.nodes, required this.edges, required this.maxNodeWidth, required this.labelStyle, required this.recordedStatuses, required this.onNodeSize, required this.onLabelSize, }); final List nodes; final List edges; final double maxNodeWidth; final TextStyle labelStyle; final Map recordedStatuses; final void Function(String, Size) onNodeSize; final void Function(String, Size) onLabelSize; @override Widget build(BuildContext context) => Offstage( child: OverflowBox( alignment: Alignment.topLeft, minWidth: 0, maxWidth: double.infinity, minHeight: 0, maxHeight: double.infinity, child: Column( mainAxisSize: MainAxisSize.min, crossAxisAlignment: CrossAxisAlignment.start, children: [ for (final node in nodes) MeasuredChild( key: ValueKey( 'run-node:${node.key}:${node.label}:' '${recordedStatuses[node.key] ?? ''}', ), onSize: (size) => onNodeSize(node.key, size), child: ConstrainedBox( constraints: BoxConstraints(maxWidth: maxNodeWidth), child: GraphStageNode( node: node, recordedStatus: recordedStatuses[node.key], onSelected: (_) {}, ), ), ), for (final edge in edges) MeasuredChild( key: ValueKey('run-label:${edge.id}'), onSize: (size) => onLabelSize(edge.label, size), child: Text(edge.label, style: labelStyle), ), ], ), ), ); }