From c0d68f7c471dab84b93368c23f54228f14ebc956 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Tue, 3 Nov 2026 10:49:09 +0000 Subject: [PATCH] Split view: drag the divider to resize the list pane, remembered per destination A 12 px grab area over the divider line resizes the list live (mouse, touch, arrow keys; double tap resets to the default policy). The shell bar over the list follows. Widths persist per destination in SharedPreferences and clamp to the window without overwriting the saved value. Capture kit gains hover= and drag= steps. --- app/lib/shell/adaptive_shell.dart | 26 ++- app/lib/shell/list_detail.dart | 229 ++++++++++++---------- app/lib/shell/list_detail_policy.dart | 83 ++++++++ app/lib/shell/list_pane_divider.dart | 187 ++++++++++++++++++ app/lib/shell/list_pane_widths.dart | 143 ++++++++++++++ app/notes/list-pane-resize.md | 16 ++ app/test/shell/list_pane_resize_test.dart | 222 +++++++++++++++++++++ app/tool/capture/README.md | 2 + app/tool/capture/capture.mjs | 21 +- app/tool/capture/page.mjs | 23 +++ 10 files changed, 837 insertions(+), 115 deletions(-) create mode 100644 app/lib/shell/list_detail_policy.dart create mode 100644 app/lib/shell/list_pane_divider.dart create mode 100644 app/lib/shell/list_pane_widths.dart create mode 100644 app/notes/list-pane-resize.md create mode 100644 app/test/shell/list_pane_resize_test.dart diff --git a/app/lib/shell/adaptive_shell.dart b/app/lib/shell/adaptive_shell.dart index f25bf974..d8e50210 100644 --- a/app/lib/shell/adaptive_shell.dart +++ b/app/lib/shell/adaptive_shell.dart @@ -9,6 +9,7 @@ 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'; class AdaptiveShell extends StatefulWidget { @@ -20,8 +21,12 @@ class AdaptiveShell extends StatefulWidget { this.onDestinationSelected, this.onSearch, this.attentionCount = 0, + this.listPaneWidthStore = const SharedPreferencesListPaneWidthStore(), }); + /// Where each destination's dragged list-pane width is kept on this device. + final ListPaneWidthStore listPaneWidthStore; + final Map destinationBodies; final bool cupertino; @@ -46,6 +51,9 @@ class _AdaptiveShellState extends State { late AppDestination _selected; final Set _visited = {}; 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(); @@ -53,6 +61,7 @@ class _AdaptiveShellState extends State { void dispose() { HardwareKeyboard.instance.removeHandler(_handleDestinationKeyEvent); _bar.dispose(); + _paneWidths.dispose(); super.dispose(); } @@ -168,9 +177,10 @@ class _AdaptiveShellState extends State { SegmentedBar currentBar() => _segmentedBar(_bar.specFor(_selected), details.label, page: page); final topBar = _ListPaneBar( - listenable: _bar.bar, + listenable: Listenable.merge([_bar.bar, _paneWidths]), initial: currentBar(), split: () => _bar.split(_selected), + preferredWidth: () => _paneWidths.widthFor(_selected.name), bar: currentBar, ); // The scaffolds below swap the system insets for their bars' @@ -313,10 +323,13 @@ class _AdaptiveShellState extends State { ); } - Widget _destinationStack(List contents) => FadeThroughStack( - key: _destinationStackKey, - index: AppDestination.values.indexOf(_selected), - children: contents, + Widget _destinationStack(List contents) => ListPaneWidthsScope( + widths: _paneWidths, + child: FadeThroughStack( + key: _destinationStackKey, + index: AppDestination.values.indexOf(_selected), + children: contents, + ), ); } @@ -334,12 +347,14 @@ class _ListPaneBar extends StatelessWidget required this.listenable, required this.initial, required this.split, + required this.preferredWidth, required this.bar, }); final Listenable listenable; final SegmentedBar initial; final bool Function() split; + final double? Function() preferredWidth; final SegmentedBar Function() bar; @override @@ -354,6 +369,7 @@ class _ListPaneBar extends StatelessWidget listenable: listenable, builder: (context, _) => ListPaneWidth( split: split(), + preferredWidth: preferredWidth(), alignment: AlignmentDirectional.topStart, child: bar(), ), diff --git a/app/lib/shell/list_detail.dart b/app/lib/shell/list_detail.dart index ae84895c..e876df28 100644 --- a/app/lib/shell/list_detail.dart +++ b/app/lib/shell/list_detail.dart @@ -1,47 +1,15 @@ import 'dart:math' as math; -import 'package:flutter/cupertino.dart'; import 'package:flutter/material.dart'; import '../ui/adaptive/floating_bar_layout.dart'; -import '../ui/adaptive/host.dart'; import 'detail_pane_navigator.dart'; +import 'list_detail_policy.dart'; +import 'list_pane_divider.dart'; +import 'list_pane_widths.dart'; import 'shell_bar.dart'; -/// At least this wide, a destination keeps its list beside the open item -/// (with the destination rail) instead of pushing the item as its own page. -const double kListDetailMinWidth = 600; -const double _bodyWindowTarget = 0.6; -const double _bodyWindowMinimum = 0.5; -const double _bodyAvailableMaximum = 0.75; - -/// The widest the list pane grows beside an open item: on a very wide window -/// (a 4K monitor) the extra width goes to the open item, not the list. -const double kListPaneMaxWidth = 440; - -/// Whether the window at [context] shows list and detail side by side. -bool showsListBesideDetail(BuildContext context) => - MediaQuery.sizeOf(context).width >= kListDetailMinWidth; - -/// The open item's width beside a list, for a [window] this wide and -/// [available] width for both panes and their divider. -double listDetailBodyWidth(double window, double available) { - // Target 60% of the full window. Keep at least half for the body while - // leaving a flexible share for native list controls on tighter windows. - final requestedMinimum = window * _bodyWindowMinimum; - final minimum = available > requestedMinimum - ? requestedMinimum - : available * _bodyWindowMinimum; - final maximum = math.max(minimum, available * _bodyAvailableMaximum); - final body = (window * _bodyWindowTarget).clamp(minimum, maximum); - // Past the list's cap, the open item takes the rest. - return math.max(body, available - 1 - kListPaneMaxWidth); -} - -/// The list pane's width beside an open item (see [listDetailBodyWidth]), -/// one divider excluded. -double listDetailListWidth(double window, double available) => - math.max(0, available - 1 - listDetailBodyWidth(window, available)); +export 'list_detail_policy.dart'; /// The system's own insets (status bar, navigation bar) as the shell saw /// them, before its scaffold replaced them with its bars' heights. @@ -79,10 +47,15 @@ class ListPaneWidth extends StatelessWidget { super.key, required this.split, required this.alignment, + this.preferredWidth, required this.child, }); final bool split; + + /// The list width the operator dragged the divider to, null for the + /// default policy; see [listDetailListWidth]. + final double? preferredWidth; final AlignmentGeometry alignment; final Widget child; @@ -93,6 +66,7 @@ class ListPaneWidth extends StatelessWidget { ? listDetailListWidth( MediaQuery.sizeOf(context).width, constraints.maxWidth, + preferredWidth, ) : constraints.maxWidth; return Align( @@ -115,7 +89,7 @@ class ListPaneWidth extends StatelessWidget { /// [kStackedBarGap] as its bottom padding: its own tabs (or the chat /// composer) float above the shell's bar, never on it, and its content clears /// both. Pages the item opens stay in its pane ([DetailPaneNavigator]). -class ListDetailPanes extends StatelessWidget { +class ListDetailPanes extends StatefulWidget { const ListDetailPanes({ super.key, required this.list, @@ -130,88 +104,125 @@ class ListDetailPanes extends StatelessWidget { /// previous one opened in its pane. final Object? detailIdentity; + @override + State createState() => _ListDetailPanesState(); +} + +class _ListDetailPanesState extends State { + // Outside a shell (no [ListPaneWidthsScope]) the divider still drags; the + // width lasts as long as the panes. + ListPaneWidths? _ownWidths; + + @override + void dispose() { + _ownWidths?.dispose(); + super.dispose(); + } + @override Widget build(BuildContext context) { - final divider = usesCupertinoHost(context) - ? Container( - width: 1, - color: CupertinoColors.separator.resolveFrom(context), - ) - : const VerticalDivider(width: 1); + final widths = + ListPaneWidthsScope.maybeOf(context) ?? + (_ownWidths ??= ListPaneWidths(store: MemoryListPaneWidthStore())); + final key = ShellBarScope.maybeOf(context)?.destination.name ?? 'panes'; final media = MediaQuery.of(context); final split = ShellBar.available(context); return ShellPaneSplit( - child: LayoutBuilder( - builder: (context, constraints) { - final bodyWidth = listDetailBodyWidth( - media.size.width, - constraints.maxWidth, - ); - Widget body = detail; - Widget listPane = list; - if (split) { - // Beside the list the item is not under the shell's top bar (it - // stays over the list pane): it keeps the system's own top inset, - // so its bar sits just below the status bar at the top edge. The - // shell's tab bar floats at the bottom right, over this pane; its - // height (the shell's bottom padding here) plus a gap lifts the - // item's tabs or composer above it. - final system = ShellSystemInsets.of(context); - body = MediaQuery( - data: media.copyWith( - padding: media.padding.copyWith( - top: system.top, - bottom: media.padding.bottom + kStackedBarGap, - ), - ), - child: PageTabsEdge( - edge: FloatingBarEdge.bottom, - child: DetailPaneNavigator( - identity: detailIdentity, - child: body, - ), - ), - ); - // The tab bar sits over the detail pane, never the list (the - // detail is at least half the window, wider than the bar), so - // the list clears only the system's bottom inset. - listPane = MediaQuery( - data: media.copyWith( - padding: media.padding.copyWith(bottom: system.bottom), - ), - child: list, - ); - } - return Row( - crossAxisAlignment: CrossAxisAlignment.stretch, - children: [ - Expanded( - child: SizedBox.expand( - key: const ValueKey('list-detail-list'), - child: Semantics( - container: true, - explicitChildNodes: true, - identifier: 'list-detail-list', - child: listPane, + child: ListenableBuilder( + listenable: widths, + builder: (context, _) => LayoutBuilder( + builder: (context, constraints) { + final window = media.size.width; + final available = constraints.maxWidth; + final preferred = widths.widthFor(key); + final listWidth = listDetailListWidth(window, available, preferred); + final bodyWidth = math.max(0.0, available - 1 - listWidth); + final bounds = listPaneWidthBounds(window, available); + Widget body = widget.detail; + Widget listPane = widget.list; + if (split) { + // Beside the list the item is not under the shell's top bar (it + // stays over the list pane): it keeps the system's own top + // inset, so its bar sits just below the status bar at the top + // edge. The shell's tab bar floats at the bottom right, over + // this pane; its height (the shell's bottom padding here) plus + // a gap lifts the item's tabs or composer above it. + final system = ShellSystemInsets.of(context); + body = MediaQuery( + data: media.copyWith( + padding: media.padding.copyWith( + top: system.top, + bottom: media.padding.bottom + kStackedBarGap, ), ), - ), - divider, - SizedBox( - width: bodyWidth, - child: SizedBox.expand( - key: const ValueKey('list-detail-body'), - child: Semantics( - container: true, - explicitChildNodes: true, - identifier: 'list-detail-body', + child: PageTabsEdge( + edge: FloatingBarEdge.bottom, + child: DetailPaneNavigator( + identity: widget.detailIdentity, child: body, ), ), - ), - ], - ); - }, + ); + // The tab bar sits over the detail pane, never the list (the + // detail is at least half the window, wider than the bar), so + // the list clears only the system's bottom inset. + listPane = MediaQuery( + data: media.copyWith( + padding: media.padding.copyWith(bottom: system.bottom), + ), + child: widget.list, + ); + } + return Stack( + children: [ + Row( + crossAxisAlignment: CrossAxisAlignment.stretch, + children: [ + Expanded( + child: SizedBox.expand( + key: const ValueKey('list-detail-list'), + child: Semantics( + container: true, + explicitChildNodes: true, + identifier: 'list-detail-list', + child: listPane, + ), + ), + ), + const ListPaneDividerLine(), + SizedBox( + width: bodyWidth, + child: SizedBox.expand( + key: const ValueKey('list-detail-body'), + child: Semantics( + container: true, + explicitChildNodes: true, + identifier: 'list-detail-body', + child: body, + ), + ), + ), + ], + ), + if (bounds != null) + PositionedDirectional( + start: listWidth + 0.5 - kListPaneDividerGrabWidth / 2, + top: 0, + bottom: 0, + width: kListPaneDividerGrabWidth, + child: ListPaneDivider( + width: listWidth, + min: bounds.min, + max: bounds.max, + onChanged: (value) => widths.preview(key, value), + onChangeEnd: () => widths.commit(key), + onReset: () => widths.reset(key), + ), + ), + ], + ); + }, + ), ), ); } diff --git a/app/lib/shell/list_detail_policy.dart b/app/lib/shell/list_detail_policy.dart new file mode 100644 index 00000000..113aefd2 --- /dev/null +++ b/app/lib/shell/list_detail_policy.dart @@ -0,0 +1,83 @@ +import 'dart:math' as math; + +import 'package:flutter/widgets.dart'; + +/// At least this wide, a destination keeps its list beside the open item +/// (with the destination rail) instead of pushing the item as its own page. +const double kListDetailMinWidth = 600; +const double _bodyWindowTarget = 0.6; +const double _bodyWindowMinimum = 0.5; +const double _bodyAvailableMaximum = 0.75; + +/// The widest the list pane grows beside an open item: on a very wide window +/// (a 4K monitor) the extra width goes to the open item, not the list. +const double kListPaneMaxWidth = 440; + +/// Whether the window at [context] shows list and detail side by side. +bool showsListBesideDetail(BuildContext context) => + MediaQuery.sizeOf(context).width >= kListDetailMinWidth; + +/// The narrowest list pane a drag leaves. +const double kListPaneMinWidth = 240; + +/// The narrowest open item a drag leaves, beside the share of the window it +/// always keeps (so the shell's tab bar, floating over it, still fits). +const double kDetailPaneMinWidth = 320; +const double _listWindowMaximum = 0.6; + +/// How far a drag may resize the list pane for a [window] this wide and +/// [available] width for both panes and their divider; null when the window +/// is too small for any width but the default policy's. +({double min, double max})? listPaneWidthBounds( + double window, + double available, +) { + final bodyMinimum = math.max( + window * _bodyWindowMinimum, + kDetailPaneMinWidth, + ); + final maximum = math.min( + available - 1 - bodyMinimum, + window * _listWindowMaximum, + ); + if (maximum < kListPaneMinWidth) return null; + return (min: kListPaneMinWidth, max: maximum); +} + +/// The open item's width beside a list, for a [window] this wide and +/// [available] width for both panes and their divider. A [preferred] list +/// width (the operator's drag) replaces the default policy, clamped to +/// [listPaneWidthBounds]. +double listDetailBodyWidth( + double window, + double available, [ + double? preferred, +]) { + if (preferred != null) { + final bounds = listPaneWidthBounds(window, available); + if (bounds != null) { + return available - 1 - preferred.clamp(bounds.min, bounds.max); + } + } + // Target 60% of the full window. Keep at least half for the body while + // leaving a flexible share for native list controls on tighter windows. + final requestedMinimum = window * _bodyWindowMinimum; + final minimum = available > requestedMinimum + ? requestedMinimum + : available * _bodyWindowMinimum; + final maximum = math.max(minimum, available * _bodyAvailableMaximum); + final body = (window * _bodyWindowTarget).clamp(minimum, maximum); + // Past the list's cap, the open item takes the rest. + return math.max(body, available - 1 - kListPaneMaxWidth); +} + +/// The list pane's width beside an open item (see [listDetailBodyWidth]), +/// one divider excluded. +double listDetailListWidth( + double window, + double available, [ + double? preferred, +]) => math.max( + 0, + available - 1 - listDetailBodyWidth(window, available, preferred), +); diff --git a/app/lib/shell/list_pane_divider.dart b/app/lib/shell/list_pane_divider.dart new file mode 100644 index 00000000..e48d6b25 --- /dev/null +++ b/app/lib/shell/list_pane_divider.dart @@ -0,0 +1,187 @@ +import 'package:flutter/gestures.dart' show DragStartBehavior; +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; +import 'package:flutter/services.dart'; + +import '../ui/adaptive/host.dart'; + +/// How wide the divider's invisible grab area is, centred on its line. +const double kListPaneDividerGrabWidth = 12; + +/// How far one arrow key press moves the divider. +const double kListPaneDividerKeyStep = 16; + +/// The one-pixel line between a list and its open item. +class ListPaneDividerLine extends StatelessWidget { + const ListPaneDividerLine({super.key}); + + @override + Widget build(BuildContext context) => usesCupertinoHost(context) + ? Container( + width: 1, + color: CupertinoColors.separator.resolveFrom(context), + ) + : const VerticalDivider(width: 1); +} + +/// The grab area over [ListPaneDividerLine]: dragging it (mouse or touch) +/// resizes the list pane between [min] and [max], the arrow keys move it by +/// [kListPaneDividerKeyStep], and a double tap or click returns it to the +/// default policy. It shows a handle while hovered, focused or dragged. +class ListPaneDivider extends StatefulWidget { + const ListPaneDivider({ + super.key, + required this.width, + required this.min, + required this.max, + required this.onChanged, + required this.onChangeEnd, + required this.onReset, + }); + + /// The list pane's current width. + final double width; + final double min; + final double max; + + /// A new list width, live while dragging. + final ValueChanged onChanged; + + /// The drag or key press ended: the width is final. + final VoidCallback onChangeEnd; + final VoidCallback onReset; + + @override + State createState() => _ListPaneDividerState(); +} + +class _ListPaneDividerState extends State { + bool _hovered = false; + bool _focused = false; + // The unclamped width the pointer asks for since the drag began, so moving + // back past a bound picks up where the pointer is, not where it stopped. + double? _dragWidth; + + double _clamp(double value) => value.clamp(widget.min, widget.max); + + // The list is at the start: in a right-to-left layout a drag to the left + // widens it. + double _forward(double dx) => + Directionality.of(context) == TextDirection.rtl ? -dx : dx; + + void _dragStart(DragStartDetails _) => + setState(() => _dragWidth = widget.width); + + void _dragUpdate(DragUpdateDetails details) { + final width = (_dragWidth ?? widget.width) + _forward(details.delta.dx); + _dragWidth = width; + widget.onChanged(_clamp(width)); + } + + void _dragEnd() { + if (_dragWidth == null) return; + setState(() => _dragWidth = null); + widget.onChangeEnd(); + } + + // A width a key press sent that the panes have not rebuilt with yet, so + // presses quicker than frames add up. + double? _stepped; + + @override + void didUpdateWidget(covariant ListPaneDivider oldWidget) { + super.didUpdateWidget(oldWidget); + _stepped = null; + } + + void _step(double delta) { + final current = _stepped ?? widget.width; + final width = _clamp(current + delta); + if (width == current) return; + _stepped = width; + widget.onChanged(width); + widget.onChangeEnd(); + } + + KeyEventResult _key(FocusNode _, KeyEvent event) { + if (event is! KeyDownEvent && event is! KeyRepeatEvent) { + return KeyEventResult.ignored; + } + final key = event.logicalKey; + if (key == LogicalKeyboardKey.arrowRight || + key == LogicalKeyboardKey.arrowLeft) { + final right = key == LogicalKeyboardKey.arrowRight ? 1.0 : -1.0; + _step(_forward(right * kListPaneDividerKeyStep)); + return KeyEventResult.handled; + } + return KeyEventResult.ignored; + } + + String _describe(double width) => '${width.round()} pixels'; + + Color _handleColor(BuildContext context) => usesCupertinoHost(context) + ? CupertinoTheme.of(context).primaryColor + : Theme.of(context).colorScheme.primary; + + @override + Widget build(BuildContext context) { + final dragging = _dragWidth != null; + final active = _hovered || _focused || dragging; + final increased = _clamp(widget.width + kListPaneDividerKeyStep); + final decreased = _clamp(widget.width - kListPaneDividerKeyStep); + return Semantics( + identifier: 'list-detail-divider', + label: 'List width', + hint: 'Drag, or use the arrow keys, to resize the list', + slider: true, + value: _describe(widget.width), + increasedValue: _describe(increased), + decreasedValue: _describe(decreased), + onIncrease: increased == widget.width + ? null + : () => _step(kListPaneDividerKeyStep), + onDecrease: decreased == widget.width + ? null + : () => _step(-kListPaneDividerKeyStep), + child: Focus( + onKeyEvent: _key, + onFocusChange: (value) => setState(() => _focused = value), + child: MouseRegion( + cursor: SystemMouseCursors.resizeColumn, + onEnter: (_) => setState(() => _hovered = true), + onExit: (_) => setState(() => _hovered = false), + child: GestureDetector( + key: const ValueKey('list-detail-divider'), + behavior: HitTestBehavior.opaque, + // The slider semantics above stand for the drag. + excludeFromSemantics: true, + // The handle follows the pointer from where it went down. + dragStartBehavior: DragStartBehavior.down, + onHorizontalDragStart: _dragStart, + onHorizontalDragUpdate: _dragUpdate, + onHorizontalDragEnd: (_) => _dragEnd(), + onHorizontalDragCancel: _dragEnd, + onDoubleTap: widget.onReset, + child: Center( + child: AnimatedOpacity( + opacity: active ? 1 : 0, + duration: const Duration(milliseconds: 150), + child: Container( + width: 4, + decoration: BoxDecoration( + // A hovered or focused handle is a hint; it firms up + // while dragged. + color: _handleColor( + context, + ).withValues(alpha: dragging ? 1 : 0.5), + borderRadius: BorderRadius.circular(2), + ), + ), + ), + ), + ), + ), + ), + ); + } +} diff --git a/app/lib/shell/list_pane_widths.dart b/app/lib/shell/list_pane_widths.dart new file mode 100644 index 00000000..a5d8dfb5 --- /dev/null +++ b/app/lib/shell/list_pane_widths.dart @@ -0,0 +1,143 @@ +import 'package:flutter/widgets.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +/// Prefix of the persisted list-pane widths, one key per destination. +const listPaneWidthStoragePrefix = 'pipelines.next.listPaneWidth.v1.'; + +/// The persistence seam for list-pane widths the operator dragged, in logical +/// pixels per destination. Both directions may fail: a null read means +/// "nothing saved", a false write means "this session only". +abstract interface class ListPaneWidthStore { + Future read(String destination); + + /// Saves [width], or forgets the destination's width when it is null. + Future write(String destination, double? width); +} + +/// `shared_preferences` storage under [listPaneWidthStoragePrefix]. +class SharedPreferencesListPaneWidthStore implements ListPaneWidthStore { + const SharedPreferencesListPaneWidthStore(); + + @override + Future read(String destination) async { + try { + return (await SharedPreferences.getInstance()).getDouble( + '$listPaneWidthStoragePrefix$destination', + ); + } catch (_) { + return null; + } + } + + @override + Future write(String destination, double? width) async { + try { + final prefs = await SharedPreferences.getInstance(); + final key = '$listPaneWidthStoragePrefix$destination'; + return width == null + ? await prefs.remove(key) + : await prefs.setDouble(key, width); + } catch (_) { + return false; + } + } +} + +/// An in-memory store for tests, fixtures and panes outside a shell. +class MemoryListPaneWidthStore implements ListPaneWidthStore { + MemoryListPaneWidthStore([Map? values]) + : values = values ?? {}; + + final Map values; + + @override + Future read(String destination) async => values[destination]; + + @override + Future write(String destination, double? width) async { + if (width == null) { + values.remove(destination); + } else { + values[destination] = width; + } + return true; + } +} + +/// The list-pane widths the operator chose, per destination; a destination +/// without one uses the default policy (`listDetailListWidth`). +/// +/// A drag [preview]s widths live and [commit]s once; a window too small for +/// a saved width clamps it when laying out, never here, so the saved value +/// survives a small window. +class ListPaneWidths extends ChangeNotifier { + ListPaneWidths({ListPaneWidthStore? store}) + : _store = store ?? const SharedPreferencesListPaneWidthStore(); + + final ListPaneWidthStore _store; + final Map _widths = {}; + final Set _loaded = {}; + bool _disposed = false; + + /// The chosen width for [destination], null for the default policy. The + /// first ask loads the saved width and notifies when it arrives. + double? widthFor(String destination) { + if (_loaded.add(destination)) _load(destination); + return _widths[destination]; + } + + Future _load(String destination) async { + final saved = await _store.read(destination); + // A drag before the read finished wins over the saved value. + if (_disposed || saved == null || _widths.containsKey(destination)) { + return; + } + _widths[destination] = saved; + notifyListeners(); + } + + /// Shows [width] for [destination] without saving it. + void preview(String destination, double width) { + _loaded.add(destination); + if (_widths[destination] == width) return; + _widths[destination] = width; + notifyListeners(); + } + + /// Saves the destination's current width. + Future commit(String destination) async { + await _store.write(destination, _widths[destination]); + } + + /// Shows and saves [width] for [destination]. + Future set(String destination, double width) { + preview(destination, width); + return commit(destination); + } + + /// Returns [destination] to the default policy and forgets its width. + Future reset(String destination) async { + _loaded.add(destination); + if (_widths.remove(destination) != null) notifyListeners(); + await _store.write(destination, null); + } + + @override + void dispose() { + _disposed = true; + super.dispose(); + } +} + +/// Provides the shell's [ListPaneWidths] to the list-detail panes below it. +class ListPaneWidthsScope extends InheritedNotifier { + const ListPaneWidthsScope({ + super.key, + required ListPaneWidths widths, + required super.child, + }) : super(notifier: widths); + + static ListPaneWidths? maybeOf(BuildContext context) => context + .dependOnInheritedWidgetOfExactType() + ?.notifier; +} diff --git a/app/notes/list-pane-resize.md b/app/notes/list-pane-resize.md new file mode 100644 index 00000000..edb6c339 --- /dev/null +++ b/app/notes/list-pane-resize.md @@ -0,0 +1,16 @@ +# Resizable list pane + +The divider between a list and its open item (`ListDetailPanes`) drags to +resize the list, on every destination that splits (Pipelines, Runs, Chat). + +- `lib/shell/list_pane_divider.dart`: 12 px grab area over the 1 px line, + `resizeColumn` cursor, handle on hover/focus/drag, mouse and touch drag, + double tap resets, arrow keys step 16 px, slider semantics. +- `lib/shell/list_pane_widths.dart`: per-destination widths, saved in + SharedPreferences under `pipelines.next.listPaneWidth.v1.` + on drag end; the shell owns one and the bar over the list follows it. +- `lib/shell/list_detail_policy.dart`: `listPaneWidthBounds` (list >= 240, + open item >= max(half the window, 320), list <= 60% of the window). A saved + width is clamped when laid out, never overwritten by a small window. +- Below `kListDetailMinWidth` nothing changes. +- Capture kit: new `hover=` and `drag=` steps. Evidence: /tmp/split-drag/. diff --git a/app/test/shell/list_pane_resize_test.dart b/app/test/shell/list_pane_resize_test.dart new file mode 100644 index 00000000..39073d7d --- /dev/null +++ b/app/test/shell/list_pane_resize_test.dart @@ -0,0 +1,222 @@ +import 'dart:ui' show SemanticsAction; + +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; +import 'package:flutter/services.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/shell/adaptive_shell.dart'; +import 'package:pipelines_app/shell/destination.dart'; +import 'package:pipelines_app/shell/list_detail.dart'; +import 'package:pipelines_app/shell/list_pane_divider.dart'; +import 'package:pipelines_app/shell/list_pane_widths.dart'; +import 'package:pipelines_app/shell/shell_bar.dart'; + +/// Dragging the divider between a list and its open item resizes the list, +/// within bounds, per destination, remembered on this device. +void main() { + Future setSize(WidgetTester tester, Size size) async { + tester.view.physicalSize = size; + tester.view.devicePixelRatio = 1; + addTearDown(tester.view.reset); + } + + Widget panes(String name) => ListDetailPanes( + list: ShellBar(child: ListView(children: [Text('$name list')])), + detail: Center(child: Text('$name detail')), + ); + + Widget shell({ + required bool cupertino, + required ListPaneWidthStore store, + AppDestination destination = AppDestination.runs, + }) { + final app = AdaptiveShell( + cupertino: cupertino, + destination: destination, + listPaneWidthStore: store, + destinationBodies: { + AppDestination.runs: (_) => panes('runs'), + AppDestination.chat: (_) => panes('chat'), + }, + ); + return cupertino ? CupertinoApp(home: app) : MaterialApp(home: app); + } + + Future settle(WidgetTester tester) async { + await tester.pump(); + await tester.pump(); + await tester.pump(const Duration(milliseconds: 300)); + } + + double listWidth(WidgetTester tester) => + tester.getSize(find.byKey(const ValueKey('list-detail-list'))).width; + double bodyWidth(WidgetTester tester) => + tester.getSize(find.byKey(const ValueKey('list-detail-body'))).width; + // The shell's top bar, narrowed to the list pane. + double shellBarWidth(WidgetTester tester) => tester + .getSize( + find + .descendant( + of: find.byType(ListPaneWidth), + matching: find.byType(SizedBox), + ) + .first, + ) + .width; + final divider = find.byKey(const ValueKey('list-detail-divider')); + + for (final cupertino in [false, true]) { + final host = cupertino ? 'Cupertino' : 'Material'; + + testWidgets('$host: dragging resizes the list live, the shell bar ' + 'follows, and the width clamps', (tester) async { + await setSize(tester, const Size(1200, 800)); + final store = MemoryListPaneWidthStore(); + await tester.pumpWidget(shell(cupertino: cupertino, store: store)); + await settle(tester); + expect(listWidth(tester), kListPaneMaxWidth); + expect(shellBarWidth(tester), kListPaneMaxWidth); + + final gesture = await tester.startGesture(tester.getCenter(divider)); + await gesture.moveBy(const Offset(-50, 0)); + await gesture.moveBy(const Offset(-50, 0)); + await tester.pump(); + // Live, before the drag ends; nothing saved yet. + expect(listWidth(tester), closeTo(340, 0.5)); + expect(shellBarWidth(tester), closeTo(340, 0.5)); + expect(bodyWidth(tester), closeTo(1200 - 1 - 340, 0.5)); + expect(store.values, isEmpty); + await gesture.up(); + await tester.pump(); + expect(store.values['runs'], closeTo(340, 0.5)); + + // Never narrower than the minimum... + await tester.drag(divider, const Offset(-400, 0)); + await settle(tester); + expect(listWidth(tester), kListPaneMinWidth); + // ...nor wider than leaves the open item half the window. + await tester.drag(divider, const Offset(900, 0)); + await settle(tester); + expect(listWidth(tester), closeTo(1200 - 1 - 600, 0.5)); + expect(shellBarWidth(tester), closeTo(599, 0.5)); + expect(store.values['runs'], closeTo(599, 0.5)); + }); + + testWidgets('$host: a double tap returns to the default policy', ( + tester, + ) async { + await setSize(tester, const Size(1200, 800)); + final store = MemoryListPaneWidthStore({'runs': 300}); + await tester.pumpWidget(shell(cupertino: cupertino, store: store)); + await settle(tester); + expect(listWidth(tester), 300); + + await tester.tap(divider); + await tester.pump(const Duration(milliseconds: 50)); + await tester.tap(divider); + await settle(tester); + expect(listWidth(tester), kListPaneMaxWidth); + expect(shellBarWidth(tester), kListPaneMaxWidth); + expect(store.values, isEmpty); + }); + + testWidgets('$host: widths are kept per destination and restored', ( + tester, + ) async { + await setSize(tester, const Size(1200, 800)); + final store = MemoryListPaneWidthStore({'runs': 300, 'chat': 500}); + await tester.pumpWidget(shell(cupertino: cupertino, store: store)); + await settle(tester); + expect(listWidth(tester), 300); + expect(shellBarWidth(tester), 300); + + await tester.pumpWidget( + shell( + cupertino: cupertino, + store: store, + destination: AppDestination.chat, + ), + ); + await settle(tester); + final chatList = find.byKey(const ValueKey('list-detail-list')).last; + expect(tester.getSize(chatList).width, 500); + expect(shellBarWidth(tester), 500); + + // A destination nobody resized keeps the default policy. + final fresh = MemoryListPaneWidthStore({'chat': 500}); + await tester.pumpWidget(const SizedBox()); + await tester.pumpWidget(shell(cupertino: cupertino, store: fresh)); + await settle(tester); + expect(listWidth(tester), kListPaneMaxWidth); + }); + + testWidgets('$host: a small window clamps the saved width without ' + 'overwriting it', (tester) async { + await setSize(tester, const Size(1000, 800)); + final store = MemoryListPaneWidthStore({'runs': 600}); + await tester.pumpWidget(shell(cupertino: cupertino, store: store)); + await settle(tester); + expect(listWidth(tester), closeTo(1000 - 1 - 500, 0.5)); + expect(shellBarWidth(tester), closeTo(499, 0.5)); + expect(store.values['runs'], 600); + + await setSize(tester, const Size(1600, 800)); + await settle(tester); + expect(listWidth(tester), 600); + expect(shellBarWidth(tester), 600); + }); + + testWidgets('$host: arrow keys move the divider and it reads as a ' + 'slider', (tester) async { + await setSize(tester, const Size(1200, 800)); + final store = MemoryListPaneWidthStore(); + final semantics = tester.ensureSemantics(); + await tester.pumpWidget(shell(cupertino: cupertino, store: store)); + await settle(tester); + Focus.of(tester.element(divider)).requestFocus(); + await tester.pump(); + + await tester.sendKeyEvent(LogicalKeyboardKey.arrowLeft); + await settle(tester); + expect(listWidth(tester), kListPaneMaxWidth - kListPaneDividerKeyStep); + expect(store.values['runs'], kListPaneMaxWidth - kListPaneDividerKeyStep); + await tester.sendKeyEvent(LogicalKeyboardKey.arrowRight); + await tester.sendKeyEvent(LogicalKeyboardKey.arrowRight); + await settle(tester); + expect(listWidth(tester), kListPaneMaxWidth + kListPaneDividerKeyStep); + + expect( + tester.getSemantics(divider), + matchesSemantics( + label: 'List width', + hint: 'Drag, or use the arrow keys, to resize the list', + value: '456 pixels', + increasedValue: '472 pixels', + decreasedValue: '440 pixels', + isSlider: true, + isFocusable: true, + isFocused: true, + hasIncreaseAction: true, + hasDecreaseAction: true, + hasFocusAction: true, + ), + ); + tester.semantics.performAction( + find.semantics.byLabel('List width'), + SemanticsAction.decrease, + ); + await settle(tester); + expect(listWidth(tester), kListPaneMaxWidth); + semantics.dispose(); + }); + } + + test('bounds: list at least 240, open item at least half the window', () { + expect(listPaneWidthBounds(1200, 1200), (min: 240.0, max: 599.0)); + expect(listPaneWidthBounds(600, 600), (min: 240.0, max: 279.0)); + expect(listPaneWidthBounds(500, 500), isNull); + expect(listDetailListWidth(1200, 1200, 100), 240); + expect(listDetailListWidth(1200, 1200, 300), 300); + expect(listDetailListWidth(500, 500, 300), listDetailListWidth(500, 500)); + }); +} diff --git a/app/tool/capture/README.md b/app/tool/capture/README.md index 0217e94b..64c0f63e 100644 --- a/app/tool/capture/README.md +++ b/app/tool/capture/README.md @@ -47,6 +47,8 @@ In JSON, a step can also set `wait` (ms), `timeout`, `name`, `ms` and `frames`. | `type=text` | type into the focused field (or the first visible one) | | `press=Enter` | press a key: Enter, Escape, Tab, Backspace, ArrowUp or ArrowDown | | `scroll=600` | scroll with the mouse wheel at the centre (JSON `at` sets a target, `dx` a horizontal delta, `repeat` and `gap` a run of ticks) | +| `hover=` | move the mouse onto the target without pressing (hover states) | +| `drag=>dx,dy` | press on the target, move by dx,dy in `steps` (12) moves `gap` (16) ms apart, release (JSON `dx`, `dy`, `steps`, `gap`; `hold: true` keeps the button down to capture mid-drag) | | `size=WxH` | resize without reloading | | `labels=name` | write the visible semantics labels, keys and rects to JSON | | `film=` | screencast a click for `--film-ms` (900) and write the frames plus a contact sheet | diff --git a/app/tool/capture/capture.mjs b/app/tool/capture/capture.mjs index f2fbd71c..d0e24026 100644 --- a/app/tool/capture/capture.mjs +++ b/app/tool/capture/capture.mjs @@ -22,7 +22,8 @@ options: --script --size WxH (880x1000) --platform material|cuperti --params steps: open=[@WxH] wait= shot= click= waitfor= type= press= scroll= size=WxH - film= labels= eval= expect= + film= labels= eval= expect= hover= + drag=>, (JSON: drag, dx, dy, steps, gap, hold) target: