Files
pipelines/app/lib/ui/adaptive/floating_destination_bar.dart
T
alan 40e94cc3da Shell: on wide split layouts the destination tabs sit under the list pane
The four destination buttons move from the bottom right over the detail
pane to the bottom of the list pane, centred in the (dragged) list width.
The list now keeps the bar's height as bottom clearance; the detail pane
clears only the system inset, so its tabs, the chat composer and the
artifact actions sit at its bottom edge. Phone layout is unchanged.
kStackedBarGap is gone with the stacked bars.
2026-11-03 12:30:56 +00:00

283 lines
10 KiB
Dart

import 'dart:math' as math;
import 'dart:ui' show SemanticsRole;
import 'package:flutter/widgets.dart';
import '../motion/motion.dart';
import 'floating_bar_layout.dart';
import 'floating_tab_button.dart';
import 'floating_tab_motion.dart';
/// A tab bar which floats above the bottom edge as a row of separate round
/// frosted [GlassPill] buttons, one per tab, instead of a full-width system
/// bar. Used for the app's destinations and for every page's own tabs.
///
/// The row is only as wide as its buttons and sits at the trailing (right,
/// in left-to-right text) edge, near the thumb, keeping [kFloatingBarMargin]
/// from the sides and above the bottom safe area. Only the buttons take
/// taps: the gaps between and beside them reach the content behind. A row
/// squeezed below its natural width narrows its gaps, then scales down.
///
/// The selected button is filled with the host's selection tint, which
/// cross-fades when the selection moves, and its icon bounces briefly. Each
/// button pops in on its own, staggered, when the bar appears or its set of
/// tabs changes, never when only the selection does.
///
/// The buttons show icons only. Each tab's label stays its accessible name
/// (and the Material tooltip), announced as a selectable tab with "tab n of
/// m" the way the platform navigation controls announce theirs (see
/// [FloatingTabButton]); the icons must be distinct within a bar. The
/// Cupertino path builds no Material widget.
class FloatingDestinationBar extends StatefulWidget {
const FloatingDestinationBar({
super.key,
required this.cupertino,
required this.currentIndex,
required this.onTap,
required this.items,
this.edge = FloatingBarEdge.bottom,
this.alignment,
});
final bool cupertino;
/// Where the row sits in the width it is given, at [FloatingBarEdge.bottom]:
/// the trailing end by default. The shell centres its tabs under the list
/// pane while a list shows beside an open item.
final AlignmentGeometry? alignment;
/// The edge the bar floats at. At [FloatingBarEdge.top] (an open item's
/// tabs under its pane's top bar) the bar sits at the leading edge, in line
/// with the bar's title, and keeps no bottom safe area.
final FloatingBarEdge edge;
final int currentIndex;
final ValueChanged<int> onTap;
final List<FloatingDestinationItem> items;
/// The icon size inside each button, as in the host navigation controls.
static const double materialIconSize = 28;
static const double cupertinoIconSize = 30;
/// The diameter of each tab button, which is also the bar's height.
static const double materialButtonSize = 52;
static const double cupertinoButtonSize = 50;
/// The gap between neighbouring buttons.
static const double materialButtonGap = 12;
static const double cupertinoButtonGap = 10;
/// The side margin at [FloatingBarEdge.top], matching the top bar's own.
static const double topMargin = 12;
/// The row of buttons inside each bar, for tests and measurement.
static const Key rowKey = ValueKey('floating-destination-bar.row');
static double buttonSize({required bool cupertino}) =>
cupertino ? cupertinoButtonSize : materialButtonSize;
static double buttonGap({required bool cupertino}) =>
cupertino ? cupertinoButtonGap : materialButtonGap;
/// The selected button's size, about [Motion.tabSelectedScale] times the
/// others (whole pixels, so layout stays exact).
static const double materialSelectedButtonSize = 62;
static const double cupertinoSelectedButtonSize = 60;
static double selectedButtonSize({required bool cupertino}) =>
cupertino ? cupertinoSelectedButtonSize : materialSelectedButtonSize;
/// The width of a row of [tabs] buttons (one of them selected), when the
/// space allows it.
static double rowWidth({required bool cupertino, required int tabs}) =>
tabs == 0
? 0
: buttonSize(cupertino: cupertino) * (tabs - 1) +
selectedButtonSize(cupertino: cupertino) +
buttonGap(cupertino: cupertino) * math.max(0, tabs - 1);
@override
State<FloatingDestinationBar> createState() => _FloatingDestinationBarState();
}
class _FloatingDestinationBarState extends State<FloatingDestinationBar>
with TickerProviderStateMixin {
late final FloatingTabMotion _motion = FloatingTabMotion(this);
final _backdrop = BackdropKey();
bool _entered = false;
bool get cupertino => widget.cupertino;
List<FloatingDestinationItem> get items => widget.items;
int get currentIndex => widget.currentIndex;
@override
void didChangeDependencies() {
super.didChangeDependencies();
if (_entered) return;
_entered = true;
_motion.enter(context, count: items.length, selected: currentIndex);
}
@override
void didUpdateWidget(FloatingDestinationBar oldWidget) {
super.didUpdateWidget(oldWidget);
if (_tabSetIdentity(oldWidget.items) != _tabSetIdentity(items)) {
// New tabs (a run's page tabs appearing): they pop in.
_motion.enter(context, count: items.length, selected: currentIndex);
} else if (oldWidget.currentIndex != currentIndex) {
_motion.select(context, currentIndex);
}
}
@override
void dispose() {
_motion.dispose();
super.dispose();
}
static String _tabSetIdentity(List<FloatingDestinationItem> items) =>
items.map((item) => '${item.key ?? item.label}:${item.label}').join('|');
double get _size => FloatingDestinationBar.buttonSize(cupertino: cupertino);
double get _selectedSize =>
FloatingDestinationBar.selectedButtonSize(cupertino: cupertino);
/// The buttons' natural width side by side, the selected one larger.
double get _buttonsWidth =>
items.isEmpty ? 0 : _size * (items.length - 1) + _selectedSize;
@override
Widget build(BuildContext context) {
final top = widget.edge == FloatingBarEdge.top;
final bar = LayoutBuilder(
builder: (context, constraints) => Align(
// As tall as the row, so a scaffold or overlay measures the bar and
// not the whole area it may grow into.
heightFactor: 1,
alignment: top
? AlignmentDirectional.topStart
: widget.alignment ?? AlignmentDirectional.bottomEnd,
child: _row(context, constraints.maxWidth),
),
);
if (top) {
// Under a top bar: no safe area to keep clear of, only the gap to the
// content below.
return Padding(
padding: const EdgeInsets.fromLTRB(
FloatingDestinationBar.topMargin,
0,
FloatingDestinationBar.topMargin,
8,
),
child: bar,
);
}
return SafeArea(
top: false,
minimum: const EdgeInsets.fromLTRB(
kFloatingBarMargin,
0,
kFloatingBarMargin,
kFloatingBarMargin,
),
child: bar,
);
}
/// The gap between neighbouring buttons in [width]: the named one, or less
/// in a row squeezed below its natural width.
double _gap(double width) {
final gap = FloatingDestinationBar.buttonGap(cupertino: cupertino);
final count = items.length;
if (count < 2 || !width.isFinite) return gap;
return (width - _buttonsWidth).clamp(0.0, gap * (count - 1)) / (count - 1);
}
Widget _row(BuildContext context, double width) {
final gap = _gap(width);
// As tall as the selected (largest) button; the others are centred on
// it, and every gap stays the same while a button grows or shrinks.
Widget row = Row(
key: FloatingDestinationBar.rowKey,
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.center,
children: [
for (var index = 0; index < items.length; index += 1) ...[
if (index > 0) SizedBox(width: gap),
_button(context, index),
],
],
);
// Narrower than the buttons themselves: the whole row shrinks.
if (width.isFinite && width < _buttonsWidth) {
row = SizedBox(
width: math.max(0.0, width),
height: _selectedSize,
child: FittedBox(fit: BoxFit.scaleDown, child: row),
);
}
// One tab bar, its buttons the tabs. The buttons share one read of the
// content behind them for their blurs where the engine supports it.
row = Semantics(
role: SemanticsRole.tabBar,
container: true,
explicitChildNodes: true,
child: BackdropGroup(backdropKey: _backdrop, child: row),
);
// The bar does not scale with text (its icons do not either); a badge
// count keeps its size.
return cupertino ? MediaQuery.withNoTextScaling(child: row) : row;
}
Widget _button(BuildContext context, int index) {
final item = items[index];
final selected = index == currentIndex;
final iconSize = cupertino
? FloatingDestinationBar.cupertinoIconSize
: FloatingDestinationBar.materialIconSize;
// The selected button grows (and a deselected one shrinks back) in the
// layout, so its neighbours move over and keep their gaps.
return FloatingTabEntrance(
motion: _motion,
index: index,
child: TweenAnimationBuilder<double>(
tween: Tween(end: selected ? _selectedSize : _size),
duration: Motion.of(context, Motion.tabSelectDuration),
curve: Motion.curve,
builder: (context, size, _) => FloatingTabButton(
key: item.key,
cupertino: cupertino,
motion: _motion,
index: index,
count: items.length,
selected: selected,
size: size,
iconSize: iconSize * size / _size,
label: item.label,
icon: selected ? item.selectedIcon ?? item.icon : item.icon,
onTap: () => widget.onTap(index),
),
),
);
}
}
/// The platform-neutral data needed by [FloatingDestinationBar].
class FloatingDestinationItem {
const FloatingDestinationItem({
required this.icon,
required this.label,
this.selectedIcon,
this.key,
});
final Widget icon;
/// The tab's accessible name (and Material tooltip); not drawn.
final String label;
final Widget? selectedIcon;
/// Identifies the whole tab, for tests and automation.
final Key? key;
}