Files
pipelines/app/lib/ui/adaptive/floating_tab_motion.dart
T
alan 377ff04aaf Show each floating tab as its own round glass button
Replace the single glass pill (host NavigationBar/CupertinoTabBar with one
gliding highlight) with a row of separate circular GlassPill buttons, 52/50 px
with 12/10 px gaps, at the same bottom-right place. The selected button fills
with the host selection tint and cross-fades; each button pops in on its own,
staggered, only when the bar appears or its tabs change; presses sink like the
top bar's. Tab semantics, keys, tooltips and badges are kept; the row shares
one BackdropGroup for its blurs.
2026-11-02 18:43:05 +00:00

181 lines
5.5 KiB
Dart

import 'dart:math' as math;
import 'package:flutter/widgets.dart';
import '../motion/motion.dart';
import 'glass_pill.dart';
/// The animations of one floating tab bar: its tab buttons popping in one
/// after another, and the newly selected icon's bounce.
///
/// They live with the bar, not with each button, so a button rebuilt with a
/// new selection (or a new badge) never restarts its entrance: only the bar
/// decides when its tabs enter.
class FloatingTabMotion {
FloatingTabMotion(TickerProvider vsync)
: entrance = AnimationController(vsync: vsync),
bounce = AnimationController(
vsync: vsync,
duration: Motion.tabBounceDuration,
value: 1,
);
/// Drives every tab's entrance; tab n plays its pop in its own window.
final AnimationController entrance;
final AnimationController bounce;
int _count = 0;
final List<({Animation<double> pop, Animation<double> opacity})> _entrances =
[];
int _selected = 0;
/// Plays the entrance of a bar of [count] tabs, from the start, with
/// [selected] chosen and nothing bouncing.
void enter(
BuildContext context, {
required int count,
required int selected,
}) {
_count = count;
final duration = Motion.of(context, Motion.tabEntranceDuration);
entrance.duration =
duration + Motion.tabEntranceStagger * math.max(0, count - 1);
if (duration == Duration.zero) {
entrance.value = 1;
} else {
entrance.forward(from: 0);
}
_splitEntrance();
_selected = selected;
bounce.value = 1;
}
/// Bounces the newly [selected] tab's icon; nothing moves under reduced
/// motion.
void select(BuildContext context, int selected) {
if (selected == _selected) return;
_selected = selected;
if (Motion.of(context, Motion.tabBounceDuration) == Duration.zero) {
bounce.value = 1;
return;
}
bounce.forward(from: 0);
}
/// The scale of tab [index]'s icon: only the newly selected one bounces.
double scaleOf(int index) {
if (index != _selected || bounce.isCompleted) return 1;
final t = bounce.value;
final rise = t < 0.5 ? t * 2 : (1 - t) * 2;
return 1 + (Motion.tabBounceScale - 1) * Curves.easeOut.transform(rise);
}
/// Tab [index]'s share of [entrance]: its pop, then its fade.
({Animation<double> pop, Animation<double> opacity}) entranceOf(int index) =>
index >= 0 && index < _entrances.length
? _entrances[index]
: (pop: kAlwaysCompleteAnimation, opacity: kAlwaysCompleteAnimation);
/// Splits [entrance] into each tab's window, once per entrance.
void _splitEntrance() {
_disposeEntrances();
final total = entrance.duration!.inMicroseconds;
if (total == 0) return;
final window = Motion.tabEntranceDuration.inMicroseconds;
for (var index = 0; index < _count; index += 1) {
final start = Motion.tabEntranceStagger.inMicroseconds * index;
final begin = (start / total).clamp(0.0, 1.0);
final end = ((start + window) / total).clamp(begin, 1.0);
final faded =
((start + window * Motion.tabEntranceOpacityPortion) / total).clamp(
begin,
1.0,
);
_entrances.add((
pop: CurvedAnimation(
parent: entrance,
curve: Interval(begin, end, curve: Curves.easeOutBack),
),
opacity: CurvedAnimation(
parent: entrance,
curve: Interval(begin, faded, curve: Curves.easeOut),
),
));
}
}
void _disposeEntrances() {
for (final animations in _entrances) {
(animations.pop as CurvedAnimation).dispose();
(animations.opacity as CurvedAnimation).dispose();
}
_entrances.clear();
}
void dispose() {
_disposeEntrances();
entrance.dispose();
bounce.dispose();
}
}
/// Tab [index]'s whole button popping in with the bar: it grows from
/// [Motion.tabEntranceScaleBegin] with a gentle overshoot, rising a little,
/// while its glass fades in through a [GlassReveal] (so the blur fades with
/// the fill instead of snapping on at the end).
class FloatingTabEntrance extends StatelessWidget {
const FloatingTabEntrance({
super.key,
required this.motion,
required this.index,
required this.child,
});
final FloatingTabMotion motion;
final int index;
final Widget child;
@override
Widget build(BuildContext context) {
final entrance = motion.entranceOf(index);
return AnimatedBuilder(
animation: entrance.pop,
// The reveal keeps the tab (and its badge count) announced while it
// fades in.
child: GlassReveal(opacity: entrance.opacity, child: child),
builder: (context, child) {
final pop = entrance.pop.value;
final scale =
Motion.tabEntranceScaleBegin +
(1 - Motion.tabEntranceScaleBegin) * pop;
return Transform.translate(
offset: Offset(0, (1 - pop) * Motion.tabEntranceSlideDistance),
child: Transform.scale(scale: scale, child: child),
);
},
);
}
}
/// Tab [index]'s icon, bouncing briefly when it becomes selected.
class FloatingTabBounce extends StatelessWidget {
const FloatingTabBounce({
super.key,
required this.motion,
required this.index,
required this.child,
});
final FloatingTabMotion motion;
final int index;
final Widget child;
@override
Widget build(BuildContext context) => AnimatedBuilder(
animation: motion.bounce,
child: child,
builder: (context, child) =>
Transform.scale(scale: motion.scaleOf(index), child: child),
);
}