a1c4c1c402
Settings leaves the tab bar (Pipelines, Runs, Chat, Search) and opens as a page from a gear in the Pipelines bar, keeping /settings, its keys and a Back to Pipelines (also the system Back). Every floating tab bar shows icons only, named for assistive technology. On wide windows the shell's tab bar stays at the bottom right; a split detail learns its height plus a 12px gap, so its tabs or the chat composer float above it, and pages the detail opens (the stage page) stay in its pane through its own navigator.
258 lines
9.0 KiB
Dart
258 lines
9.0 KiB
Dart
import 'package:flutter/widgets.dart';
|
|
|
|
/// At least this wide, a floating tab bar is sized to its tabs and sits at the
|
|
/// trailing edge; narrower, it spans the width minus [kFloatingBarMargin].
|
|
const double kFloatingBarWideWidth = 600;
|
|
|
|
/// The gap between a floating tab bar and the edges (and bottom safe area).
|
|
const double kFloatingBarMargin = 16;
|
|
|
|
/// The gap between two floating bars stacked at the bottom right of a wide
|
|
/// window: the shell's tab bar and, above it, an open item's own tabs (the
|
|
/// chat composer adds its own padding on top of this).
|
|
const double kStackedBarGap = 12;
|
|
|
|
/// [padding] with the floating bar's clearance added at the bottom.
|
|
///
|
|
/// A scrollable under a floating bar (see [FloatingBarOverlay] and the shell)
|
|
/// reads the bar's height as [MediaQuery.paddingOf] bottom; adding it to the
|
|
/// list's own padding lets the content scroll behind the bar yet still bring
|
|
/// its last item clear of it at rest. Lists without explicit padding already
|
|
/// do this themselves.
|
|
EdgeInsetsGeometry withFloatingBarClearance(
|
|
BuildContext context,
|
|
EdgeInsetsGeometry padding,
|
|
) => padding.add(EdgeInsets.only(bottom: MediaQuery.paddingOf(context).bottom));
|
|
|
|
/// [padding] with the top bar's clearance added at the top.
|
|
///
|
|
/// A page whose top bar floats over its content (a `SegmentedBar` in a
|
|
/// scaffold with `extendBodyBehindAppBar`, a `SegmentedBarOverlay`, the
|
|
/// shell's bar) reads the bar's height as [MediaQuery.paddingOf] top. Adding
|
|
/// it to a list's own padding starts the first item below the bar at rest
|
|
/// while scrolled content passes behind the glass pieces. Lists without
|
|
/// explicit padding (`ListView`'s default) already do this themselves.
|
|
EdgeInsetsGeometry withTopBarClearance(
|
|
BuildContext context,
|
|
EdgeInsetsGeometry padding,
|
|
) => padding.add(EdgeInsets.only(top: MediaQuery.paddingOf(context).top));
|
|
|
|
/// [padding] with both the top bar's and the floating tab bar's clearance:
|
|
/// for a list that scrolls behind a bar at each edge.
|
|
EdgeInsetsGeometry withBarClearance(
|
|
BuildContext context,
|
|
EdgeInsetsGeometry padding,
|
|
) {
|
|
final media = MediaQuery.paddingOf(context);
|
|
return padding.add(EdgeInsets.only(top: media.top, bottom: media.bottom));
|
|
}
|
|
|
|
/// Empty space as tall as the top bar's clearance ([MediaQuery.paddingOf]
|
|
/// top), starting a scrolling column so its first item sits below the bar at
|
|
/// rest and scrolls behind it.
|
|
class TopBarClearance extends StatelessWidget {
|
|
const TopBarClearance({super.key});
|
|
|
|
@override
|
|
Widget build(BuildContext context) =>
|
|
SizedBox(height: MediaQuery.paddingOf(context).top);
|
|
}
|
|
|
|
/// [TopBarClearance] as the first sliver of a [CustomScrollView]: the first
|
|
/// item starts below the bar at rest and scrolls behind it.
|
|
///
|
|
/// The clearance stays pinned (it paints nothing and takes no taps), so a
|
|
/// pinned header further down (`PinnedHeaderSliver`, a sticky section title)
|
|
/// pins just below the bar rather than behind it.
|
|
class SliverTopBarClearance extends StatelessWidget {
|
|
const SliverTopBarClearance({super.key});
|
|
|
|
@override
|
|
Widget build(BuildContext context) =>
|
|
const PinnedHeaderSliver(child: TopBarClearance());
|
|
}
|
|
|
|
/// The top bar's height over the content at [context]: where a pinned
|
|
/// header must stop so it stays below the bar.
|
|
double topBarInset(BuildContext context) => MediaQuery.paddingOf(context).top;
|
|
|
|
/// Content that cannot scroll behind the top bar (a fixed header, a canvas
|
|
/// with its own overlay controls): it starts below the bar, and its subtree no
|
|
/// longer sees the bar's height as padding.
|
|
class BelowTopBar extends StatelessWidget {
|
|
const BelowTopBar({super.key, required this.child});
|
|
|
|
final Widget child;
|
|
|
|
@override
|
|
Widget build(BuildContext context) => Padding(
|
|
padding: EdgeInsets.only(top: MediaQuery.paddingOf(context).top),
|
|
child: MediaQuery.removePadding(
|
|
context: context,
|
|
removeTop: true,
|
|
child: child,
|
|
),
|
|
);
|
|
}
|
|
|
|
/// Empty space as tall as the floating bar's clearance
|
|
/// ([MediaQuery.paddingOf] bottom), ending a scrolling column so its last item
|
|
/// comes clear of the bar at rest.
|
|
class FloatingBarClearance extends StatelessWidget {
|
|
const FloatingBarClearance({super.key});
|
|
|
|
@override
|
|
Widget build(BuildContext context) =>
|
|
SizedBox(height: MediaQuery.paddingOf(context).bottom);
|
|
}
|
|
|
|
/// [FloatingBarClearance] as the last sliver of a [CustomScrollView].
|
|
class SliverFloatingBarClearance extends StatelessWidget {
|
|
const SliverFloatingBarClearance({super.key});
|
|
|
|
@override
|
|
Widget build(BuildContext context) =>
|
|
const SliverToBoxAdapter(child: FloatingBarClearance());
|
|
}
|
|
|
|
/// The edge a page's own floating tab bar sits at.
|
|
enum FloatingBarEdge {
|
|
/// Above the bottom safe area: a phone page, a page covering the shell,
|
|
/// or a detail pane beside a list (the shell's tab bar stays over the
|
|
/// list pane).
|
|
bottom,
|
|
|
|
/// Just below the page's top bar, for a surface whose bottom is taken.
|
|
top,
|
|
}
|
|
|
|
/// Where the pages' own tab bars float in this subtree ([FloatingBarEdge]).
|
|
///
|
|
/// Pages float their tabs at the bottom (the default), including a detail
|
|
/// pane beside a list, whose bottom the shell leaves free.
|
|
class PageTabsEdge extends InheritedWidget {
|
|
const PageTabsEdge({super.key, required this.edge, required super.child});
|
|
|
|
final FloatingBarEdge edge;
|
|
|
|
static FloatingBarEdge of(BuildContext context) =>
|
|
context.dependOnInheritedWidgetOfExactType<PageTabsEdge>()?.edge ??
|
|
FloatingBarEdge.bottom;
|
|
|
|
@override
|
|
bool updateShouldNotify(PageTabsEdge oldWidget) => edge != oldWidget.edge;
|
|
}
|
|
|
|
/// Floats [bar] over [child] at [edge], the way a scaffold with `extendBody`
|
|
/// floats its bottom bar, for a bar that is not a scaffold's.
|
|
///
|
|
/// [child] fills the whole area and scrolls behind the bar. At the bottom it
|
|
/// learns the bar's measured height (bottom safe area and margins included)
|
|
/// as its [MediaQuery.paddingOf] bottom, so a list can pad its last item clear
|
|
/// of the bar at rest (see [withFloatingBarClearance]). At the top the bar
|
|
/// sits below the area's own top inset (the page's top bar) and the content's
|
|
/// top padding grows by the bar's height (see [withTopBarClearance]). Taps the
|
|
/// bar does not take, such as beside a bar narrower than the area, reach
|
|
/// [child].
|
|
class FloatingBarOverlay extends StatelessWidget {
|
|
const FloatingBarOverlay({
|
|
super.key,
|
|
required this.bar,
|
|
required this.child,
|
|
this.edge = FloatingBarEdge.bottom,
|
|
});
|
|
|
|
final Widget bar;
|
|
final Widget child;
|
|
final FloatingBarEdge edge;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final top = edge == FloatingBarEdge.top;
|
|
final inset = top ? MediaQuery.paddingOf(context).top : 0.0;
|
|
return CustomMultiChildLayout(
|
|
delegate: _OverlayLayout(top: top, inset: inset),
|
|
children: [
|
|
// Painted first, so the bar draws (and takes taps) above it.
|
|
LayoutId(
|
|
id: _Slot.content,
|
|
child: LayoutBuilder(
|
|
builder: (context, constraints) {
|
|
final barHeight = constraints is _ContentConstraints
|
|
? constraints.barHeight
|
|
: 0.0;
|
|
final media = MediaQuery.of(context);
|
|
final padding = top
|
|
? media.padding.copyWith(top: inset + barHeight)
|
|
: media.padding.copyWith(
|
|
bottom: barHeight > media.padding.bottom
|
|
? barHeight
|
|
: media.padding.bottom,
|
|
);
|
|
return MediaQuery(
|
|
data: media.copyWith(padding: padding),
|
|
child: child,
|
|
);
|
|
},
|
|
),
|
|
),
|
|
LayoutId(id: _Slot.bar, child: bar),
|
|
],
|
|
);
|
|
}
|
|
}
|
|
|
|
enum _Slot { content, bar }
|
|
|
|
/// The content's tight constraints, carrying the bar's height so the content
|
|
/// rebuilds its inset when the bar grows or shrinks.
|
|
class _ContentConstraints extends BoxConstraints {
|
|
_ContentConstraints(Size size, {required this.barHeight})
|
|
: super(
|
|
minWidth: size.width,
|
|
maxWidth: size.width,
|
|
minHeight: size.height,
|
|
maxHeight: size.height,
|
|
);
|
|
|
|
final double barHeight;
|
|
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
other is _ContentConstraints &&
|
|
super == other &&
|
|
other.barHeight == barHeight;
|
|
|
|
@override
|
|
int get hashCode => Object.hash(super.hashCode, barHeight);
|
|
}
|
|
|
|
class _OverlayLayout extends MultiChildLayoutDelegate {
|
|
_OverlayLayout({required this.top, required this.inset});
|
|
|
|
final bool top;
|
|
final double inset;
|
|
|
|
@override
|
|
void performLayout(Size size) {
|
|
final bar = layoutChild(
|
|
_Slot.bar,
|
|
BoxConstraints(
|
|
minWidth: size.width,
|
|
maxWidth: size.width,
|
|
maxHeight: size.height,
|
|
),
|
|
);
|
|
positionChild(_Slot.bar, Offset(0, top ? inset : size.height - bar.height));
|
|
layoutChild(
|
|
_Slot.content,
|
|
_ContentConstraints(size, barHeight: bar.height),
|
|
);
|
|
positionChild(_Slot.content, Offset.zero);
|
|
}
|
|
|
|
@override
|
|
bool shouldRelayout(_OverlayLayout oldDelegate) =>
|
|
oldDelegate.top != top || oldDelegate.inset != inset;
|
|
}
|