6b82f51331
The add-pane picker is opened from a pane, not a button; with no room above or below the anchor the panel was laid out with no height (found by run 303's UI review).
233 lines
7.4 KiB
Dart
233 lines
7.4 KiB
Dart
import 'package:flutter/material.dart';
|
|
|
|
import '../motion/motion.dart';
|
|
|
|
/// The narrowest app that gets desktop popups: the width where a list shows
|
|
/// beside its open item (`kListDetailMinWidth`).
|
|
const double kDesktopPopupMinWidth = 600;
|
|
|
|
/// Whether popups here are desktop ones (a menu anchored to its button, a
|
|
/// dialog) rather than a phone's bottom sheets. It is the app's width that
|
|
/// decides, not the surface asking: content in a narrow floating window on a
|
|
/// wide app still gets menus and dialogs.
|
|
bool usesDesktopPopups(BuildContext context) {
|
|
final root = Navigator.maybeOf(context, rootNavigator: true)?.context;
|
|
return MediaQuery.sizeOf(root ?? context).width >= kDesktopPopupMinWidth;
|
|
}
|
|
|
|
/// Shows a short list of choices (a mode, a sort order, a pane to add, a
|
|
/// row's actions) built by [builder].
|
|
///
|
|
/// On a wide app it is a menu panel anchored to [anchor] (the button that
|
|
/// opened it): below it, or above when there is no room, kept inside the app.
|
|
/// When [anchor] is a region rather than a button (a pane), the panel opens
|
|
/// over its top left.
|
|
/// On a phone it is a bottom sheet. Either way it is on the root navigator,
|
|
/// so it is above every floating window. Escape, Back or a press outside
|
|
/// closes it; the content closes it with `Navigator.of(context).pop(value)`.
|
|
Future<T?> showAppChoiceMenu<T>(
|
|
BuildContext anchor, {
|
|
required WidgetBuilder builder,
|
|
double width = 320,
|
|
String? semanticLabel,
|
|
}) {
|
|
final navigator = Navigator.of(anchor, rootNavigator: true);
|
|
if (!usesDesktopPopups(anchor)) {
|
|
return showModalBottomSheet<T>(
|
|
context: anchor,
|
|
useRootNavigator: true,
|
|
showDragHandle: true,
|
|
isScrollControlled: true,
|
|
useSafeArea: true,
|
|
builder: builder,
|
|
);
|
|
}
|
|
final box = anchor.findRenderObject()! as RenderBox;
|
|
final overlay = navigator.overlay!.context.findRenderObject()! as RenderBox;
|
|
final rect = box.localToGlobal(Offset.zero, ancestor: overlay) & box.size;
|
|
return navigator.push<T>(
|
|
_AnchoredMenuRoute<T>(
|
|
anchor: rect,
|
|
width: width,
|
|
builder: builder,
|
|
label: semanticLabel ?? 'Menu',
|
|
themes: InheritedTheme.capture(from: anchor, to: navigator.context),
|
|
duration: Motion.of(anchor, Motion.quick),
|
|
),
|
|
);
|
|
}
|
|
|
|
/// Shows richer content (a chat's details, a file's details) built by
|
|
/// [builder]: a dialog on a wide app, a bottom sheet on a phone, on the root
|
|
/// navigator either way. The content sizes itself (a `Column` with
|
|
/// `MainAxisSize.min`); the dialog scrolls it when it is taller than the app.
|
|
Future<T?> showAppDetails<T>(
|
|
BuildContext context, {
|
|
required WidgetBuilder builder,
|
|
double maxWidth = 560,
|
|
}) {
|
|
if (!usesDesktopPopups(context)) {
|
|
return showModalBottomSheet<T>(
|
|
context: context,
|
|
useRootNavigator: true,
|
|
showDragHandle: true,
|
|
isScrollControlled: true,
|
|
useSafeArea: true,
|
|
builder: builder,
|
|
);
|
|
}
|
|
return showDialog<T>(
|
|
context: context,
|
|
useRootNavigator: true,
|
|
builder: (dialog) => Dialog(
|
|
clipBehavior: Clip.antiAlias,
|
|
child: ConstrainedBox(
|
|
constraints: BoxConstraints(
|
|
maxWidth: maxWidth,
|
|
maxHeight: MediaQuery.sizeOf(dialog).height * 0.85,
|
|
),
|
|
// Content taller than the app scrolls inside the dialog.
|
|
child: SingleChildScrollView(
|
|
padding: const EdgeInsets.only(top: 16),
|
|
child: builder(dialog),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
class _AnchoredMenuRoute<T> extends PopupRoute<T> {
|
|
_AnchoredMenuRoute({
|
|
required this.anchor,
|
|
required this.width,
|
|
required this.builder,
|
|
required this.label,
|
|
required this.themes,
|
|
required this.duration,
|
|
});
|
|
|
|
final Rect anchor;
|
|
final double width;
|
|
final WidgetBuilder builder;
|
|
final String label;
|
|
final CapturedThemes themes;
|
|
final Duration duration;
|
|
|
|
@override
|
|
Color? get barrierColor => null;
|
|
@override
|
|
bool get barrierDismissible => true;
|
|
@override
|
|
String? get barrierLabel => 'Dismiss';
|
|
@override
|
|
Duration get transitionDuration => duration;
|
|
|
|
@override
|
|
Widget buildPage(
|
|
BuildContext context,
|
|
Animation<double> animation,
|
|
Animation<double> secondaryAnimation,
|
|
) {
|
|
final colors = Theme.of(context).colorScheme;
|
|
return SafeArea(
|
|
child: CustomSingleChildLayout(
|
|
delegate: _AnchoredMenuLayout(anchor, width),
|
|
child: FadeTransition(
|
|
opacity: CurvedAnimation(parent: animation, curve: Motion.curve),
|
|
child: Semantics(
|
|
scopesRoute: true,
|
|
namesRoute: true,
|
|
explicitChildNodes: true,
|
|
label: label,
|
|
child: Material(
|
|
key: const ValueKey('app-choice-menu'),
|
|
elevation: 3,
|
|
// A step above a window's own surface, so the panel reads
|
|
// as raised when it opens over one.
|
|
color: colors.surfaceContainerHigh,
|
|
surfaceTintColor: Colors.transparent,
|
|
borderRadius: BorderRadius.circular(12),
|
|
clipBehavior: Clip.antiAlias,
|
|
child: Padding(
|
|
padding: const EdgeInsets.symmetric(vertical: 8),
|
|
child: themes.wrap(Builder(builder: builder)),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Places the panel below its anchor, aligned to the anchor's leading edge,
|
|
/// or above it when it fits better there, and always inside the app.
|
|
class _AnchoredMenuLayout extends SingleChildLayoutDelegate {
|
|
_AnchoredMenuLayout(this.anchor, this.width);
|
|
|
|
final Rect anchor;
|
|
final double width;
|
|
|
|
static const double margin = 8;
|
|
static const double gap = 4;
|
|
|
|
/// Less room than this on both sides means the anchor is not a button but
|
|
/// a region (a pane's bar, a whole pane): the panel then opens over it,
|
|
/// from its top.
|
|
static const double minRoom = 200;
|
|
|
|
double _below(Size size) => size.height - anchor.bottom - gap - margin;
|
|
double _above() => anchor.top - gap - margin;
|
|
bool _over(Size size) => _below(size) < minRoom && _above() < minRoom;
|
|
|
|
@override
|
|
BoxConstraints getConstraintsForChild(BoxConstraints constraints) {
|
|
final available = constraints.biggest;
|
|
final below = _below(available);
|
|
final above = _above();
|
|
final double room;
|
|
if (_over(available)) {
|
|
room =
|
|
available.height -
|
|
anchor.top.clamp(margin, available.height) -
|
|
margin;
|
|
} else {
|
|
room = below >= minRoom || below >= above ? below : above;
|
|
}
|
|
final maxWidth = (available.width - 2 * margin).clamp(0.0, double.infinity);
|
|
return BoxConstraints(
|
|
minWidth: width.clamp(0.0, maxWidth),
|
|
maxWidth: width.clamp(0.0, maxWidth),
|
|
maxHeight: room.clamp(0.0, available.height - 2 * margin),
|
|
);
|
|
}
|
|
|
|
@override
|
|
Offset getPositionForChild(Size size, Size childSize) {
|
|
final double top;
|
|
if (_over(size)) {
|
|
top = anchor.top + gap;
|
|
} else if (childSize.height <= _below(size)) {
|
|
top = anchor.bottom + gap;
|
|
} else {
|
|
top = anchor.top - gap - childSize.height;
|
|
}
|
|
final maxTop = (size.height - margin - childSize.height).clamp(
|
|
margin,
|
|
double.infinity,
|
|
);
|
|
final maxLeft = (size.width - margin - childSize.width).clamp(
|
|
margin,
|
|
double.infinity,
|
|
);
|
|
return Offset(
|
|
anchor.left.clamp(margin, maxLeft),
|
|
top.clamp(margin, maxTop),
|
|
);
|
|
}
|
|
|
|
@override
|
|
bool shouldRelayout(_AnchoredMenuLayout oldDelegate) =>
|
|
oldDelegate.anchor != anchor || oldDelegate.width != width;
|
|
}
|