3b996bdbc7
Relative-time labels follow one wall-minute RelativeTimeClock instead of a timer per row, skip ticks while their tab is offstage and rebuild only when their text changes. The shell rebuilds its top bar only for the focused destination's published bar and its tab bar only for badge changes. Run events that repeat a row's state no longer notify, and the runs list filters and sorts once per build. Adds a rebuild/timer benchmark.
369 lines
13 KiB
Dart
369 lines
13 KiB
Dart
import '../ui/motion/motion.dart';
|
|
import '../ui/motion/fade_through_stack.dart';
|
|
import 'package:flutter/cupertino.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter/services.dart';
|
|
|
|
import '../ui/adaptive/segmented_bar.dart';
|
|
import '../ui/adaptive/floating_bar_layout.dart';
|
|
import '../ui/adaptive/floating_destination_bar.dart';
|
|
import 'attention_badge.dart';
|
|
import 'destination.dart';
|
|
import 'list_detail.dart';
|
|
import 'shell_bar.dart';
|
|
|
|
class AdaptiveShell extends StatefulWidget {
|
|
const AdaptiveShell({
|
|
super.key,
|
|
this.destinationBodies = const {},
|
|
this.cupertino = false,
|
|
this.destination,
|
|
this.onDestinationSelected,
|
|
this.onSearch,
|
|
this.attentionCount = 0,
|
|
});
|
|
|
|
final Map<AppDestination, WidgetBuilder> destinationBodies;
|
|
final bool cupertino;
|
|
|
|
/// The destination a route owner selected. When null the shell keeps its own
|
|
/// selection, which preserves the plain-shell tests and native composition.
|
|
final AppDestination? destination;
|
|
final ValueChanged<AppDestination>? onDestinationSelected;
|
|
|
|
/// Opens the transient Search page. Null hides the action, so the plain
|
|
/// shell tests and compositions without routing keep their tab set only.
|
|
final VoidCallback? onSearch;
|
|
|
|
/// Runs needing the operator today, mirrored on the Runs tab in every mount
|
|
/// so it stays visible from any destination. Zero shows no badge.
|
|
final int attentionCount;
|
|
|
|
@override
|
|
State<AdaptiveShell> createState() => _AdaptiveShellState();
|
|
}
|
|
|
|
class _AdaptiveShellState extends State<AdaptiveShell> {
|
|
late AppDestination _selected;
|
|
final Set<AppDestination> _visited = {};
|
|
final ShellBarRegistry _bar = ShellBarRegistry();
|
|
// Keeps every destination's state if the stack's parent ever changes.
|
|
final GlobalKey _destinationStackKey = GlobalKey();
|
|
|
|
@override
|
|
void dispose() {
|
|
HardwareKeyboard.instance.removeHandler(_handleDestinationKeyEvent);
|
|
_bar.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_selected = widget.destination ?? AppDestination.pipelines;
|
|
_visited.add(_selected);
|
|
HardwareKeyboard.instance.addHandler(_handleDestinationKeyEvent);
|
|
}
|
|
|
|
@override
|
|
void didUpdateWidget(covariant AdaptiveShell oldWidget) {
|
|
super.didUpdateWidget(oldWidget);
|
|
final destination = widget.destination;
|
|
if (destination != null) {
|
|
_selected = destination;
|
|
_visited.add(destination);
|
|
}
|
|
}
|
|
|
|
void _select(AppDestination destination) {
|
|
final callback = widget.onDestinationSelected;
|
|
if (callback != null) {
|
|
callback(destination);
|
|
return;
|
|
}
|
|
setState(() {
|
|
_selected = destination;
|
|
_visited.add(destination);
|
|
});
|
|
}
|
|
|
|
/// The destination's icon; only Runs carries the attention count.
|
|
Widget _icon(AppDestination destination, IconData data) {
|
|
Widget icon = Icon(data);
|
|
if (destination == AppDestination.chat) {
|
|
return ActivityBadge(
|
|
key: const ValueKey('shell.badge.chat.unread'),
|
|
count: _bar.badge(destination, ShellBadgeKind.unread),
|
|
label: 'unread chats',
|
|
cupertino: widget.cupertino,
|
|
child: icon,
|
|
);
|
|
}
|
|
if (destination != AppDestination.runs) return icon;
|
|
// One indicator: runs that need you outrank runs in progress, so the
|
|
// tab never wears two counts at once.
|
|
final attention = widget.attentionCount > 0;
|
|
return AttentionDestinationIcon(
|
|
count: widget.attentionCount,
|
|
cupertino: widget.cupertino,
|
|
child: ActivityBadge(
|
|
key: const ValueKey('shell.badge.runs.running'),
|
|
count: attention ? 0 : _bar.badge(destination, ShellBadgeKind.running),
|
|
label: 'runs in progress',
|
|
cupertino: widget.cupertino,
|
|
child: icon,
|
|
),
|
|
);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
// Full-screen detail routes cover the shell themselves. Keep the root tabs
|
|
// mounted/layout-ready underneath, so Back does not resize or reveal them
|
|
// only after the outgoing page has finished its native animation.
|
|
// Settings is shown as a page of the Pipelines tab: the tab bar keeps
|
|
// Pipelines selected and the bar offers Back to it.
|
|
final index = shellTabDestinations.indexOf(shellTabFor(_selected));
|
|
final page = !shellTabDestinations.contains(_selected);
|
|
final details = destinationDetails(_selected);
|
|
final contents = AppDestination.values.map((destination) {
|
|
final item = destinationDetails(destination);
|
|
return KeyedSubtree(
|
|
key: ValueKey(destination),
|
|
child: ShellBarScope(
|
|
registry: _bar,
|
|
destination: destination,
|
|
child: _visited.contains(destination)
|
|
? widget.destinationBodies[destination]?.call(context) ??
|
|
Center(child: Text('${item.label} — Not implemented'))
|
|
: const SizedBox.shrink(),
|
|
),
|
|
);
|
|
}).toList();
|
|
// Only the bar shows the registry's state, so a published bar or badge
|
|
// rebuilds its bar alone; the destinations and scaffold stay as built.
|
|
_bar.focus = _selected;
|
|
// One floating glass tab bar at every width: full width on a phone,
|
|
// sized to its tabs at the right edge on a wide window (the bar judges
|
|
// that itself, live). Content keeps the whole width and scrolls behind
|
|
// it, learning the bar's height as its bottom media padding. Neither
|
|
// scaffold's structure depends on the width, so resizing never
|
|
// remounts a destination.
|
|
//
|
|
// While the tab shows its list beside an open item the bar keeps
|
|
// the same place, bottom right near the thumb: the item pane learns
|
|
// the bar's height (see ListDetailPanes) and floats its own tabs or
|
|
// composer above it, so the two never overlap.
|
|
final bar = ListenableBuilder(
|
|
listenable: _bar.badges,
|
|
builder: (context, _) => FloatingDestinationBar(
|
|
cupertino: widget.cupertino,
|
|
currentIndex: index,
|
|
onTap: (value) => _select(shellTabDestinations[value]),
|
|
items: _destinationItems(),
|
|
),
|
|
);
|
|
// Destinations reach the top edge and scroll behind the floating top
|
|
// bar too: each learns the bar's height as its top media padding and
|
|
// pads its own lists by it (see withTopBarClearance).
|
|
SegmentedBar currentBar() =>
|
|
_segmentedBar(_bar.specFor(_selected), details.label, page: page);
|
|
final topBar = _ListPaneBar(
|
|
listenable: _bar.bar,
|
|
initial: currentBar(),
|
|
split: () => _bar.split(_selected),
|
|
bar: currentBar,
|
|
);
|
|
// The scaffolds below swap the system insets for their bars'
|
|
// heights; panes beside a list read the real ones from here.
|
|
final system = MediaQuery.paddingOf(context);
|
|
// A page (Settings) closes to Pipelines on the system Back too. The
|
|
// scope is always there, so opening the page never remounts the shell.
|
|
Widget backable(Widget child) => PopScope(
|
|
canPop: !page,
|
|
onPopInvokedWithResult: (didPop, _) {
|
|
if (!didPop) _closePage();
|
|
},
|
|
child: child,
|
|
);
|
|
if (widget.cupertino) {
|
|
return backable(
|
|
ShellSystemInsets(
|
|
padding: system,
|
|
child: CupertinoPageScaffold(
|
|
navigationBar: topBar,
|
|
child: SafeArea(
|
|
top: false,
|
|
bottom: false,
|
|
child: FloatingBarOverlay(
|
|
bar: bar,
|
|
child: _destinationStack(contents),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
return backable(
|
|
ShellSystemInsets(
|
|
padding: system,
|
|
child: Scaffold(
|
|
extendBodyBehindAppBar: true,
|
|
appBar: topBar,
|
|
body: _destinationStack(contents),
|
|
extendBody: true,
|
|
bottomNavigationBar: bar,
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
/// Leaves a page destination (Settings) for the tab it belongs to.
|
|
void _closePage() => _select(shellTabFor(_selected));
|
|
|
|
/// Handles this before focused text controls can insert or traverse on
|
|
/// Ctrl+Tab. The handler is scoped to the shell's lifetime, not onboarding.
|
|
bool _handleDestinationKeyEvent(KeyEvent event) {
|
|
if (event is! KeyDownEvent ||
|
|
event.logicalKey != LogicalKeyboardKey.tab ||
|
|
!HardwareKeyboard.instance.isControlPressed) {
|
|
return false;
|
|
}
|
|
final current = shellTabDestinations.indexOf(shellTabFor(_selected));
|
|
final direction = HardwareKeyboard.instance.isShiftPressed ? -1 : 1;
|
|
final next = (current + direction) % shellTabDestinations.length;
|
|
_select(
|
|
shellTabDestinations[next < 0
|
|
? next + shellTabDestinations.length
|
|
: next],
|
|
);
|
|
return true;
|
|
}
|
|
|
|
List<FloatingDestinationItem> _destinationItems() =>
|
|
shellTabDestinations.map((destination) {
|
|
final item = destinationDetails(destination);
|
|
return FloatingDestinationItem(
|
|
key: ValueKey('shell.destination.${destination.name}'),
|
|
icon: _icon(
|
|
destination,
|
|
widget.cupertino ? item.cupertinoIcon : item.icon,
|
|
),
|
|
label: item.label,
|
|
);
|
|
}).toList();
|
|
|
|
/// The open screen's own bar: its Back, title and actions, or the tab's
|
|
/// name with Search.
|
|
SegmentedBar _segmentedBar(
|
|
ShellBarSpec? spec,
|
|
String label, {
|
|
required bool page,
|
|
}) {
|
|
final cupertino = widget.cupertino;
|
|
final onBack = spec?.onBack ?? (page ? _closePage : null);
|
|
final published = spec?.actions ?? const <Widget>[];
|
|
final onSearch = widget.onSearch;
|
|
return SegmentedBar(
|
|
cupertino: cupertino,
|
|
automaticallyImplyLeading: false,
|
|
leading: onBack == null
|
|
? null
|
|
: SegmentedBackButton(
|
|
key: const ValueKey('shell.back'),
|
|
cupertino: cupertino,
|
|
onPressed: onBack,
|
|
),
|
|
title: spec?.title ?? label,
|
|
titleWidget: spec?.titleWidget,
|
|
titleWidgetMaxWidth: spec?.titleWidgetMaxWidth ?? double.infinity,
|
|
backgroundColor: spec?.backgroundColor,
|
|
subtitle: spec?.subtitle,
|
|
subtitleIcon: spec?.subtitleIcon,
|
|
onTitlePressed: spec?.onTitlePressed,
|
|
expandableTitle: spec?.expandableTitle ?? false,
|
|
titleAction: spec?.titleAction,
|
|
titleSemanticLabel: spec?.titleSemanticLabel,
|
|
titleKey: spec?.titleKey,
|
|
actions: [
|
|
if (published.isNotEmpty)
|
|
// A screen taking the bar over cross-fades its actions in.
|
|
MotionSwitcher(
|
|
child: Row(
|
|
key: ObjectKey(_bar.ownerFor(_selected)),
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
for (final action in published) Flexible(child: action),
|
|
],
|
|
),
|
|
)
|
|
// A screen whose main pill is its own field (Search) needs no
|
|
// separate Search action.
|
|
else if (onSearch != null && spec?.titleWidget == null && !page)
|
|
cupertino
|
|
? CupertinoButton(
|
|
key: const ValueKey('shell.search'),
|
|
padding: EdgeInsets.zero,
|
|
onPressed: onSearch,
|
|
child: const Icon(
|
|
CupertinoIcons.search,
|
|
semanticLabel: 'Search',
|
|
),
|
|
)
|
|
: IconButton(
|
|
key: const ValueKey('shell.search'),
|
|
onPressed: onSearch,
|
|
tooltip: 'Search',
|
|
icon: const Icon(Icons.search),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
Widget _destinationStack(List<Widget> contents) => FadeThroughStack(
|
|
key: _destinationStackKey,
|
|
index: AppDestination.values.indexOf(_selected),
|
|
children: contents,
|
|
);
|
|
}
|
|
|
|
/// The shell's top bar, over the list pane only while the tab shows a list
|
|
/// beside an open item ([ShellPaneSplit]); the item's own bar takes the rest
|
|
/// of the same row. The bar keeps its place in the scaffold either way, so a
|
|
/// split never remounts it.
|
|
///
|
|
/// It rebuilds itself when [listenable] (the focused destination's published
|
|
/// bar) changes; [initial] supplies the size and obstruction, which do not
|
|
/// depend on the published contents.
|
|
class _ListPaneBar extends StatelessWidget
|
|
implements ObstructingPreferredSizeWidget {
|
|
const _ListPaneBar({
|
|
required this.listenable,
|
|
required this.initial,
|
|
required this.split,
|
|
required this.bar,
|
|
});
|
|
|
|
final Listenable listenable;
|
|
final SegmentedBar initial;
|
|
final bool Function() split;
|
|
final SegmentedBar Function() bar;
|
|
|
|
@override
|
|
Size get preferredSize => initial.preferredSize;
|
|
|
|
@override
|
|
bool shouldFullyObstruct(BuildContext context) =>
|
|
initial.shouldFullyObstruct(context);
|
|
|
|
@override
|
|
Widget build(BuildContext context) => ListenableBuilder(
|
|
listenable: listenable,
|
|
builder: (context, _) => ListPaneWidth(
|
|
split: split(),
|
|
alignment: AlignmentDirectional.topStart,
|
|
child: bar(),
|
|
),
|
|
);
|
|
}
|