Files
pipelines/app/lib/ui/layout/sliver_reveal.dart
T
alan 7b1455631b Rebuild only changed list rows and lay out big artifact sections lazily
Runs and chat session rows are memoized on their own data (MemoSubtree), so
a run event or a chat's running change rebuilds one row instead of every
built row. The artifact gallery's open sections are lazy slivers revealed
by a sliver open/close animation, and thumbnails decode at display size.
Benches in test/perf measure both.
2026-11-02 00:08:29 +00:00

153 lines
4.0 KiB
Dart

import 'dart:math' as math;
import 'package:flutter/rendering.dart';
import 'package:flutter/widgets.dart';
/// Opens and closes a sliver by growing or shrinking it from its top, the
/// sliver counterpart of a clipped `AnimatedSize` with top alignment. The
/// sliver stays lazy: only its visible part is built and laid out, however
/// long it is. Closed, it takes no space and builds nothing.
class SliverReveal extends StatefulWidget {
const SliverReveal({
super.key,
required this.open,
required this.duration,
required this.curve,
required this.sliver,
});
final bool open;
final Duration duration;
final Curve curve;
final Widget sliver;
@override
State<SliverReveal> createState() => _SliverRevealState();
}
class _SliverRevealState extends State<SliverReveal>
with SingleTickerProviderStateMixin {
late final AnimationController _controller = AnimationController(
vsync: this,
duration: widget.duration,
value: widget.open ? 1 : 0,
);
@override
void didUpdateWidget(SliverReveal oldWidget) {
super.didUpdateWidget(oldWidget);
_controller.duration = widget.duration;
if (widget.open == oldWidget.open) return;
if (widget.duration == Duration.zero) {
_controller.value = widget.open ? 1 : 0;
} else if (widget.open) {
_controller.forward();
} else {
_controller.reverse();
}
}
@override
void dispose() {
_controller.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) => AnimatedBuilder(
animation: _controller,
builder: (context, sliver) {
if (_controller.isDismissed) return const SliverToBoxAdapter();
final value = _controller.value;
return _SliverExtentFactor(
factor: value >= 1 ? 1 : widget.curve.transform(value),
sliver: sliver,
);
},
child: widget.sliver,
);
}
class _SliverExtentFactor extends SingleChildRenderObjectWidget {
const _SliverExtentFactor({required this.factor, Widget? sliver})
: super(child: sliver);
final double factor;
@override
RenderObject createRenderObject(BuildContext context) =>
_RenderSliverExtentFactor(factor);
@override
void updateRenderObject(
BuildContext context,
_RenderSliverExtentFactor renderObject,
) => renderObject.factor = factor;
}
/// Lays its sliver out normally and reports [factor] of its extent, clipping
/// what lies beyond.
class _RenderSliverExtentFactor extends RenderProxySliver {
_RenderSliverExtentFactor(this._factor);
double _factor;
set factor(double value) {
if (value == _factor) return;
_factor = value;
markNeedsLayout();
}
bool get _clipped => _factor < 1;
@override
void performLayout() {
final child = this.child!;
child.layout(constraints, parentUsesSize: true);
final full = child.geometry!;
if (!_clipped || full.scrollOffsetCorrection != null) {
geometry = full;
return;
}
final extent = full.scrollExtent * _factor;
final paintExtent = math.min(
calculatePaintOffset(constraints, from: 0, to: extent),
full.paintExtent,
);
geometry = SliverGeometry(
scrollExtent: extent,
paintExtent: paintExtent,
layoutExtent: paintExtent,
maxPaintExtent: extent,
cacheExtent: calculateCacheOffset(constraints, from: 0, to: extent),
hasVisualOverflow: true,
);
}
@override
void paint(PaintingContext context, Offset offset) {
if (child == null || geometry!.paintExtent <= 0) return;
if (!_clipped) return super.paint(context, offset);
final extent = geometry!.paintExtent;
final cross = constraints.crossAxisExtent;
final clip = switch (constraints.axis) {
Axis.vertical => Rect.fromLTWH(0, 0, cross, extent),
Axis.horizontal => Rect.fromLTWH(0, 0, extent, cross),
};
_clip.layer = context.pushClipRect(
needsCompositing,
offset,
clip,
super.paint,
oldLayer: _clip.layer,
);
}
final _clip = LayerHandle<ClipRectLayer>();
@override
void dispose() {
_clip.layer = null;
super.dispose();
}
}