Files
pipelines/app/lib/shell/adaptive_shell.dart
T
alan efca56e4e4 Show running and failed run counts independently
Give the Runs tab separate activity and failure indicators so neither suppresses the other. Reuse known summaries and pushed updates, keep failed states separate from decisions and dismissal counts, and update across tabs even when total attention is unchanged.
2026-11-11 22:10:37 +00:00

438 lines
16 KiB
Dart

import '../ui/motion/fade_through_stack.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import '../ui/adaptive/segmented_bar.dart';
import '../ui/adaptive/floating_destination_bar.dart';
import 'attention_badge.dart';
import 'destination.dart';
import 'list_detail.dart';
import 'list_pane_widths.dart';
import 'shell_bar.dart';
import 'shell_list_shortcuts.dart';
import 'shell_search_shortcut_labels.dart';
import 'tab_history.dart';
import '../ui/input/keyboard_owner.dart';
class AdaptiveShell extends StatefulWidget {
const AdaptiveShell({
super.key,
this.destinationBodies = const {},
this.destination,
this.onDestinationSelected,
this.onClosePage,
this.onSearch,
this.attentionCount = 0,
this.runningRunCount,
this.failedRunCount,
this.listPaneWidthStore = const SharedPreferencesListPaneWidthStore(),
this.barActions = const [],
});
/// Actions every destination's bar ends with (the Terminal toggle), after
/// the screen's own or Search.
final List<Widget> barActions;
/// Where each destination's dragged list-pane width is kept on this device.
final ListPaneWidthStore listPaneWidthStore;
final Map<AppDestination, WidgetBuilder> destinationBodies;
/// 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;
final VoidCallback? onClosePage;
/// 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, retained in the tab's accessible label.
final int attentionCount;
/// App-wide counts when available; standalone screens publish their own.
final int? runningRunCount;
final int? failedRunCount;
@override
State<AdaptiveShell> createState() => _AdaptiveShellState();
}
class _AdaptiveShellState extends State<AdaptiveShell> {
late AppDestination _selected;
final Set<AppDestination> _visited = {};
final TabHistory _history = TabHistory();
// Whether a navigator inside each destination (an open item's pane) has a
// page of its own for the system Back to close first.
final Map<AppDestination, bool> _nestedCanPop = {};
final ShellBarRegistry _bar = ShellBarRegistry();
late final ListPaneWidths _paneWidths = ListPaneWidths(
store: widget.listPaneWidthStore,
);
// 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();
_paneWidths.dispose();
super.dispose();
}
@override
void initState() {
super.initState();
_bar.onNavigate = _select;
_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) {
_history.record(_selected, destination);
_selected = destination;
_visited.add(destination);
}
}
void _select(AppDestination destination) {
final callback = widget.onDestinationSelected;
if (callback != null) {
callback(destination);
return;
}
setState(() {
_history.record(_selected, destination);
_selected = destination;
_visited.add(destination);
});
}
/// Runs has independent status counts; Chat has its unread 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',
child: icon,
);
}
if (destination != AppDestination.runs) return icon;
return RunsDestinationIcon(
running:
widget.runningRunCount ??
_bar.badge(destination, ShellBadgeKind.running),
failed:
widget.failedRunCount ??
_bar.badge(destination, ShellBadgeKind.failed),
attention: widget.attentionCount,
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: NotificationListener<NavigationNotification>(
onNotification: (notification) {
_nestedCanPop[destination] = notification.canHandlePop;
return false;
},
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: sized to its tabs at the
// right edge, near the thumb. 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 moves under
// the leading edge of the list pane, so the open item
// keeps its whole height: the list clears the bar and the item clears
// only the system inset (see ListDetailPanes). The bar keeps its place
// in the tree, so a split never replays its entrance.
final bar = ListenableBuilder(
listenable: Listenable.merge([_bar.badges, _bar.bar, _paneWidths]),
builder: (context, _) {
if (_bar.specFor(_selected)?.hideNavigation ?? false) {
return const SizedBox.shrink();
}
// On a wide window the bar stays under the list column even when no
// item is open (Search, a list alone), so it never jumps sides. A page
// (Settings) has no list column, so its bar stays at the right edge.
final split =
_bar.split(_selected) || (!page && showsListBesideDetail(context));
return ListPaneWidth(
split: split,
preferredWidth: _paneWidths.widthFor(_selected.name),
alignment: AlignmentDirectional.bottomStart,
child: FloatingDestinationBar(
showLabels: true,
currentIndex: index,
onTap: (value) => _select(shellTabDestinations[value]),
items: _destinationItems(),
alignment: split ? AlignmentDirectional.bottomStart : null,
),
);
},
);
// 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: Listenable.merge([_bar.bar, _paneWidths]),
initial: currentBar(),
split: () => _bar.split(_selected),
preferredWidth: () => _paneWidths.widthFor(_selected.name),
bar: currentBar,
visible: () => !(_bar.specFor(_selected)?.barless ?? false),
);
// 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; at a
// tab's root Back returns to the tab opened before it. Only with neither
// does Back reach the platform, so Android's (predictive) Back closes the
// app only from the first tab. Pages pushed over the shell (an item,
// Search, a dialog) pop before this scope is asked. The scope is always
// there, so opening the page never remounts the shell.
Widget backable(Widget child) => PopScope(
canPop: !page && _history.isEmpty,
onPopInvokedWithResult: (didPop, _) {
if (!didPop) _back(page: page);
},
child: child,
);
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() {
final close = widget.onClosePage;
if (close != null) {
close();
} else {
_select(shellTabFor(_selected));
}
}
/// The system Back the shell handles: it closes a page, or else returns to
/// the previous tab unless the open item's own pane closes a page first.
void _back({required bool page}) {
if (page) {
_closePage();
return;
}
if (_nestedCanPop[shellTabFor(_selected)] ?? false) return;
final previous = _history.takePrevious();
if (previous != null) _select(previous);
}
/// App-wide search and conversation-list selection are handled before text
/// fields. Split-pane navigation belongs to the chat workspace; tab changes
/// have no global keyboard chord.
bool _handleDestinationKeyEvent(KeyEvent event) {
// A terminal keeps its keys (Escape, Ctrl+/, Ctrl+digits).
if (primaryFocusIsTypingSurface()) return false;
final keyboard = HardwareKeyboard.instance;
if (_selected == AppDestination.search &&
event is KeyDownEvent &&
event.logicalKey == LogicalKeyboardKey.escape &&
!keyboard.isControlPressed &&
!keyboard.isMetaPressed &&
!keyboard.isShiftPressed &&
!keyboard.isAltPressed &&
_searchEscape()) {
return true;
}
if (shellSearchShortcut(event, keyboard)) {
_select(AppDestination.search);
WidgetsBinding.instance.addPostFrameCallback((_) {
if (mounted && _selected == AppDestination.search) {
_bar.searchFocus.request();
}
});
WidgetsBinding.instance.ensureVisualUpdate();
return true;
}
final listIndex = shellListShortcutIndex(event, keyboard);
if (listIndex == null || _selected != AppDestination.chat) return false;
return _bar.lists.open(AppDestination.chat, listIndex);
}
/// A popup or nested viewer owns Escape before the underlying Search tab.
bool _searchEscape() {
final route = ModalRoute.of(context);
if (route != null && !route.isCurrent) return false;
final focusedContext = FocusManager.instance.primaryFocus?.context;
final focusedRoute = focusedContext == null
? null
: ModalRoute.of(focusedContext);
if (focusedRoute != null && route != null && focusedRoute != route) {
return false;
}
if (!_bar.searchFocus.available) return false;
if (!_bar.searchFocus.focused) {
_bar.searchFocus.request();
return true;
}
if (_history.isEmpty) return false;
_back(page: false);
return true;
}
List<FloatingDestinationItem> _destinationItems() =>
shellTabDestinations.map((destination) {
final item = destinationDetails(destination);
return FloatingDestinationItem(
key: ValueKey('shell.destination.${destination.name}'),
icon: _icon(destination, 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 onBack = spec?.onBack ?? (page ? _closePage : null);
final published = spec?.actions ?? const <Widget>[];
final onSearch = widget.onSearch;
return SegmentedBar(
automaticallyImplyLeading: false,
leading: onBack == null
? null
: SegmentedBackButton(
key: const ValueKey('shell.back'),
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,
// A screen taking the bar over brings its own actions, which pop in
// one after another; while it stays, they stay.
actionsKey: published.isEmpty ? null : _bar.ownerFor(_selected),
actions: [
if (published.isNotEmpty)
...published
// A screen whose main pill is its own field (Search) needs no
// separate Search action.
else if (onSearch != null && spec?.titleWidget == null && !page)
IconButton(
key: const ValueKey('shell.search'),
onPressed: onSearch,
tooltip: 'Search (${shellSearchShortcutLabels().join(', ')})',
icon: const Icon(Icons.search),
),
...widget.barActions,
],
);
}
Widget _destinationStack(List<Widget> contents) => ListPaneWidthsScope(
widths: _paneWidths,
child: 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, which does not depend on the
/// published contents.
class _ListPaneBar extends StatelessWidget implements PreferredSizeWidget {
const _ListPaneBar({
required this.listenable,
required this.initial,
required this.split,
required this.preferredWidth,
required this.bar,
required this.visible,
});
final Listenable listenable;
final SegmentedBar initial;
final bool Function() split;
final double? Function() preferredWidth;
final SegmentedBar Function() bar;
final bool Function() visible;
@override
Size get preferredSize => initial.preferredSize;
@override
Widget build(BuildContext context) => ListenableBuilder(
listenable: listenable,
builder: (context, _) => !visible()
? const SizedBox.shrink()
: ListPaneWidth(
split: split(),
preferredWidth: preferredWidth(),
alignment: AlignmentDirectional.topStart,
child: bar(),
),
);
}