232 lines
7.5 KiB
Dart
232 lines
7.5 KiB
Dart
import 'package:flutter/cupertino.dart';
|
|
import 'package:flutter/material.dart';
|
|
|
|
import '../../../core/api_gateway.dart';
|
|
import '../domain/graph_definition.dart';
|
|
import '../layout/graph_node_layout.dart';
|
|
import '../layout/layout_models.dart';
|
|
import '../painting/graph_edge_layer.dart';
|
|
import '../routing/graph_edge_routing.dart';
|
|
import '../routing/route_models.dart';
|
|
import 'graph_canvas_style.dart';
|
|
import 'graph_stage_node.dart';
|
|
import 'graph_measurements.dart';
|
|
|
|
/// The definition's own empty-state wording (web `PIPELINE_GRAPH_EMPTY`).
|
|
const String definitionGraphEmpty = 'This pipeline has no stages.';
|
|
|
|
/// One pipeline definition as a readable native graph: measured stage nodes,
|
|
/// routed passive edges behind them and native outcome labels on their boxes.
|
|
///
|
|
/// [selectedStage] is a node key (including `#success`/`#failure`) and
|
|
/// [onSelected] reports the exact key activated. Nothing reads run evidence:
|
|
/// nodes show no status and terminals stay plain, so no visit is implied. The
|
|
/// view fills bounded caller constraints with a stock [InteractiveViewer].
|
|
class DefinitionGraphView extends StatefulWidget {
|
|
const DefinitionGraphView({
|
|
super.key,
|
|
required this.graph,
|
|
required this.onSelected,
|
|
this.selectedStage,
|
|
});
|
|
|
|
final JsonMap graph;
|
|
final String? selectedStage;
|
|
final ValueChanged<String> onSelected;
|
|
|
|
@override
|
|
State<DefinitionGraphView> createState() => _DefinitionGraphViewState();
|
|
}
|
|
|
|
class _DefinitionGraphViewState extends State<DefinitionGraphView> {
|
|
final Map<String, Size> _nodeSizes = {};
|
|
final Map<String, Size> _labelSizes = {};
|
|
TextScaler? _scaler;
|
|
bool _rebuildScheduled = false;
|
|
|
|
@override
|
|
void didChangeDependencies() {
|
|
super.didChangeDependencies();
|
|
// A different text scale changes every measured extent; drop the old
|
|
// extents so a stale 1x layout is never rendered around 2x text.
|
|
final scaler = MediaQuery.textScalerOf(context);
|
|
if (scaler != _scaler) {
|
|
_scaler = scaler;
|
|
_nodeSizes.clear();
|
|
_labelSizes.clear();
|
|
}
|
|
}
|
|
|
|
/// Records one measured extent and schedules the frame that uses it.
|
|
void _record(Map<String, Size> sizes, String key, Size size) {
|
|
if (sizes[key] == size) return;
|
|
sizes[key] = size;
|
|
if (_rebuildScheduled) return;
|
|
_rebuildScheduled = true;
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
_rebuildScheduled = false;
|
|
if (mounted) setState(() {});
|
|
});
|
|
}
|
|
|
|
/// The landed layout and routing for the measured extents, or null until
|
|
/// every node and every edge label has a real measurement.
|
|
(GraphLayout, GraphRouting)? _geometry(
|
|
List<GraphNode> nodes,
|
|
List<GraphEdge> edges,
|
|
) {
|
|
final extents = <String, NodeExtent>{};
|
|
for (final node in nodes) {
|
|
final size = _nodeSizes[node.key];
|
|
if (size == null) return null;
|
|
extents[node.key] = NodeExtent(width: size.width, height: size.height);
|
|
}
|
|
final labelExtents = <int, LabelExtent>{};
|
|
for (final edge in edges) {
|
|
final size = _labelSizes[edge.label];
|
|
if (size == null) return null;
|
|
labelExtents[edge.id] = LabelExtent(
|
|
width: size.width,
|
|
height: size.height,
|
|
);
|
|
}
|
|
final layout = layoutGraphNodes(
|
|
nodes: nodes,
|
|
edges: edges,
|
|
extents: extents,
|
|
config: graphCanvasLayoutConfig(labelExtents.values),
|
|
);
|
|
final routing = routeGraphEdges(
|
|
layout: layout,
|
|
edges: edges,
|
|
labelExtents: labelExtents,
|
|
config: graphCanvasRoutingConfig(),
|
|
);
|
|
return (layout, routing);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final nodes = graphNodes(widget.graph);
|
|
final edges = graphEdges(widget.graph);
|
|
final style = GraphCanvasStyle.of(context);
|
|
return LayoutBuilder(
|
|
builder: (context, constraints) {
|
|
assert(
|
|
constraints.hasBoundedWidth && constraints.hasBoundedHeight,
|
|
'DefinitionGraphView needs a bounded viewport; constrain it, for '
|
|
'example with a SizedBox or an Expanded slot.',
|
|
);
|
|
final geometry = nodes.isEmpty ? null : _geometry(nodes, edges);
|
|
return Stack(
|
|
fit: StackFit.expand,
|
|
children: [
|
|
if (nodes.isEmpty)
|
|
_message(definitionGraphEmpty, style)
|
|
else if (geometry != null)
|
|
_canvas(nodes, geometry.$1, geometry.$2, style)
|
|
else
|
|
const SizedBox.shrink(),
|
|
if (nodes.isNotEmpty)
|
|
GraphMeasurements(
|
|
nodes: nodes,
|
|
edges: edges,
|
|
maxNodeWidth: constraints.maxWidth,
|
|
labelStyle: style.labelStyle,
|
|
selectedStage: widget.selectedStage,
|
|
onNodeSize: (key, size) => _record(_nodeSizes, key, size),
|
|
onLabelSize: (key, size) => _record(_labelSizes, key, size),
|
|
),
|
|
],
|
|
);
|
|
},
|
|
);
|
|
}
|
|
|
|
Widget _message(String message, GraphCanvasStyle style) {
|
|
return Padding(
|
|
padding: const EdgeInsets.all(24),
|
|
child: Align(
|
|
alignment: AlignmentDirectional.topStart,
|
|
child: Text(message, style: style.messageStyle),
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _canvas(
|
|
List<GraphNode> nodes,
|
|
GraphLayout layout,
|
|
GraphRouting routing,
|
|
GraphCanvasStyle style,
|
|
) {
|
|
final nodesByKey = <String, GraphNode>{
|
|
for (final node in nodes) node.key: node,
|
|
};
|
|
final size = Size(routing.width, routing.height);
|
|
return Column(
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
Expanded(
|
|
child: InteractiveViewer(
|
|
constrained: false,
|
|
minScale: 0.3,
|
|
maxScale: 3,
|
|
child: SizedBox.fromSize(
|
|
size: size,
|
|
child: Stack(
|
|
clipBehavior: Clip.none,
|
|
children: [
|
|
// The passive layer comes first so every edge paints behind
|
|
// the native nodes and labels without taking their input.
|
|
Positioned.fill(
|
|
child: GraphEdgeLayer(
|
|
routes: routing.routes,
|
|
canvasSize: size,
|
|
color: 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: GraphStageNode(
|
|
node: nodesByKey[box.key]!,
|
|
selected: box.key == widget.selectedStage,
|
|
onSelected: widget.onSelected,
|
|
),
|
|
),
|
|
for (final label in routing.labels)
|
|
Positioned(
|
|
left: label.x,
|
|
top: label.y,
|
|
child: Text(
|
|
routing.routeFor(label.edgeId)!.label,
|
|
style: style.labelStyle,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
),
|
|
if (routing.skipped.isNotEmpty)
|
|
Flexible(
|
|
child: SingleChildScrollView(
|
|
child: _message(
|
|
[
|
|
for (final diagnostic in routing.skipped)
|
|
'${diagnostic.source} → ${diagnostic.outcome}: '
|
|
'${diagnostic.message}',
|
|
].join('\n'),
|
|
style,
|
|
),
|
|
),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
}
|