diff --git a/app/lib/features/terminal/terminal_window.dart b/app/lib/features/terminal/terminal_window.dart index 1f47033f..de4a5f81 100644 --- a/app/lib/features/terminal/terminal_window.dart +++ b/app/lib/features/terminal/terminal_window.dart @@ -17,7 +17,7 @@ const _terminalContent = 'terminal'; /// /// [TerminalLayout] stays the terminal's own state (shown, panel or float): /// showing it in float mode opens or shows the window, hiding minimises it, -/// and the window's Minimise and Close hide the terminal. +/// and the window's X (minimise) hides the terminal. class TerminalWindows { TerminalWindows({ required this.manager, @@ -110,7 +110,7 @@ class TerminalWindows { if (legacy && layout.maximized) manager.setMaximized(entry.id, true); } - /// The window's Minimise or Close (or the windows' own show and hide) + /// The window's X or Minimise (or the windows' own show and hide) /// hides the terminal. void _windowsChanged() { if (!_started || !_ready || _syncing || !_wanted) return; diff --git a/app/lib/shell/windows/window_entry.dart b/app/lib/shell/windows/window_entry.dart index 83fe7afe..1d36b154 100644 --- a/app/lib/shell/windows/window_entry.dart +++ b/app/lib/shell/windows/window_entry.dart @@ -37,7 +37,7 @@ class WindowEntry { /// The saved frame; it is drawn fitted inside the window area. final Rect frame; - /// Hidden by its minimise button; still listed and shown again with its + /// Hidden by the title bar's X; still listed and shown again with its /// group. final bool minimized; final bool maximized; diff --git a/app/lib/shell/windows/window_frame.dart b/app/lib/shell/windows/window_frame.dart index 61240ef6..bce9e305 100644 --- a/app/lib/shell/windows/window_frame.dart +++ b/app/lib/shell/windows/window_frame.dart @@ -11,8 +11,9 @@ double windowTitleBarHeight(BuildContext context) => MediaQuery.textScalerOf(context).scale(40).clamp(40.0, 64.0); /// A floating window's card and title bar: the title (drag to move, double -/// click to maximise), the kind's actions, then Minimise, Maximise and -/// Close. The content is drawn over the card's body by the window's +/// click to maximise), the kind's actions, then Maximise and the X. The X +/// minimises: it hides the window and keeps its state, like the chord does +/// in reverse. The content is drawn over the card's body by the window's /// navigator. class WindowFrame extends StatelessWidget { const WindowFrame({ @@ -25,7 +26,6 @@ class WindowFrame extends StatelessWidget { required this.onMoveEnd, required this.onMinimize, required this.onToggleMaximized, - required this.onClose, }); final String title; @@ -36,9 +36,10 @@ class WindowFrame extends StatelessWidget { /// The drag's delta and the pointer's global position. final void Function(Offset delta, Offset globalPosition) onMove; final VoidCallback onMoveEnd; + + /// The X: hides the window, keeping it listed and its state. final VoidCallback onMinimize; final VoidCallback onToggleMaximized; - final VoidCallback onClose; @override Widget build(BuildContext context) { @@ -69,11 +70,6 @@ class WindowFrame extends StatelessWidget { onPressed: action.onPressed, icon: Icon(action.icon), ), - IconButton( - tooltip: 'Minimise', - onPressed: onMinimize, - icon: const Icon(Icons.minimize), - ), IconButton( tooltip: maximized ? 'Restore size' : 'Maximise', onPressed: onToggleMaximized, @@ -82,8 +78,8 @@ class WindowFrame extends StatelessWidget { ), ), IconButton( - tooltip: 'Close', - onPressed: onClose, + tooltip: 'Minimise', + onPressed: onMinimize, icon: const Icon(Icons.close), ), const SizedBox(width: 4), diff --git a/app/lib/shell/windows/window_kind.dart b/app/lib/shell/windows/window_kind.dart index 3a98499d..2f287885 100644 --- a/app/lib/shell/windows/window_kind.dart +++ b/app/lib/shell/windows/window_kind.dart @@ -2,7 +2,7 @@ import 'package:flutter/widgets.dart'; import 'window_entry.dart'; -/// One action in a window's title bar, before Minimise and Close (Dock on a +/// One action in a window's title bar, before Maximise and the X (Dock on a /// chat, a kind's own menu). class WindowAction { const WindowAction({ @@ -42,7 +42,7 @@ abstract class WindowKind { /// The window's content, below the title bar. Widget build(BuildContext context, WindowEntry entry); - /// Title-bar actions before Minimise and Close. + /// Title-bar actions before Maximise and the X. List actions(BuildContext context, WindowEntry entry) => const []; @@ -57,7 +57,7 @@ abstract class WindowKind { /// as its window takes focus. The default leaves it on the window. void focusContent(WindowEntry entry) {} - /// Called after the user closes the window (the X). + /// Called after the window is closed (Dock, Close all, a chat's /close). void closed(WindowEntry entry) {} /// Validates a saved window's [WindowEntry.data]; null drops the window. diff --git a/app/lib/shell/windows/window_layer.dart b/app/lib/shell/windows/window_layer.dart index efaffc28..427e2847 100644 --- a/app/lib/shell/windows/window_layer.dart +++ b/app/lib/shell/windows/window_layer.dart @@ -259,7 +259,6 @@ class _WindowLayerState extends State onMinimize: () => manager.setMinimized(_id, true), onToggleMaximized: () => manager.setMaximized(_id, !entry.maximized), - onClose: () => manager.close(_id), ), ), ), diff --git a/app/lib/ui/motion/container_transform_flight.dart b/app/lib/ui/motion/container_transform_flight.dart index f8a1b377..6dbead2e 100644 --- a/app/lib/ui/motion/container_transform_flight.dart +++ b/app/lib/ui/motion/container_transform_flight.dart @@ -229,11 +229,14 @@ class _Frame { required bool tracking, }) { const curve = Curves.fastOutSlowIn; - // Played backwards in time, the same easing reads as the item settling. + // Closing reads `t` from 1 to 0, so easeIn of `t` is a shrink that + // decelerates in time and starts on the first frame. The time-reversed + // fastOutSlowIn barely moved for its first ~60 ms, which read as Back + // doing nothing. final grown = tracking ? t : closing - ? curve.flipped.transform(t) + ? Curves.easeInCubic.transform(t) : curve.transform(t); // Opening covers the item first and shows the page late; closing hides // the page first and uncovers the item late. diff --git a/app/notes/chat-back-start.md b/app/notes/chat-back-start.md new file mode 100644 index 00000000..5a6d17be --- /dev/null +++ b/app/notes/chat-back-start.md @@ -0,0 +1,54 @@ +# Chat Back starts immediately (phone) + +## Finding + +Static reading of the phone chat path (`DetailPageHost`, `ContainerTransformPageRoute`, +`ContainerTransformFlight`, the chat screen's `_back`, the shell's back handling) found no +awaited work before the pop. Draft, scroll and transcript saves run fire-and-forget or in +`dispose`, after the reverse animation. `DetailPageHost`'s `onClosed` runs when the route is +disposed, so it cannot delay the pop. + +The delay the user sees is the close curve. Closing used `Curves.fastOutSlowIn.flipped` +against the animation value, which barely moves for its first ~60 ms. The page sat still +after Back, then began to shrink. + +## Change + +`lib/ui/motion/container_transform_flight.dart`: the closing shrink uses +`Curves.easeInCubic.transform(t)` on the reverse animation value. That is a shrink that starts +on the first frame and decelerates into the row. Opening is unchanged. The reverse duration +stays at `Motion.containerTransformReverse` = 250 ms (≤300 ms). + +## Measured (widget test, fake frame clock, 390x844, 16 ms per frame) + +Share of the page's shrink travel completed after each frame following the system Back +(`handlePopRoute` then `pump`). The first frame after the pop only starts the ticker, so it +reads 0 in both builds. + +| Elapsed after pop | Before | After | +| --- | ---: | ---: | +| 16 ms | 0.0% | 0.0% | +| 32 ms | 1.0% | 15.7% | +| 48 ms | 4.6% | 30.7% | +| 64 ms | 12.1% | 44.1% | +| 80 ms | 25.2% | 56.4% | + +The Back route is no longer current, and its animation is `reverse`, after the first pump +in both builds. Route change was already synchronous. + +## Focused tests + +Command: `tool/memwatch/full.sh 'test/ui/motion/container_transform_back_start_test.dart test/ui/motion/container_transform_route_test.dart test/shell/detail_page_test.dart test/features/chat/chat_open_transition_test.dart'` +Result: 15 passed, 0 failed (peak 1284 MB, 11 s). + +- New regression `container_transform_back_start_test.dart`: system Back changes the route + in one pump, and the page is more than 10% shrunk 16 ms later. The owner's close work + awaits a future that never completes, and Back still starts. Against the old curve this + test fails (shrink 0.99%). +- `tool/analyze.sh`: clean. + +## Not verified + +- `tool/chat_back_latency_probe.mjs` (browser) was not run; UI capture belongs to ui-review. +- Phone device timing was not measured (no device test ran). +- Leaving the chat list (tab-root Back) was read, not measured: it calls `_select` synchronously. diff --git a/app/notes/chat-floating-pane.md b/app/notes/chat-floating-pane.md index e17dcb38..9f982383 100644 --- a/app/notes/chat-floating-pane.md +++ b/app/notes/chat-floating-pane.md @@ -15,13 +15,14 @@ every destination and come back at app start without Chat being opened. chat's window last was, else at the default frame stepped 32 px per chat window already open. - **Window**: drag the title bar to move, the lower right corner to resize, - double click the title to maximise. The title bar has Dock, Minimise, - Maximise and Close. + double click the title to maximise. The title bar has Dock, Maximise and + the X. - **Dock** puts the chat back into the tiling, right of the active pane. When the Chat destination is not built it opens the chat there instead. - - **Minimise** hides that window; the chord brings it back. - - **Close (X)** closes the window and returns nothing to the tiling. The chat - itself is not closed on the server. + - **X** (tooltip and semantics: Minimise) hides that window, keeping its state; + it stays listed in the Windows menu and the chord brings it back. It never + closes the window, the chat or the tiling: nothing returns to the tiling. + The chat itself is not closed on the server. - **Chord**: Alt+Y, Ctrl+Y, and Cmd+Y on Apple platforms (`chatFloatShortcut`). With chat windows open it hides or shows all of them. With none it floats the active tiled pane, when that pane can float and Chat has the keyboard; diff --git a/app/notes/floating-windows.md b/app/notes/floating-windows.md index f02bd8c5..fe6370be 100644 --- a/app/notes/floating-windows.md +++ b/app/notes/floating-windows.md @@ -15,7 +15,8 @@ mode (below). `FloatingLayer`, the overlay the old windows used, is gone. - `WindowHost`: the windows as plain children of the terminal stage's stack, in the shell page (not an overlay above it), outside every destination. - `WindowLayer` / `WindowFrame`: one window's card, title bar (drag, double - click to maximise, kind actions, Minimise, Maximise, Close) and resize corner. + click to maximise, kind actions, Maximise, the X = minimise) and resize corner. + There is no separate Minimise button; the X hides the window and keeps it. - `WindowNavigator`: each window's own page stack. - `WindowFocus`: a focus scope per window; the keyboard follows the top window and returns to what had it when the last one hides. @@ -73,8 +74,8 @@ the device, not a server) and `TerminalWindows`, which keeps it in step with float, panel height); the bottom panel is still a shell panel. - Showing the terminal in float mode opens or shows the window; hiding it - (Alt+T, Ctrl+`, the options menu) minimises it. The window's Minimise and - Close both hide the terminal. Its shells and tabs live in `TerminalHub`, so + (Alt+T, Ctrl+`, the options menu) minimises it. The window's X (minimise) + hides the terminal. Its shells and tabs live in `TerminalHub`, so nothing is lost either way, and the window comes back where it was. - The frame and maximised state are the window system's. The first window takes the ones `pipelines.terminal-layout.v1` saved before; that record is diff --git a/app/notes/window-x-minimises.md b/app/notes/window-x-minimises.md new file mode 100644 index 00000000..d933b110 --- /dev/null +++ b/app/notes/window-x-minimises.md @@ -0,0 +1,55 @@ +# Window X minimises (no separate Minimise button) + +## Change + +- The title bar of a floating window is now: kind actions (Dock on a chat), + Maximise / Restore size, then the X. +- The X hides the window and keeps its state, exactly as Minimise did. Its + tooltip and semantics are `Minimise`. It keeps the X glyph (`Icons.close`). +- The X never calls the kind's `closed` hook, so a chat window keeps its chat + open on the server and returns nothing to the tiling. +- `WindowFrame` no longer takes `onClose`; `WindowLayer` wires the X to + `manager.setMinimized(id, true)`. +- Unchanged: the chord (Alt+Y) shows hidden chat windows; the Windows menu + still lists minimised windows with a minimise mark and shows them on choice; + Show all, Minimise all and Close all stay in that menu. Terminal windows + still hide the terminal when their window is hidden by the X. + +Changed paths (under `app/`): + +- `lib/shell/windows/window_frame.dart`, `window_layer.dart`, `window_kind.dart`, + `window_entry.dart` (comments and the frame's parameters) +- `lib/features/terminal/terminal_window.dart` (comment only) +- `test/shell/windows/window_host_test.dart`, `window_layering_test.dart` +- `test/features/chat/chat_floating_pane_test.dart` +- `test/features/terminal/terminal_surface_test.dart` +- `notes/floating-windows.md`, `notes/chat-floating-pane.md` + +## Focused results + +- `tool/memwatch/full.sh 'test/shell/windows/window_host_test.dart + test/shell/windows/window_layering_test.dart + test/shell/windows/window_conveniences_test.dart + test/features/chat/chat_floating_pane_test.dart + test/features/terminal/terminal_surface_test.dart'`: + PASS, 72 passed, 0 failed, 0 skipped, exit 0. +- `tool/analyze.sh`: clean, exit 0. +- Not run: the full suite (the land gate runs it). No Cupertino code or tests + touched. + +## Affected states (widget-test coverage only) + +- Window title bar: no `Close` tooltip; `Minimise` on the X; `Maximise` / + `Restore size` unchanged. +- Chat window: X hides it; the chat stays open, is not docked and sends no + `chat_close`; the chord shows it again with the same frame and composer. +- Probe window: X keeps the entry (minimised), the content state survives, and + the group toggle brings it back. +- Terminal float window: X hides the terminal and keeps its tabs; the chord + shows it again at the same frame. + +## Limitations + +- No browser or device capture here; `ui-review` owns the title-bar captures. +- The X glyph with a Minimise tooltip is a deliberate choice; a minimise glyph + would be a one-line change in `window_frame.dart` if preferred. diff --git a/app/test/features/chat/chat_floating_pane_test.dart b/app/test/features/chat/chat_floating_pane_test.dart index ceb1a11e..75a77e7d 100644 --- a/app/test/features/chat/chat_floating_pane_test.dart +++ b/app/test/features/chat/chat_floating_pane_test.dart @@ -390,19 +390,24 @@ void main() { await app.stop(tester); }); - testWidgets('X closes the window and returns nothing to the tiling', ( - tester, - ) async { + testWidgets('X minimises the window: the chat stays open, returns nothing ' + 'to the tiling, and the chord brings the window back', (tester) async { await _saved('a', 'b'); final app = _App(_Store()); await app.start(tester); await _menu(tester, 'b', 'Float (Alt+Y)'); - await tester.tap(find.byTooltip('Close')); + await tester.tap(find.byTooltip('Minimise')); await tester.pumpAndSettle(); - expect(app.floating, isEmpty); + // Still a window, hidden; not closed and not docked. + expect(app.floating, ['b']); + expect(app.windows.windows.single.minimized, isTrue); + expect(_shown('Chat b'), findsNothing); expect(_workspace(tester).panes.map((p) => p.sessionId), ['a']); - expect(_thread('b'), findsNothing); expect(app.gateway.calls.where((c) => c.type == 'chat_close'), isEmpty); + await _chord(tester); + expect(_shown('Chat b'), findsOneWidget); + expect(_thread('b').hitTestable(), findsOneWidget); + expect(app.floating, ['b']); await app.stop(tester); }); diff --git a/app/test/features/terminal/terminal_surface_test.dart b/app/test/features/terminal/terminal_surface_test.dart index fff954a5..f029887d 100644 --- a/app/test/features/terminal/terminal_surface_test.dart +++ b/app/test/features/terminal/terminal_surface_test.dart @@ -167,10 +167,12 @@ void main() { expect(floatFinder, findsOneWidget); expect(frame().size, start.size + const Offset(80, 50)); - await tester.tap(find.byTooltip('Close')); + // The X minimises too: the window stays listed, hidden, with its shells. + await tester.tap(find.byTooltip('Minimise')); await tester.pumpAndSettle(); expect(layout.visible, isFalse); - expect(manager.windows, isEmpty); + expect(manager.windows.single.minimized, isTrue); + expect(floatFinder, findsNothing); expect(hub.tabs, hasLength(2)); await ctrlBacktick(tester); expect(floatFinder, findsOneWidget); diff --git a/app/test/shell/windows/window_host_test.dart b/app/test/shell/windows/window_host_test.dart index 75e5574e..a16c6902 100644 --- a/app/test/shell/windows/window_host_test.dart +++ b/app/test/shell/windows/window_host_test.dart @@ -25,9 +25,11 @@ void main() { const Rect.fromLTWH(100, 80, 360, 420), ); expect(find.byTooltip('Probe action'), findsOneWidget); - for (final tip in ['Minimise', 'Maximise', 'Close']) { + for (final tip in ['Minimise', 'Maximise']) { expect(find.byTooltip(tip), findsOneWidget); } + // There is no separate Minimise button: the X is the one minimise. + expect(find.byTooltip('Close'), findsNothing); expect(find.text('sheet').hitTestable(), findsOneWidget); // The title bar, the content and the app behind all keep their // semantics (a page route's barrier hides what is behind it). @@ -172,14 +174,30 @@ void main() { expect(find.text('typed'), findsOneWidget); }); - testWidgets('X closes the window', (tester) async { + testWidgets('X minimises the window and never closes it', (tester) async { final entry = manager.open('probe', 'a'); await pumpProbe(tester, manager); - await tester.tap(find.byTooltip('Close')); + await tester.enterText(find.byKey(const ValueKey('a-field')), 'kept'); + final state = tester.state(find.byType(ProbeContent)); + await tester.tap(find.byTooltip('Minimise')); await tester.pumpAndSettle(); - expect(manager.windows, isEmpty); - expect(find.byType(ProbeContent, skipOffstage: false), findsNothing); - expect((manager.kinds['probe']! as ProbeWindowKind).closed_, [entry.id]); + expect(manager.windows.single.id, entry.id); + expect(manager.byId(entry.id)!.minimized, isTrue); + expect(find.text('Probe a').hitTestable(), findsNothing); + // Not a close: the kind's closed hook does not run, and the content + // stays alive with its state. + expect((manager.kinds['probe']! as ProbeWindowKind).closed_, isEmpty); + expect( + tester.state( + find.byType(ProbeContent, skipOffstage: false), + ), + same(state), + ); + // Listed and brought back by the group, as Minimise always was. + manager.toggleGroup('probe'); + await tester.pumpAndSettle(); + expect(find.text('Probe a').hitTestable(), findsOneWidget); + expect(find.text('kept'), findsOneWidget); }); testWidgets('pressing a window brings it to the top and keeps both alive', ( diff --git a/app/test/shell/windows/window_layering_test.dart b/app/test/shell/windows/window_layering_test.dart index ff2dbac5..a60d21e6 100644 --- a/app/test/shell/windows/window_layering_test.dart +++ b/app/test/shell/windows/window_layering_test.dart @@ -209,14 +209,17 @@ void main() { probeTooltipColor, ); - await mouse.moveTo(tester.getCenter(find.byTooltip('Close').last)); + await mouse.moveTo(tester.getCenter(find.byTooltip('Minimise').last)); await tester.pumpAndSettle(const Duration(seconds: 1)); - expect(find.text('Close'), findsOneWidget); + expect(find.text('Minimise'), findsOneWidget); // Not clipped to the window: tooltips paint in an overlay as large // as the app. final overlay = tester.renderObject( find - .ancestor(of: find.text('Close'), matching: find.byType(Overlay)) + .ancestor( + of: find.text('Minimise'), + matching: find.byType(Overlay), + ) .first, ); expect(overlay.size, const Size(1280, 800)); diff --git a/app/test/ui/motion/container_transform_back_start_test.dart b/app/test/ui/motion/container_transform_back_start_test.dart new file mode 100644 index 00000000..455c8c41 --- /dev/null +++ b/app/test/ui/motion/container_transform_back_start_test.dart @@ -0,0 +1,141 @@ +import 'dart:async'; + +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/shell/destination.dart'; +import 'package:pipelines_app/shell/detail_page.dart'; +import 'package:pipelines_app/shell/shell_bar.dart'; +import 'package:pipelines_app/ui/motion/container_transform_flight.dart'; +import 'package:pipelines_app/ui/motion/container_transform_source.dart'; +import 'package:pipelines_app/ui/motion/motion.dart'; + +const _screen = Size(390, 844); + +/// A phone-style owner: its selected row opens a detail page that grows from +/// the row, as the chat screen's page does. +class _Owner extends StatefulWidget { + const _Owner({required this.selection, required this.sources}); + + final ValueNotifier selection; + final ContainerTransformSources sources; + + @override + State<_Owner> createState() => _OwnerState(); +} + +class _OwnerState extends State<_Owner> { + final DetailPageHost page = DetailPageHost(); + + /// Stands in for work the owner might await when the page closes (a draft + /// or scroll save). It never completes, so any pop that waited on it would + /// never start. + final Completer neverSaved = Completer(); + int closed = 0; + + @override + void dispose() { + page.dispose(); + super.dispose(); + } + + @override + Widget build(BuildContext context) => ValueListenableBuilder( + valueListenable: widget.selection, + builder: (context, selected, _) { + page.sync( + context, + selected: selected != null, + destination: AppDestination.chat, + growFrom: widget.sources.link(() => widget.selection.value), + onClosed: () { + closed++; + unawaited(_save()); + widget.selection.value = null; + }, + builder: (context) => + ShellBar(title: 'Chat', child: const Text('chat body')), + ); + return ContainerTransformScope( + sources: widget.sources, + child: const Column( + children: [ + SizedBox(height: 200), + ContainerTransformSource( + id: '7', + color: Color(0xFFE3F2FD), + child: SizedBox( + key: Key('row-7'), + height: 72, + child: Text('row 7'), + ), + ), + ], + ), + ); + }, + ); + + Future _save() => neverSaved.future; +} + +Future _pumpOwner( + WidgetTester tester, + ValueNotifier selection, + ContainerTransformSources sources, +) async { + tester.view.physicalSize = _screen; + tester.view.devicePixelRatio = 1; + addTearDown(tester.view.reset); + await tester.pumpWidget( + MaterialApp( + home: _Owner(selection: selection, sources: sources), + ), + ); +} + +void main() { + testWidgets( + 'system Back changes the route in one frame and shrinks the page at once', + (tester) async { + final selection = ValueNotifier(null); + final sources = ContainerTransformSources(); + await _pumpOwner(tester, selection, sources); + selection.value = '7'; + await tester.pumpAndSettle(); + + final row = tester.getRect( + find.byKey(const Key('row-7'), skipOffstage: false), + ); + final route = ModalRoute.of( + tester.element(find.byKey(containerTransformSurfaceKey)), + )!; + expect(route.isCurrent, isTrue); + + // The owner's close work never completes, yet Back starts at once. + await tester.binding.handlePopRoute(); + await tester.pump(); + expect(route.isCurrent, isFalse); + expect(route.animation!.status, AnimationStatus.reverse); + + // Two frames after the pop the page is visibly shrinking toward the row. + await tester.pump(const Duration(milliseconds: 16)); + final height = tester + .getRect(find.byKey(containerTransformSurfaceKey)) + .height; + final travel = _screen.height - row.height; + final shrunk = (_screen.height - height) / travel; + expect(shrunk, greaterThan(0.1)); + expect(shrunk, lessThan(1)); + + // The reverse stays within the standard Material container transform. + expect( + Motion.containerTransformReverse, + lessThanOrEqualTo(const Duration(milliseconds: 300)), + ); + await tester.pumpAndSettle(); + expect(find.text('chat body'), findsNothing); + expect(selection.value, isNull); + expect(tester.state<_OwnerState>(find.byType(_Owner)).closed, 1); + }, + ); +}