168 lines
4.6 KiB
Dart
168 lines
4.6 KiB
Dart
import 'package:flutter/widgets.dart';
|
|
|
|
/// Short, quiet motion shared by the app: opening and closing sections,
|
|
/// counts and statuses changing, live items arriving. Every duration drops
|
|
/// to zero when the system asks for reduced motion.
|
|
abstract final class Motion {
|
|
/// A count, an icon or a status swapping in place.
|
|
static const Duration quick = Duration(milliseconds: 150);
|
|
|
|
/// A section opening or closing, a bar changing its actions.
|
|
static const Duration standard = Duration(milliseconds: 200);
|
|
|
|
static const Curve curve = Curves.easeOutCubic;
|
|
|
|
/// [duration], or zero under the system's reduce-motion setting.
|
|
static Duration of(BuildContext context, Duration duration) =>
|
|
MediaQuery.maybeDisableAnimationsOf(context) ?? false
|
|
? Duration.zero
|
|
: duration;
|
|
}
|
|
|
|
/// Swaps [child] with a short cross-fade whenever its key changes.
|
|
class MotionSwitcher extends StatelessWidget {
|
|
const MotionSwitcher({
|
|
super.key,
|
|
required this.child,
|
|
this.duration = Motion.quick,
|
|
this.scale = false,
|
|
});
|
|
|
|
final Widget child;
|
|
final Duration duration;
|
|
|
|
/// Also grows the incoming child from 80%: for badges and pills.
|
|
final bool scale;
|
|
|
|
@override
|
|
Widget build(BuildContext context) => AnimatedSwitcher(
|
|
duration: Motion.of(context, duration),
|
|
switchInCurve: Motion.curve,
|
|
switchOutCurve: Motion.curve,
|
|
transitionBuilder: (child, animation) {
|
|
final faded = FadeTransition(opacity: animation, child: child);
|
|
if (!scale) return faded;
|
|
return ScaleTransition(
|
|
scale: Tween<double>(begin: 0.8, end: 1).animate(animation),
|
|
child: faded,
|
|
);
|
|
},
|
|
child: child,
|
|
);
|
|
}
|
|
|
|
/// Names the items of a live list, so items that arrive after the first load
|
|
/// can enter with a short fade and slide while the first load and items
|
|
/// scrolled into view appear at once.
|
|
class ArrivalScope extends StatefulWidget {
|
|
const ArrivalScope({super.key, required this.ids, required this.child});
|
|
|
|
/// Every item currently in the list, built or not.
|
|
final Iterable<Object> ids;
|
|
final Widget child;
|
|
|
|
@override
|
|
State<ArrivalScope> createState() => _ArrivalScopeState();
|
|
}
|
|
|
|
class _ArrivalScopeState extends State<ArrivalScope> {
|
|
final Set<Object> _known = {};
|
|
final Set<Object> _fresh = {};
|
|
bool _primed = false;
|
|
|
|
void _absorb() {
|
|
final ids = widget.ids.toList();
|
|
if (!_primed) {
|
|
// The first non-empty list is the starting point, not an arrival.
|
|
if (ids.isEmpty) return;
|
|
_known.addAll(ids);
|
|
_primed = true;
|
|
return;
|
|
}
|
|
for (final id in ids) {
|
|
if (_known.add(id)) _fresh.add(id);
|
|
}
|
|
}
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_absorb();
|
|
}
|
|
|
|
@override
|
|
void didUpdateWidget(ArrivalScope oldWidget) {
|
|
super.didUpdateWidget(oldWidget);
|
|
_absorb();
|
|
}
|
|
|
|
/// True once for an item that arrived after the first load.
|
|
bool _claim(Object id) => _fresh.remove(id);
|
|
|
|
@override
|
|
Widget build(BuildContext context) =>
|
|
_ArrivalData(state: this, child: widget.child);
|
|
}
|
|
|
|
class _ArrivalData extends InheritedWidget {
|
|
const _ArrivalData({required this.state, required super.child});
|
|
|
|
final _ArrivalScopeState state;
|
|
|
|
@override
|
|
bool updateShouldNotify(_ArrivalData oldWidget) => false;
|
|
}
|
|
|
|
/// One item of an [ArrivalScope]: fades and slides in when it is new.
|
|
class Arrival extends StatefulWidget {
|
|
const Arrival({super.key, required this.id, required this.child});
|
|
|
|
final Object id;
|
|
final Widget child;
|
|
|
|
@override
|
|
State<Arrival> createState() => _ArrivalState();
|
|
}
|
|
|
|
class _ArrivalState extends State<Arrival> with SingleTickerProviderStateMixin {
|
|
AnimationController? _controller;
|
|
|
|
@override
|
|
void didChangeDependencies() {
|
|
super.didChangeDependencies();
|
|
if (_controller != null) return;
|
|
final scope = context.getInheritedWidgetOfExactType<_ArrivalData>()?.state;
|
|
final duration = Motion.of(context, Motion.standard);
|
|
if (scope == null ||
|
|
duration == Duration.zero ||
|
|
!scope._claim(widget.id)) {
|
|
return;
|
|
}
|
|
_controller = AnimationController(vsync: this, duration: duration)
|
|
..forward();
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_controller?.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final controller = _controller;
|
|
if (controller == null) return widget.child;
|
|
final curved = CurvedAnimation(parent: controller, curve: Motion.curve);
|
|
return FadeTransition(
|
|
opacity: curved,
|
|
child: SlideTransition(
|
|
position: Tween<Offset>(
|
|
begin: const Offset(0, 0.15),
|
|
end: Offset.zero,
|
|
).animate(curved),
|
|
child: widget.child,
|
|
),
|
|
);
|
|
}
|
|
}
|