7b1455631b
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.
153 lines
4.0 KiB
Dart
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();
|
|
}
|
|
}
|