import 'package:flutter/widgets.dart'; import 'destination.dart'; import 'shell_list_shortcuts.dart'; import 'shell_search_focus.dart'; /// What the open screen of a tab puts in the app bar: its title, a Back /// control and its actions. Absent, the bar shows the tab's own name. class ShellBarSpec { const ShellBarSpec({ this.title, this.subtitle, this.subtitleIcon, this.onTitlePressed, this.expandableTitle = false, this.titleAction, this.titleSemanticLabel, this.titleKey, this.onBack, this.actions = const [], this.barless = false, this.hideNavigation = false, this.titleWidget, this.titleWidgetMaxWidth = double.infinity, this.backgroundColor, }); final String? title; /// The bar's main pill in place of the title (a search field); see /// `SegmentedBar.titleWidget`. final Widget? titleWidget; final double titleWidgetMaxWidth; /// The page's own background behind the bar (a grouped list's), so the /// bar's scrim matches what scrolls under it; null keeps the shell's. final Color? backgroundColor; /// A one-line subtitle in the title pill (the item's context: its /// pipeline and version), so the body need not repeat it. final String? subtitle; final IconData? subtitleIcon; /// Makes the title pill a button; see `SegmentedBar.onTitlePressed`. final VoidCallback? onTitlePressed; final bool expandableTitle; final Widget? titleAction; final String? titleSemanticLabel; final Key? titleKey; final VoidCallback? onBack; final List actions; /// The content draws its own floating bar: a detail page shows no bar of /// its own and lets the content reach the top edge. final bool barless; final bool hideNavigation; } /// The bar contents each tab's open screen has published. /// /// It notifies its own listeners of every visible change. A host that shows /// one destination's bar at a time sets [focus] and may listen to [bar] and /// [badges] separately: a hidden tab republishing its bar (a list rebuilding /// on a run event) then rebuilds nothing, and a badge change rebuilds only /// the tab bar. class ShellBarRegistry extends ChangeNotifier { ValueChanged? onNavigate; bool get canNavigate => onNavigate != null && !_disposed; void navigateTo(AppDestination destination) { if (!_disposed) onNavigate?.call(destination); } final Map _specs = {}; final Map<(AppDestination, ShellBadgeKind), int> _badges = {}; final _Notifier _bar = _Notifier(); final _Notifier _badgeNotifier = _Notifier(); /// Registered list openers; keyboard shortcuts invoke Chat only. final ShellListShortcuts lists = ShellListShortcuts(); final ShellSearchFocus searchFocus = ShellSearchFocus(); /// The destination whose bar is on screen; null treats every destination /// as shown. Bar changes of other destinations are kept without notifying: /// the host rebuilds when it changes the focus. AppDestination? focus; /// Notifies when the focused destination's bar spec or split changes. Listenable get bar => _bar; /// Notifies when any tab badge count changes. Listenable get badges => _badgeNotifier; bool _shown(AppDestination destination) => focus == null || focus == destination; void _barChanged(AppDestination destination) { if (!_shown(destination)) return; _bar.notify(); notifyListeners(); } final Map _splits = {}; /// Whether a tab's screen shows a list beside an open item right now /// ([ShellPaneSplit]): the shell's bar then covers the list pane only, so /// the item's own bar shares its top row. bool split(AppDestination destination) => (_splits[destination] ?? 0) > 0; void _setSplit(AppDestination destination, bool value) { if (_disposed) return; final before = split(destination); _splits[destination] = (_splits[destination] ?? 0) + (value ? 1 : -1); if (split(destination) != before) _barChanged(destination); } /// The count a tab's screen published for [kind], 0 when none. int badge(AppDestination destination, ShellBadgeKind kind) => _badges[(destination, kind)] ?? 0; void _setBadge(AppDestination destination, ShellBadgeKind kind, int count) { if (_disposed || badge(destination, kind) == count) return; _badges[(destination, kind)] = count; _badgeNotifier.notify(); notifyListeners(); } bool _disposed = false; @override void dispose() { _disposed = true; _bar.dispose(); _badgeNotifier.dispose(); super.dispose(); } ShellBarSpec? specFor(AppDestination destination) => _specs[destination]?.$2; /// The screen that published [destination]'s bar; it changes when another /// screen takes the bar over. Object? ownerFor(AppDestination destination) => _specs[destination]?.$1; void _set(AppDestination destination, Object owner, ShellBarSpec spec) { // A screen's update can land after the shell itself has gone. if (_disposed) return; _specs[destination] = (owner, spec); _barChanged(destination); } void _clear(AppDestination destination, Object owner) { if (_disposed) return; if (_specs[destination]?.$1 != owner) return; _specs.remove(destination); _barChanged(destination); } } class _Notifier extends ChangeNotifier { void notify() => notifyListeners(); } /// Places one tab's content under the shell's bar registry. class ShellBarScope extends InheritedWidget { const ShellBarScope({ super.key, required this.registry, required this.destination, required super.child, }); final ShellBarRegistry registry; final AppDestination destination; static ShellBarScope? maybeOf(BuildContext context) => context.dependOnInheritedWidgetOfExactType(); @override bool updateShouldNotify(ShellBarScope oldWidget) => registry != oldWidget.registry || destination != oldWidget.destination; } /// Puts [title], [onBack] and [actions] in the app bar while [child] is shown. /// Outside a shell (a screen mounted on its own) it does nothing, so the /// screen keeps its own controls. class ShellBar extends StatefulWidget { const ShellBar({ super.key, this.title, this.subtitle, this.subtitleIcon, this.onTitlePressed, this.expandableTitle = false, this.titleAction, this.titleSemanticLabel, this.titleKey, this.onBack, this.actions = const [], this.active = true, this.barless = false, this.hideNavigation = false, this.titleWidget, this.titleWidgetMaxWidth = double.infinity, this.backgroundColor, required this.child, }); /// See [ShellBarSpec.titleWidget]. final Widget? titleWidget; final double titleWidgetMaxWidth; /// See [ShellBarSpec.backgroundColor]. final Color? backgroundColor; /// See [ShellBarSpec.barless]. final bool barless; final bool hideNavigation; /// False while the screen is kept mounted but hidden (a list under an open /// detail): it then gives the bar up. final bool active; final String? title; /// See [ShellBarSpec.subtitle]. final String? subtitle; final IconData? subtitleIcon; final VoidCallback? onTitlePressed; final bool expandableTitle; final Widget? titleAction; final String? titleSemanticLabel; final Key? titleKey; final VoidCallback? onBack; final List actions; final Widget child; /// Whether a shell bar will show these controls for the subtree at /// [context]. static bool available(BuildContext context) => ShellBarScope.maybeOf(context) != null; @override State createState() => _ShellBarState(); } class _ShellBarState extends State { final Object _owner = Object(); ShellBarScope? _scope; @override void didChangeDependencies() { super.didChangeDependencies(); _scope = ShellBarScope.maybeOf(context); } void _publish() { final scope = _scope; if (scope == null) return; if (!widget.active) { WidgetsBinding.instance.addPostFrameCallback((_) { if (mounted) scope.registry._clear(scope.destination, _owner); }); return; } final spec = ShellBarSpec( title: widget.title, subtitle: widget.subtitle, subtitleIcon: widget.subtitleIcon, onTitlePressed: widget.onTitlePressed, expandableTitle: widget.expandableTitle, titleAction: widget.titleAction, titleSemanticLabel: widget.titleSemanticLabel, titleKey: widget.titleKey, onBack: widget.onBack, actions: widget.actions, barless: widget.barless, hideNavigation: widget.hideNavigation, titleWidget: widget.titleWidget, titleWidgetMaxWidth: widget.titleWidgetMaxWidth, backgroundColor: widget.backgroundColor, ); // The bar is above this screen; update it after this frame's build. WidgetsBinding.instance.addPostFrameCallback((_) { if (mounted) scope.registry._set(scope.destination, _owner, spec); }); } @override void dispose() { final scope = _scope; if (scope != null) { WidgetsBinding.instance.addPostFrameCallback( (_) => scope.registry._clear(scope.destination, _owner), ); } super.dispose(); } @override Widget build(BuildContext context) { _publish(); return widget.child; } } /// Tells the shell, while mounted, that its tab shows a list beside an open /// item (`ListDetailPanes`). The shell then narrows its own bar to the list /// pane, so each pane owns its bar on one shared top row. Outside a shell it /// does nothing. class ShellPaneSplit extends StatefulWidget { const ShellPaneSplit({super.key, required this.child}); final Widget child; @override State createState() => _ShellPaneSplitState(); } class _ShellPaneSplitState extends State { ShellBarScope? _scope; @override void didChangeDependencies() { super.didChangeDependencies(); final scope = ShellBarScope.maybeOf(context); if (scope == _scope) return; _release(); _scope = scope; if (scope != null) { // The bar is above this screen; update it after this frame's build. WidgetsBinding.instance.addPostFrameCallback( (_) => scope.registry._setSplit(scope.destination, true), ); } } void _release() { final scope = _scope; if (scope == null) return; WidgetsBinding.instance.addPostFrameCallback( (_) => scope.registry._setSplit(scope.destination, false), ); } @override void dispose() { _release(); super.dispose(); } @override Widget build(BuildContext context) => widget.child; } /// What a tab badge counts. enum ShellBadgeKind { /// Runs still executing. running, /// Chats with messages not yet seen. unread, } /// Publishes a count for this tab's badge while [child] is mounted. class ShellBadge extends StatefulWidget { const ShellBadge({ super.key, required this.kind, required this.count, required this.child, }); final ShellBadgeKind kind; final int count; final Widget child; @override State createState() => _ShellBadgeState(); } class _ShellBadgeState extends State { ShellBarScope? _scope; @override void didChangeDependencies() { super.didChangeDependencies(); _scope = ShellBarScope.maybeOf(context); } @override void dispose() { final scope = _scope; final kind = widget.kind; if (scope != null) { WidgetsBinding.instance.addPostFrameCallback( (_) => scope.registry._setBadge(scope.destination, kind, 0), ); } super.dispose(); } @override Widget build(BuildContext context) { final scope = _scope; if (scope != null) { final count = widget.count; final kind = widget.kind; WidgetsBinding.instance.addPostFrameCallback((_) { if (mounted) scope.registry._setBadge(scope.destination, kind, count); }); } return widget.child; } }