Files
pipelines/app/lib/ui/adaptive/segmented_bar.dart
T
alan a40a6e2e1c Narrow list panes: readable bar title, More overflow menu, rows keep status and actions
The floating bar keeps the title at its own width (up to half the bar) and
moves overflowable actions into one More menu instead of squeezing them
below their touch targets. List rows keep their leading status avatar and
More actions at any list-pane width; the time moves under the subtitle.
2026-11-03 18:04:10 +00:00

556 lines
20 KiB
Dart

import 'dart:math' as math;
import 'package:flutter/cupertino.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'pop_entrance.dart';
import 'segmented_action_row.dart';
import 'segmented_bar_entrance.dart';
import 'segmented_bar_overflow.dart';
import 'segmented_bar_motion.dart';
import 'segmented_bar_pieces.dart';
export 'segmented_bar_overflow.dart'
show
SegmentedMenuChoice,
SegmentedOverflowAction,
SegmentedOverflowEntry,
SegmentedOverflowable,
segmentedMoreKey;
export 'segmented_bar_pieces.dart' show SegmentedBackButton, SegmentedPill;
/// The app's top bar: separate frosted-glass pieces floating over the page's
/// content, on a scrim of the page's background that fades out downwards.
///
/// From the leading edge: a round piece holding [leading] (the platform's
/// Back, implied as the stock bars do when [automaticallyImplyLeading]), a
/// pill with the [title] and an optional one-line [subtitle] that runs
/// [onTitlePressed] when given, and a pill holding the [actions] at the
/// trailing edge. The title keeps its own width (up to [maxTitleShare] of the
/// bar, and never under [minTitleShare]); the actions take their natural
/// width beside it, and those that do not fit move into one More menu
/// (when they are [SegmentedOverflowable]) rather than shrink below their
/// touch targets. Only actions that cannot move ellipsise the first of them.
///
/// A page whose bar is mainly an input (Search) passes [titleWidget] instead:
/// it takes the title pill's place as one pill that fills the space beside
/// the leading piece (up to the widget's own width cap), with no title.
///
/// Only the pieces take taps: a tap between them reaches the content behind.
/// It works as a [Scaffold.appBar] (with `extendBodyBehindAppBar`) and a
/// [CupertinoPageScaffold.navigationBar], which inset the content by the
/// bar's height through [MediaQuery.paddingOf], so a page keeps its
/// scaffold's structure; [SegmentedBarOverlay] does the same anywhere else.
/// It handles the top safe area itself.
class SegmentedBar extends StatefulWidget
implements ObstructingPreferredSizeWidget {
const SegmentedBar({
super.key,
required this.cupertino,
required this.title,
this.titleWidget,
this.titleWidgetMaxWidth = double.infinity,
this.leading,
this.automaticallyImplyLeading = true,
this.subtitle,
this.subtitleIcon,
this.onTitlePressed,
this.expandableTitle = false,
this.titleAction,
this.titleSemanticLabel,
this.titleKey,
this.actions = const [],
this.actionsKey,
this.backgroundColor,
this.pillColor,
this.foregroundColor,
this.bottomPadding = 8,
this.backdrop,
});
/// Which control family to draw. Required because the bar's reserved
/// height differs: a Cupertino navigation bar never scales its text, so it
/// reserves exactly its height, while a Material app bar grows with text.
final bool cupertino;
/// The title; empty shows no title pill unless there is a [subtitle].
final String title;
/// The bar's main pill when it is not a title: a search field and its
/// filters. It replaces the title pill (so [title], [subtitle] and
/// [onTitlePressed] are not drawn) and fills the width beside the leading
/// piece and any [actions], up to [titleWidgetMaxWidth].
final Widget? titleWidget;
/// The widest the [titleWidget] pill grows on a wide window; it starts at
/// the leading edge, so content below can line up with it.
final double titleWidgetMaxWidth;
/// The leading control, normally a [SegmentedBackButton].
final Widget? leading;
/// Whether to show the platform's Back (or close, on a full-screen dialog)
/// when [leading] is null and the route can go back.
final bool automaticallyImplyLeading;
final String? subtitle;
final IconData? subtitleIcon;
/// Makes the title pill a button (an information page, a picker).
final VoidCallback? onTitlePressed;
/// Lets the title expand over the content without changing bar clearance.
final bool expandableTitle;
/// An action shown inside the expanded title pill.
final Widget? titleAction;
final String? titleSemanticLabel;
/// The key of the title's button (or its content when not pressable).
final Key? titleKey;
/// The bar's actions, at the trailing edge in one pill; each pops in on
/// its own (see [SegmentedEntrancePlanner]).
final List<Widget> actions;
/// Who supplies [actions] (a shell's open screen): when it changes, every
/// action is new and pops in, though one has the same key as before.
final Object? actionsKey;
/// The bar's backdrop; defaults to the enclosing scaffold's background.
final Color? backgroundColor;
/// The pieces' fill; defaults to the host's raised surface role.
final Color? pillColor;
/// The title's color, for a bar over a dark backdrop.
final Color? foregroundColor;
/// Space between the pieces and the content below.
final double bottomPadding;
/// Painted over the scrim and under the pieces, filling the bar from its
/// top edge (a page's own tint, such as a chat's colour). It takes no taps.
final Widget? backdrop;
static const double _topPadding = 8;
/// The share of the bar the title always keeps beside the actions.
static const double minTitleShare = 0.25;
/// The most of the bar the title's own width claims before the actions:
/// a short title (a destination's name) shows whole, a long one leaves
/// the actions room.
static const double maxTitleShare = 0.5;
/// Bar text grows with the reader's setting up to this factor, like the
/// stock app bar caps its title, so the bar never takes over the page.
static const double maxTextScale = 2;
@override
Size get preferredSize {
final piece = segmentedPieceHeight(cupertino);
if (cupertino) {
// CupertinoPageScaffold disables text scaling for its navigation bar
// and reserves exactly this height for it.
return Size.fromHeight(_topPadding + piece + bottomPadding);
}
// A Material scaffold only caps its app bar at this height and lets it
// size to its content: room for a title and subtitle at the largest
// text scale.
return Size.fromHeight(_topPadding + piece * maxTextScale + bottomPadding);
}
@override
// Content scrolls behind the bar; the scaffold insets it by the bar's
// height through the media padding instead.
bool shouldFullyObstruct(BuildContext context) => false;
Color _background(BuildContext context) {
if (backgroundColor case final color?) {
// A dynamic system colour (the grouped background) follows the theme.
return CupertinoDynamicColor.maybeResolve(color, context) ?? color;
}
if (cupertino) {
return context
.dependOnInheritedWidgetOfExactType<
CupertinoPageScaffoldBackgroundColor
>()
?.color ??
CupertinoTheme.of(context).scaffoldBackgroundColor;
}
return Scaffold.maybeOf(context)?.widget.backgroundColor ??
Theme.of(context).scaffoldBackgroundColor;
}
@override
State<SegmentedBar> createState() => _SegmentedBarState();
}
class _SegmentedBarState extends State<SegmentedBar> {
bool _expanded = false;
/// The expanded title is drawn in the overlay, anchored to the collapsed
/// pill: drawn inside the bar it would overflow the bar's bounds, where
/// its pipeline action could be seen but not tapped.
final _titleLink = LayerLink();
final _expandedTitle = OverlayPortalController();
/// The row's pieces sit side by side, so they share one read of the
/// content behind them. The expanded title overlaps the content below the
/// bar and is drawn later, in the overlay, so it reads its own.
final _piecesBackdrop = BackdropKey();
final _expandedTitleBackdrop = BackdropKey();
/// When each piece pops in: in turn from the leading edge on the bar's
/// first frame, at once (or in turn with those arriving together) later.
final _entrances = SegmentedEntrancePlanner();
@override
void initState() {
super.initState();
WidgetsBinding.instance.addPostFrameCallback((_) => _entrances.markShown());
}
@override
void didUpdateWidget(covariant SegmentedBar oldWidget) {
super.didUpdateWidget(oldWidget);
if (oldWidget.title != widget.title ||
oldWidget.subtitle != widget.subtitle) {
_expanded = false;
}
}
void _toggleTitle() {
// The portal stays attached once used and draws nothing while
// collapsed, so collapsing on a new run (during a rebuild) needs no
// overlay call.
if (!_expandedTitle.isShowing) _expandedTitle.show();
setState(() => _expanded = !_expanded);
}
/// The bar's main pill: the [SegmentedBar.titleWidget] filling the row, or
/// the title pill (drawn expanded in the overlay when it is expandable).
Widget _titleIsland(
BuildContext context,
Widget Function(bool expanded) titlePill,
) {
final titleWidget = widget.titleWidget;
if (titleWidget != null) {
// The main pill fills the row, up to its cap.
return ConstrainedBox(
constraints: BoxConstraints(maxWidth: widget.titleWidgetMaxWidth),
child: SegmentedPill(
cupertino: widget.cupertino,
fill: widget.pillColor,
child: SizedBox(width: double.infinity, child: titleWidget),
),
);
}
if (!widget.expandableTitle) return titlePill(false);
return LayoutBuilder(
builder: (context, titleSpace) => OverlayPortal(
controller: _expandedTitle,
overlayChildBuilder: (context) => !(_expanded && widget.expandableTitle)
? const SizedBox.shrink()
: Positioned(
top: 0,
left: 0,
child: CompositedTransformFollower(
link: _titleLink,
showWhenUnlinked: false,
child: ConstrainedBox(
constraints: BoxConstraints(maxWidth: titleSpace.maxWidth),
child: BackdropGroup(
backdropKey: _expandedTitleBackdrop,
child: titlePill(true),
),
),
),
),
child: CompositedTransformTarget(
link: _titleLink,
child: ExcludeSemantics(
excluding: _expanded && widget.expandableTitle,
child: titlePill(false),
),
),
),
);
}
/// Which actions (by identity) a narrow bar moved into its More menu.
Set<Object> _overflowed = const {};
void _hidden(List<Object> ids, List<int> indexes) {
if (!mounted) return;
final next = {
for (final index in indexes)
if (index < ids.length) ids[index],
};
if (setEquals(next, _overflowed)) return;
setState(() => _overflowed = next);
}
/// The actions, each keyed by its identity ([segmentedActionIds]) so one
/// arriving or leaving leaves the others be, each popping in on its own,
/// at its natural width. Those that do not fit leave for the trailing More
/// button ([SegmentedActionRow]), so none is squeezed below its touch
/// target; one moved there is out of the focus order too.
Widget _actionRow(
List<Widget> actions,
List<Object> ids,
List<SegmentedActionEntrance> entrances, {
required bool cupertino,
required double overflowWidth,
}) {
final entries = [
for (final (index, action) in actions.indexed)
if (action is SegmentedOverflowable && _overflowed.contains(ids[index]))
(action as SegmentedOverflowable).overflowEntry,
];
return SegmentedActionRow(
overflowable: [
for (final action in actions) action is SegmentedOverflowable,
],
overflowWidth: overflowWidth,
onHidden: (indexes) => _hidden(ids, indexes),
more: ExcludeFocus(
excluding: entries.isEmpty,
child: SegmentedPress(
cupertino: cupertino,
tint: widget.foregroundColor,
child: SegmentedMoreButton(cupertino: cupertino, entries: entries),
),
),
actions: [
for (final (index, action) in actions.indexed)
ExcludeFocus(
key: ValueKey(ids[index]),
excluding: _overflowed.contains(ids[index]),
child: PopEntrance(
play: entrances[index].play,
delay: entrances[index].delay,
glass: false,
child: SegmentedPress(
cupertino: cupertino,
tint: widget.foregroundColor,
enabled: actions.length > 1,
child: action,
),
),
),
],
);
}
@override
Widget build(BuildContext context) {
final cupertino = widget.cupertino;
final title = widget.title;
final titleWidget = widget.titleWidget;
final leadingWidget = widget.leading;
final automaticallyImplyLeading = widget.automaticallyImplyLeading;
final subtitle = widget.subtitle;
final subtitleIcon = widget.subtitleIcon;
final onTitlePressed = widget.onTitlePressed;
final titleSemanticLabel = widget.titleSemanticLabel;
final titleKey = widget.titleKey;
final actions = widget.actions;
final pillColor = widget.pillColor;
final foregroundColor = widget.foregroundColor;
final bottomPadding = widget.bottomPadding;
final leading =
leadingWidget ??
(automaticallyImplyLeading
? impliedSegmentedLeading(context, cupertino)
: null);
final showTitle = title.isNotEmpty || (subtitle ?? '').isNotEmpty;
Widget titlePill(bool expanded) => SegmentedTitlePill(
cupertino: cupertino,
title: title,
subtitle: subtitle,
subtitleIcon: subtitleIcon,
onPressed: widget.expandableTitle ? _toggleTitle : onTitlePressed,
semanticLabel: widget.expandableTitle
? '${titleSemanticLabel ?? title}, ${expanded ? 'expanded' : 'collapsed'}'
: titleSemanticLabel,
buttonKey: expanded ? null : titleKey,
expanded: expanded,
titleAction: expanded ? widget.titleAction : null,
foreground: foregroundColor,
fill: pillColor,
);
// Each island is keyed by its role (and each action by its identity), so
// it keeps its entrance (and plays none) while the bar rebuilds around
// it.
final hasTitle = titleWidget != null || showTitle;
final actionIds = segmentedActionIds(actions, widget.actionsKey);
final entrances = _entrances.plan(
leading: leading != null,
title: hasTitle,
actionIds: actionIds,
);
final Widget bar = LayoutBuilder(
builder: (context, constraints) {
// The actions keep to the trailing edge at their natural width, so
// a model name shows whole while the title has room. The title keeps
// at least [SegmentedBar.minTitleShare] of the bar, and its own
// width (a destination's name) up to [SegmentedBar.maxTitleShare];
// actions that do not fit beside it move into the More menu.
final width = constraints.maxWidth;
final titleMinimum = titleWidget != null || !showTitle
? width * SegmentedBar.minTitleShare
: math.max(
width * SegmentedBar.minTitleShare,
math.min(
segmentedTitleWidth(
context,
cupertino: cupertino,
title: title,
subtitle: subtitle,
subtitleIcon: subtitleIcon,
foreground: foregroundColor,
),
width * SegmentedBar.maxTitleShare,
),
);
final besideTitle =
width -
(leading == null ? 0 : segmentedPieceHeight(cupertino) + 8) -
8;
// Actions that cannot move (a model picker) may take the room down
// to the title's minimum share; the rest leave for the More menu
// before the title goes under its own width.
final actionsMaxWidth = math.max(
0.0,
besideTitle - width * SegmentedBar.minTitleShare,
);
final overflowWidth = math.max(0.0, besideTitle - titleMinimum);
return Row(
children: [
if (leading != null) ...[
PopEntrance(
key: const ValueKey('segmented.leading'),
delay: entrances.leading,
child: SegmentedPress(
cupertino: cupertino,
tint: foregroundColor,
child: SegmentedPill(
cupertino: cupertino,
fill: pillColor,
child: leading,
),
),
),
const SizedBox(width: 8),
],
Expanded(
// Only as tall as the title: a Material scaffold offers its app
// bar more height than it needs.
child: Align(
alignment: AlignmentDirectional.centerStart,
heightFactor: 1,
child: !hasTitle
? const SizedBox.shrink()
: PopEntrance(
key: ValueKey(
titleWidget != null
? 'segmented.field'
: 'segmented.title',
),
delay: entrances.title,
child: _titleIsland(context, titlePill),
),
),
),
if (actions.isNotEmpty) ...[
const SizedBox(width: 8),
ConstrainedBox(
constraints: BoxConstraints(maxWidth: actionsMaxWidth),
child: PopEntrance(
key: const ValueKey('segmented.actions'),
delay: entrances.pill,
// A lone action is the whole pill, so the pill sinks when it
// is pressed; beside others, each action sinks on its own.
child: SegmentedPress(
cupertino: cupertino,
tint: foregroundColor,
enabled: actions.length == 1,
child: SegmentedPill(
cupertino: cupertino,
fill: pillColor,
child: _actionRow(
actions,
actionIds,
entrances.actions,
cupertino: cupertino,
overflowWidth: overflowWidth,
),
),
),
),
),
],
],
);
},
);
final background = widget._background(context);
final inset = MediaQuery.paddingOf(context).top;
return Stack(
children: [
// The scrim: the page's background, opaque at the edge and fading out
// towards the content, so content scrolled behind the pieces still
// reads. It takes no taps; only the pieces do.
Positioned.fill(
child: IgnorePointer(
child: Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
SizedBox(
height: inset,
child: ColoredBox(color: background),
),
Expanded(
child: DecoratedBox(
decoration: BoxDecoration(
gradient: LinearGradient(
begin: Alignment.topCenter,
end: Alignment.bottomCenter,
colors: [
background,
background.withValues(alpha: background.a * 0.95),
background.withValues(alpha: 0),
],
stops: const [0, 0.5, 1],
),
),
),
),
],
),
),
),
if (widget.backdrop case final backdrop?)
Positioned.fill(child: IgnorePointer(child: backdrop)),
SafeArea(
bottom: false,
child: Padding(
padding: EdgeInsetsDirectional.fromSTEB(
12,
SegmentedBar._topPadding,
12,
bottomPadding,
),
child: MediaQuery.withClampedTextScaling(
maxScaleFactor: SegmentedBar.maxTextScale,
child: BackdropGroup(backdropKey: _piecesBackdrop, child: bar),
),
),
),
],
);
}
}