From de0c06cec19bd5ca76f921719de1e7f4e68d39f8 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sat, 7 Nov 2026 00:46:02 +0000 Subject: [PATCH 1/2] Chat: slash focuses the composer; Ctrl+Tab over one pane toggles recent chats A bare / typed outside any text field puts the keyboard in the active chat's composer through the existing focus request, after the frame, so the slash is not typed into it. Ctrl+Tab with a single pane now swaps in the chat shown before the current one and back; two or more panes keep cycling panes. The visit remembers its shown chats most-recent-first, dropping closed, /new-moved and other-server ids. --- app/lib/features/chat/chat_screen_keys.dart | 96 +++++++++ .../features/chat/chat_screen_workspace.dart | 26 +-- app/lib/features/chat/screen.dart | 10 +- app/notes/chat-keyboard-focus.md | 26 +++ .../chat/chat_keyboard_focus_test.dart | 190 ++++++++++++++++++ 5 files changed, 335 insertions(+), 13 deletions(-) create mode 100644 app/lib/features/chat/chat_screen_keys.dart create mode 100644 app/notes/chat-keyboard-focus.md create mode 100644 app/test/features/chat/chat_keyboard_focus_test.dart diff --git a/app/lib/features/chat/chat_screen_keys.dart b/app/lib/features/chat/chat_screen_keys.dart new file mode 100644 index 00000000..2d4535a9 --- /dev/null +++ b/app/lib/features/chat/chat_screen_keys.dart @@ -0,0 +1,96 @@ +part of 'screen.dart'; + +/// How many chats the visit remembers for Ctrl+Tab over a single pane. +const chatRecentSessionLimit = 8; + +/// Keys the Chat destination answers from anywhere in it, also while the +/// sidebar or a toolbar owns focus: a bare `/` puts the keyboard in the open +/// chat's composer, and Ctrl+Tab over a single pane returns to the chat shown +/// before it (and back again). Both are handled before the focus tree, like +/// the workspace's pane cycling, and leave other destinations, popups, +/// dialogs and any focused text field alone. +mixin _ChatScreenKeys on State, _ChatScreenWorkspace { + void _open(JsonMap session, {bool focusComposer}); + + /// The chats this visit has shown in the workspace, most recent first; the + /// active one leads it. In memory only: a reopened app starts afresh. + final List _recentSessions = []; + + /// Moves the active pane's chat to the front. Called on every workspace + /// change, including a restored layout, so the chat opened before the + /// current one is always the second entry. + @override + void _noteRecentSession() { + final id = _workspace.activePane?.sessionId; + if (id == null || id.isEmpty || _recentSessions.firstOrNull == id) return; + _recentSessions + ..remove(id) + ..insert(0, id); + if (_recentSessions.length > chatRecentSessionLimit) { + _recentSessions.removeLast(); + } + } + + /// Drops [id]: a closed chat, or one `/new` moved to a fresh session. + void _forgetRecentSession(String id) => _recentSessions.remove(id); + + /// Drops every remembered chat: ids belong to one server. + @override + void _forgetRecentSessions() => _recentSessions.clear(); + + /// Over a single pane, opens the chat shown before the active one with its + /// composer focused; false when this visit has shown no other chat. + @override + bool _toggleRecentChat() { + final current = _workspace.activePane?.sessionId; + final previous = _recentSessions + .where((id) => id != current) + .firstOrNull; + if (previous == null) return false; + _open(_rowFor(previous) ?? {'id': previous}, focusComposer: true); + return true; + } + + /// Whether the shown destination is Chat with no popup, dialog or other + /// route over it, so a key pressed now is meant for the open chat. + @override + bool _chatOwnsKeyboard() { + final destination = ShellBarScope.maybeOf(context)?.registry.focus; + if (destination != null && destination != AppDestination.chat) return false; + final focusContext = FocusManager.instance.primaryFocus?.context; + final route = focusContext == null + ? ModalRoute.of(context) + : ModalRoute.of(focusContext); + return route is! PopupRoute && (route == null || route.isCurrent); + } + + /// A bare `/` typed outside any text field focuses the active chat's + /// composer. The composer takes focus after this frame (see + /// [ChatComposerFocusRequests]), once the host has finished delivering the + /// keystroke, so the slash itself is not typed into it. Inside a text field + /// (the composer, a dialog's field) `/` stays an ordinary character. + bool _slashFocusKey(KeyEvent event) { + final keyboard = HardwareKeyboard.instance; + if (event is! KeyDownEvent || + event.character != '/' || + keyboard.isControlPressed || + keyboard.isMetaPressed || + keyboard.isAltPressed || + !_workspaceVisible) { + return false; + } + final id = _workspace.activePane?.sessionId; + if (id == null || _textFieldHasFocus() || !_chatOwnsKeyboard()) { + return false; + } + _composerFocus.request(id); + return true; + } + + /// Whether an editable text control holds focus, wherever it is. + bool _textFieldHasFocus() { + final context = FocusManager.instance.primaryFocus?.context; + final editable = context?.findAncestorWidgetOfExactType(); + return editable != null && !editable.readOnly; + } +} diff --git a/app/lib/features/chat/chat_screen_workspace.dart b/app/lib/features/chat/chat_screen_workspace.dart index 07456661..eea0bb68 100644 --- a/app/lib/features/chat/chat_screen_workspace.dart +++ b/app/lib/features/chat/chat_screen_workspace.dart @@ -4,6 +4,10 @@ part of 'screen.dart'; mixin _ChatScreenWorkspace on State { Map get _openedSessions; ChatComposerFocusRequests get _composerFocus; + bool _chatOwnsKeyboard(); + bool _toggleRecentChat(); + void _noteRecentSession(); + void _forgetRecentSessions(); JsonMap? _rowFor(String id); void _back(); bool get _pageOpen; @@ -89,6 +93,7 @@ mixin _ChatScreenWorkspace on State { _workspaceBinding = null; if (_workspaceScope != null && scope != _workspaceScope) { _workspace.restoreLayout(ChatWorkspaceSnapshot.fromLayout(null, null)!); + _forgetRecentSessions(); _workspaceVisible = false; _usedWorkspace = true; _sidebarMode = ChatSidebarMode.expanded; @@ -111,7 +116,9 @@ mixin _ChatScreenWorkspace on State { String _workspaceSignature = ''; /// Ctrl+Tab cycles retained panes even when the sidebar or toolbar owns - /// focus. Command+Tab stays with the operating system's application switcher. + /// focus. Over a single pane it swaps in the chat shown before this one + /// instead, and back again (see [_toggleRecentChat]). Command+Tab stays + /// with the operating system's application switcher. bool _cycleChatKey(KeyEvent event) { final keyboard = HardwareKeyboard.instance; if (event is! KeyDownEvent || @@ -120,19 +127,12 @@ mixin _ChatScreenWorkspace on State { keyboard.isMetaPressed || keyboard.isAltPressed || !_workspaceVisible || - _workspace.paneCount == 0) { - return false; - } - final destination = ShellBarScope.maybeOf(context)?.registry.focus; - if (destination != null && destination != AppDestination.chat) return false; - final focusContext = FocusManager.instance.primaryFocus?.context; - final route = focusContext == null - ? ModalRoute.of(context) - : ModalRoute.of(focusContext); - if (route is PopupRoute || (route != null && !route.isCurrent)) { + _workspace.paneCount == 0 || + !_chatOwnsKeyboard()) { return false; } final panes = _workspace.panes; + if (panes.length == 1 && _toggleRecentChat()) return true; final active = panes.indexWhere( (pane) => pane.id == _workspace.activePaneId, ); @@ -156,7 +156,9 @@ mixin _ChatScreenWorkspace on State { } void _workspaceChanged() { - if (!mounted || _workspaceBinding?.isRestoring == true) return; + if (!mounted) return; + _noteRecentSession(); + if (_workspaceBinding?.isRestoring == true) return; final signature = '${_workspace.activePaneId}:${_workspace.panes.map((p) => '${p.id}=${p.sessionId}').join(',')}'; if (_workspaceSignature == signature) return; diff --git a/app/lib/features/chat/screen.dart b/app/lib/features/chat/screen.dart index d67fbc9d..3dfbc011 100644 --- a/app/lib/features/chat/screen.dart +++ b/app/lib/features/chat/screen.dart @@ -35,6 +35,7 @@ import 'ui/sessions/chat_sessions_body.dart'; import 'ui/sessions/chat_sessions_controller.dart'; import 'ui/sessions/chat_sessions_screen.dart'; +part 'chat_screen_keys.dart'; part 'chat_screen_workspace.dart'; /// The Chat destination's list/detail switch. @@ -73,7 +74,8 @@ class ChatScreen extends StatefulWidget { State createState() => _ChatScreenState(); } -class _ChatScreenState extends State with _ChatScreenWorkspace { +class _ChatScreenState extends State + with _ChatScreenWorkspace, _ChatScreenKeys { /// The list's controller, shared with the mounted list screen. The list /// screen refreshes it on mount and swaps its repository when the socket is /// replaced; this destination lists created rows and re-reads after a @@ -141,10 +143,12 @@ class _ChatScreenState extends State with _ChatScreenWorkspace { _workspace.open(initial); _workspaceVisible = true; _publishedWorkspaceSession = initial; + _noteRecentSession(); } _workspace.addListener(_workspaceChanged); _bindWorkspacePersistence(); HardwareKeyboard.instance.addHandler(_cycleChatKey); + HardwareKeyboard.instance.addHandler(_slashFocusKey); // Seen from now on, so the press that chooses the first chat counts. LastPointerKind.instance; _sessions.addListener(_nextChanged); @@ -201,6 +205,7 @@ class _ChatScreenState extends State with _ChatScreenWorkspace { void _openBySelection(JsonMap session) => _open(session, focusComposer: chatSelectionFocusesComposer(session)); + @override void _open(JsonMap session, {bool focusComposer = false}) { final id = '${session['id'] ?? ''}'; if (id.isEmpty) return; @@ -254,6 +259,7 @@ class _ChatScreenState extends State with _ChatScreenWorkspace { if (accepted != null) _acceptedModels[id] = accepted; _startNotice = (id: id, notice: notice); _openedSessions[id] = {...session}..remove('running'); + _forgetRecentSession(previousId); _workspace.replaceSession(previousId, id); if (_workspace.paneCount == 0) _open(session); } @@ -271,6 +277,7 @@ class _ChatScreenState extends State with _ChatScreenWorkspace { /// `/close` was accepted: the conversation leaves, back to the list, which /// re-reads the closed row. void _closed(String sessionId) { + _forgetRecentSession(sessionId); for (final pane in _workspace.panes .where((pane) => pane.sessionId == sessionId) @@ -391,6 +398,7 @@ class _ChatScreenState extends State with _ChatScreenWorkspace { @override void dispose() { HardwareKeyboard.instance.removeHandler(_cycleChatKey); + HardwareKeyboard.instance.removeHandler(_slashFocusKey); _page.dispose(); _workspaceBinding?.dispose(); _workspace.removeListener(_workspaceChanged); diff --git a/app/notes/chat-keyboard-focus.md b/app/notes/chat-keyboard-focus.md new file mode 100644 index 00000000..2b7faa40 --- /dev/null +++ b/app/notes/chat-keyboard-focus.md @@ -0,0 +1,26 @@ +# Slash focuses the composer; Ctrl+Tab over one pane toggles recent chats + +`lib/features/chat/chat_screen_keys.dart` (a part of `screen.dart`) adds two +Chat-destination keys, registered on `HardwareKeyboard` for the screen's +lifetime like the pane cycling in `chat_screen_workspace.dart`: + +- A bare `/` (matched on the typed character, so it follows the keyboard + layout; Ctrl/Alt/Meta chords are left alone, Ctrl+/ stays the shell's Search) + requests focus for the active pane's composer through the existing + `ChatComposerFocusRequests`. The composer takes it after the frame, once the + host has finished delivering the keystroke, so the slash is not typed into + it. Nothing happens while any editable text field has focus, while a popup + or dialog is open, or on another destination. +- Ctrl+Tab (and Ctrl+Shift+Tab) over a single pane swaps in the chat shown + before the active one, composer focused, and back again. With no earlier + chat this visit it still just focuses the composer; with two or more panes + the existing pane cycling is unchanged. + +The visit keeps a most-recent-first list of the chats the workspace has shown +(bounded to eight, in memory). It is noted on every workspace change, including +a restored layout and the routed first chat; a chat `/close`d or moved by +`/new` is dropped, and a server switch clears it. + +Tests: `test/features/chat/chat_keyboard_focus_test.dart`. Widget tests cannot +show a browser's text insertion, so "the slash is not typed" rests on the +post-frame focus request; the composer text is asserted empty. diff --git a/app/test/features/chat/chat_keyboard_focus_test.dart b/app/test/features/chat/chat_keyboard_focus_test.dart new file mode 100644 index 00000000..f5fbbce2 --- /dev/null +++ b/app/test/features/chat/chat_keyboard_focus_test.dart @@ -0,0 +1,190 @@ +import 'package:flutter/material.dart'; +import 'package:flutter/services.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/api_gateway.dart'; +import 'package:pipelines_app/features/chat/screen.dart'; +import 'package:pipelines_app/features/chat/ui/sessions/session_actions.dart'; +import 'package:pipelines_app/features/chat/workspace/chat_workspace.dart'; +import 'package:pipelines_app/shell/adaptive_shell.dart'; +import 'package:pipelines_app/shell/destination.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +import 'conversation/chat_thread_fixtures.dart'; + +class _Gateway extends FakeChatGateway { + @override + Future call(String type, [JsonMap fields = const {}]) { + if (type == 'chat_sessions') { + return Future.value({ + 'chat_sessions': [ + for (final id in ['a', 'b', 'c']) {'id': id, 'title': 'Chat $id'}, + ], + }); + } + if (type == 'chat_shells') return Future.value({'chat_shells': []}); + return super.call(type, fields); + } +} + +Finder _input(String id) => find.descendant( + of: find.byKey(ValueKey('chat-composer-$id')), + matching: find.byType(EditableText), +); +EditableText _editable(WidgetTester tester, String id) => + tester.widget(_input(id)); +Finder _actions(String id) => find.byWidgetPredicate( + (widget) => widget is SessionActionsButton && widget.session['id'] == id, +); +ChatWorkspaceController _workspace(WidgetTester tester) => + tester.widget(find.byType(ChatWorkspace)).controller; + +Future _setup(WidgetTester tester) async { + SharedPreferences.setMockInitialValues({}); + tester.view.physicalSize = const Size(1800, 1000); + tester.view.devicePixelRatio = 1; + addTearDown(tester.view.reset); + final gateway = _Gateway()..history = (_) async => chatPage([]); + addTearDown(gateway.close); + await tester.pumpWidget( + MaterialApp( + home: AdaptiveShell( + destination: AppDestination.chat, + destinationBodies: { + AppDestination.chat: (_) => ChatScreen(gateway: gateway), + }, + ), + ), + ); + await tester.pumpAndSettle(); +} + +Future _openRow(WidgetTester tester, String id) async { + await tester.tap(find.byKey(Key('chat-row-$id'))); + await tester.pumpAndSettle(); +} + +/// Puts focus on a sidebar control, outside every text field. +Future _focusSidebar(WidgetTester tester) async { + final icon = find + .descendant(of: _actions('a'), matching: find.byType(Icon)) + .first; + Focus.of(tester.element(icon)).requestFocus(); + await tester.pumpAndSettle(); +} + +Future _slash(WidgetTester tester) async { + final handled = await tester.sendKeyEvent(LogicalKeyboardKey.slash); + await tester.pumpAndSettle(); + return handled; +} + +Future _controlTab(WidgetTester tester, {bool shift = false}) async { + await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft); + if (shift) await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftLeft); + await tester.sendKeyEvent(LogicalKeyboardKey.tab); + if (shift) await tester.sendKeyUpEvent(LogicalKeyboardKey.shiftLeft); + await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft); + await tester.pumpAndSettle(); +} + +void main() { + testWidgets('slash outside a text field focuses the composer, untyped', ( + tester, + ) async { + await _setup(tester); + await _openRow(tester, 'a'); + await _focusSidebar(tester); + expect(_editable(tester, 'a').focusNode.hasPrimaryFocus, isFalse); + + expect(await _slash(tester), isTrue); + expect(_editable(tester, 'a').focusNode.hasPrimaryFocus, isTrue); + expect(_editable(tester, 'a').controller.text, isEmpty); + + // Inside the composer a slash is an ordinary character for the field. + expect(await _slash(tester), isFalse); + expect(_editable(tester, 'a').focusNode.hasPrimaryFocus, isTrue); + + // Shift+/ (a question mark) and Alt+/ are not the shortcut; Ctrl+/ is + // the shell's own Search chord. + await _focusSidebar(tester); + await tester.sendKeyDownEvent(LogicalKeyboardKey.shiftLeft); + await tester.sendKeyEvent(LogicalKeyboardKey.slash, character: '?'); + await tester.sendKeyUpEvent(LogicalKeyboardKey.shiftLeft); + await tester.sendKeyDownEvent(LogicalKeyboardKey.altLeft); + await tester.sendKeyEvent(LogicalKeyboardKey.slash); + await tester.sendKeyUpEvent(LogicalKeyboardKey.altLeft); + await tester.pumpAndSettle(); + expect(_editable(tester, 'a').focusNode.hasPrimaryFocus, isFalse); + await tester.pumpWidget(const SizedBox.shrink()); + }); + + testWidgets('slash leaves a dialog text field and a popup alone', ( + tester, + ) async { + await _setup(tester); + await _openRow(tester, 'a'); + await tester.tap(_actions('a')); + await tester.pumpAndSettle(); + expect(await _slash(tester), isFalse); + expect(find.text('Rename…'), findsOneWidget); + await tester.tap(find.text('Rename…')); + await tester.pumpAndSettle(); + final dialogField = find.descendant( + of: find.byType(Dialog), + matching: find.byType(EditableText), + ); + expect(dialogField, findsOneWidget); + await tester.tap(dialogField); + await tester.pumpAndSettle(); + expect(await _slash(tester), isFalse); + expect(find.byType(Dialog), findsOneWidget); + expect(_editable(tester, 'a').focusNode.hasPrimaryFocus, isFalse); + await tester.pumpWidget(const SizedBox.shrink()); + }); + + testWidgets('Control Tab over one pane returns to the previous chat', ( + tester, + ) async { + await _setup(tester); + await _openRow(tester, 'a'); + final workspace = _workspace(tester); + // Nothing shown before: the chord only focuses the composer. + await _controlTab(tester); + expect(workspace.activePane?.sessionId, 'a'); + expect(_editable(tester, 'a').focusNode.hasPrimaryFocus, isTrue); + + await _openRow(tester, 'b'); + await tester.enterText(_input('b'), 'Draft B'); + await _focusSidebar(tester); + for (final id in ['a', 'b', 'a']) { + await _controlTab(tester); + expect(workspace.paneCount, 1); + expect(workspace.activePane?.sessionId, id); + expect(_editable(tester, id).focusNode.hasPrimaryFocus, isTrue); + } + await _controlTab(tester, shift: true); + expect(workspace.activePane?.sessionId, 'b'); + expect(_editable(tester, 'b').controller.text, 'Draft B'); + + // A third chat makes the pair c and b; a is no longer one step away. + await _openRow(tester, 'c'); + await _controlTab(tester); + expect(workspace.activePane?.sessionId, 'b'); + await _controlTab(tester); + expect(workspace.activePane?.sessionId, 'c'); + + // Two panes cycle the panes as before, not the history. + await tester.tap(_actions('a')); + await tester.pumpAndSettle(); + await tester.tap(find.text('Open to the right')); + await tester.pumpAndSettle(); + expect(workspace.paneCount, 2); + expect(workspace.activePane?.sessionId, 'a'); + await _controlTab(tester); + expect(workspace.activePane?.sessionId, 'c'); + await _controlTab(tester); + expect(workspace.activePane?.sessionId, 'a'); + expect(workspace.paneCount, 2); + await tester.pumpWidget(const SizedBox.shrink()); + }); +} From 5e1498c4b22dd897fef65812d82e88961107f254 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sat, 7 Nov 2026 00:48:12 +0000 Subject: [PATCH 2/2] Chat composer: accent focus ring and wider desktop bottom margin While the field has focus the composer pill shows a thin translucent ring and soft glow in the chat's accent (its own colour, else the theme primary), fading in and out; nothing is drawn unfocused. On desktop hosts the composer keeps 24 px from the window's bottom edge instead of 12 (phones unchanged), split by the same host test as Enter-sends. --- .../chat/conversation/chat_composer_bar.dart | 75 +++++++++--- .../chat/conversation/chat_thread_view.dart | 1 + .../conversation/composer_focus_ring.dart | 82 +++++++++++++ .../chat_composer_bottom_margin_test.dart | 68 +++++++++++ .../chat_composer_focus_ring_test.dart | 109 ++++++++++++++++++ 5 files changed, 320 insertions(+), 15 deletions(-) create mode 100644 app/lib/features/chat/conversation/composer_focus_ring.dart create mode 100644 app/test/features/chat/conversation/chat_composer_bottom_margin_test.dart create mode 100644 app/test/features/chat/conversation/chat_composer_focus_ring_test.dart diff --git a/app/lib/features/chat/conversation/chat_composer_bar.dart b/app/lib/features/chat/conversation/chat_composer_bar.dart index d227f6ea..37fcac64 100644 --- a/app/lib/features/chat/conversation/chat_composer_bar.dart +++ b/app/lib/features/chat/conversation/chat_composer_bar.dart @@ -26,6 +26,8 @@ import '../../../ui/adaptive/glass_pill.dart'; import 'chat_reading_width.dart'; import 'composer_focus_request.dart'; import 'composer_focus_restore.dart'; +import 'composer_focus_ring.dart'; +import '../ui/sessions/chat_color_palette.dart'; /// The composer's placeholder when the chat names no working directory. const String chatComposerPlaceholder = 'Message the agent'; @@ -48,6 +50,22 @@ bool chatEnterSends([TargetPlatform? platform]) { return target != TargetPlatform.android && target != TargetPlatform.iOS; } +/// The composer's gap above the bottom of the window (or its bottom safe +/// area) on a phone, where it sits just over the keyboard or home indicator. +const double kChatComposerBottomMargin = 12; + +/// The same gap on a desktop host (native or a desktop browser), whose +/// window's bottom edge is a hard frame under a pointer: the composer keeps +/// more room from it so it does not read as stuck to the edge. +const double kChatComposerDesktopBottomMargin = 24; + +/// The composer's bottom gap on [platform] (the running host by default), +/// split between phones and desktops as [chatEnterSends] is. +double chatComposerBottomMargin([TargetPlatform? platform]) => + chatEnterSends(platform) + ? kChatComposerDesktopBottomMargin + : kChatComposerBottomMargin; + /// The single primary control's words while a turn is and is not running. const String chatSendLabel = 'Send'; const String chatStopLabel = 'Stop'; @@ -102,8 +120,13 @@ class ChatComposerBar extends StatefulWidget { this.placeholder = chatComposerPlaceholder, this.enterSends, this.images, + this.chatColor, }); + /// The chat's colour name (see `chatSessionColor`), the accent of the + /// field's focus ring; null takes the host's primary colour. + final String? chatColor; + /// The transcript's image cache, told about uploaded files so the sent turn /// shows them without a round trip. final ChatAttachmentImages? images; @@ -716,7 +739,12 @@ class _ChatComposerBarState extends State { constraints: const BoxConstraints(maxWidth: kChatReadingWidth), child: Padding( key: const Key('chat-composer'), - padding: const EdgeInsetsDirectional.fromSTEB(16, 8, 16, 12), + padding: EdgeInsetsDirectional.fromSTEB( + 16, + 8, + 16, + chatComposerBottomMargin(), + ), child: Column( mainAxisSize: MainAxisSize.min, crossAxisAlignment: CrossAxisAlignment.stretch, @@ -787,22 +815,39 @@ class _ChatComposerBarState extends State { ); } + static const OutlinedBorder _pillShape = RoundedRectangleBorder( + borderRadius: BorderRadius.all(Radius.circular(28)), + ); + /// The field and its controls in one frosted-glass surface floating over /// the transcript, so the composer reads as a single input rather than a - /// row of separate controls, and the conversation shows through it. - Widget _pill(BuildContext context, bool cupertino, Widget child) => GlassPill( - key: const Key('chat-composer-pill'), - cupertino: cupertino, - shape: const RoundedRectangleBorder( - borderRadius: BorderRadius.all(Radius.circular(28)), - ), - // The end controls keep the same gap from the pill's sides as from its - // bottom (and its top while the field is one line). - child: Padding( - padding: const EdgeInsets.all(GlassBarMetrics.fieldEdgeGap), - child: child, - ), - ); + /// row of separate controls, and the conversation shows through it. While + /// the field has focus the pill's edge takes the chat's accent. + Widget _pill(BuildContext context, bool cupertino, Widget child) => + ComposerFocusRing( + focus: _focus, + accent: _accent(context, cupertino), + shape: _pillShape, + child: GlassPill( + key: const Key('chat-composer-pill'), + cupertino: cupertino, + shape: _pillShape, + // The end controls keep the same gap from the pill's sides as from + // its bottom (and its top while the field is one line). + child: Padding( + padding: const EdgeInsets.all(GlassBarMetrics.fieldEdgeGap), + child: child, + ), + ), + ); + + /// The chat's accent: its own colour's shade for this host and brightness, + /// else the host's primary colour. + Color _accent(BuildContext context, bool cupertino) => + chatColorShade(context, widget.chatColor) ?? + (cupertino + ? CupertinoTheme.of(context).primaryColor + : Theme.of(context).colorScheme.primary); /// The attach control: a host button that opens the picker, disabled when the /// host has no picker or one prompt is already awaiting its reply. diff --git a/app/lib/features/chat/conversation/chat_thread_view.dart b/app/lib/features/chat/conversation/chat_thread_view.dart index 79e85230..69dbfb0a 100644 --- a/app/lib/features/chat/conversation/chat_thread_view.dart +++ b/app/lib/features/chat/conversation/chat_thread_view.dart @@ -937,6 +937,7 @@ class _ChatThreadViewState extends State { placeholder: chatComposerPlaceholderFor( '${widget.session?['directory'] ?? ''}', ), + chatColor: chatSessionColor(widget.session), backgroundTasks: ChatBackgroundTasks( key: ValueKey('chat-background-tasks-${widget.sessionId}'), gateway: widget.gateway, diff --git a/app/lib/features/chat/conversation/composer_focus_ring.dart b/app/lib/features/chat/conversation/composer_focus_ring.dart new file mode 100644 index 00000000..3454efb2 --- /dev/null +++ b/app/lib/features/chat/conversation/composer_focus_ring.dart @@ -0,0 +1,82 @@ +import 'package:flutter/widgets.dart'; + +/// The composer's focus indication: a thin ring in the chat's accent colour +/// along the pill's edge and a soft glow of the same colour outside it, so +/// a focused field shows as such without relying on its caret alone. Both +/// fade in and out with focus; at rest unfocused nothing visible is drawn. +/// +/// The accent is the chat's own colour (its highlight in the list) when it +/// has one, else the host's primary colour, never the pill's background: the +/// ring is translucent so the same tint stays subtle on a light and a dark +/// pill. +class ComposerFocusRing extends StatelessWidget { + const ComposerFocusRing({ + super.key, + required this.focus, + required this.accent, + required this.shape, + required this.child, + }); + + /// The field's focus node; the ring follows its [FocusNode.hasFocus]. + final FocusNode focus; + + /// The chat's accent, at full opacity; the ring and glow fade it. + final Color accent; + + /// The pill's shape, so the ring hugs its edge. + final OutlinedBorder shape; + final Widget child; + + /// How long the ring takes to appear or fade. + static const Duration duration = Duration(milliseconds: 160); + + /// The ring's stroke, drawn just inside the pill's edge over its hairline. + static const double ringWidth = 1.5; + + /// The accent's opacity in the ring while focused. + static const double ringOpacity = 0.6; + + /// The accent's opacity in the glow while focused. + static const double glowOpacity = 0.18; + + /// The glow's blur radius; it spreads [glowSpread] past the pill first. + static const double glowBlur = 12; + static const double glowSpread = 1; + + @override + Widget build(BuildContext context) => ListenableBuilder( + listenable: focus, + child: child, + builder: (context, child) { + final focused = focus.hasFocus; + // Both decorations keep the same shape, shadow and stroke while only + // their colours change, so the container lerps them into one fade. + return AnimatedContainer( + key: const Key('chat-composer-focus-ring'), + duration: duration, + curve: Curves.easeOutCubic, + decoration: ShapeDecoration( + shape: shape, + shadows: [ + BoxShadow( + color: accent.withValues(alpha: focused ? glowOpacity : 0), + blurRadius: glowBlur, + spreadRadius: glowSpread, + ), + ], + ), + // Over the child: the pill's fill would otherwise cover the ring. + foregroundDecoration: ShapeDecoration( + shape: shape.copyWith( + side: BorderSide( + color: accent.withValues(alpha: focused ? ringOpacity : 0), + width: ringWidth, + ), + ), + ), + child: child, + ); + }, + ); +} diff --git a/app/test/features/chat/conversation/chat_composer_bottom_margin_test.dart b/app/test/features/chat/conversation/chat_composer_bottom_margin_test.dart new file mode 100644 index 00000000..1eff3734 --- /dev/null +++ b/app/test/features/chat/conversation/chat_composer_bottom_margin_test.dart @@ -0,0 +1,68 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/features/chat/conversation/chat_composer_bar.dart'; + +import 'chat_composer_bar_fixtures.dart'; + +/// The phones: Fuchsia counts as a keyboard host (Enter sends), like desktop. +final _phones = TargetPlatformVariant({ + TargetPlatform.android, + TargetPlatform.iOS, +}); + +double _bottomMargin(WidgetTester tester) { + final padding = tester.widget( + find.byKey(const Key('chat-composer')), + ); + return (padding.padding as EdgeInsetsDirectional).bottom; +} + +void main() { + test('phones keep the close bottom margin, desktops a wider one', () { + expect( + chatComposerBottomMargin(TargetPlatform.android), + kChatComposerBottomMargin, + ); + expect( + chatComposerBottomMargin(TargetPlatform.iOS), + kChatComposerBottomMargin, + ); + for (final desktop in [ + TargetPlatform.macOS, + TargetPlatform.windows, + TargetPlatform.linux, + ]) { + expect( + chatComposerBottomMargin(desktop), + kChatComposerDesktopBottomMargin, + ); + } + expect( + kChatComposerDesktopBottomMargin, + greaterThan(kChatComposerBottomMargin), + ); + }); + + group('rendered composer', () { + late ComposerBarGateway gateway; + + setUp(() => gateway = ComposerBarGateway()..page = fixtureTurn()); + tearDown(() => gateway.close()); + + testWidgets( + 'keeps more room from a desktop window bottom', + (tester) async { + await tester.pumpWidget(composerThread(gateway)); + await tester.pumpAndSettle(); + expect(_bottomMargin(tester), kChatComposerDesktopBottomMargin); + }, + variant: TargetPlatformVariant.desktop(), + ); + + testWidgets('stays close to a phone bottom', (tester) async { + await tester.pumpWidget(composerThread(gateway)); + await tester.pumpAndSettle(); + expect(_bottomMargin(tester), kChatComposerBottomMargin); + }, variant: _phones); + }); +} diff --git a/app/test/features/chat/conversation/chat_composer_focus_ring_test.dart b/app/test/features/chat/conversation/chat_composer_focus_ring_test.dart new file mode 100644 index 00000000..cec806fd --- /dev/null +++ b/app/test/features/chat/conversation/chat_composer_focus_ring_test.dart @@ -0,0 +1,109 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/features/chat/conversation/composer_focus_ring.dart'; +import 'package:pipelines_app/features/chat/ui/sessions/chat_color_palette.dart'; + +import 'chat_composer_bar_fixtures.dart'; + +/// The focus ring wrapping the composer pill: its outer glow and inner ring. +({Color glow, BorderSide side}) _ring(WidgetTester tester) { + final container = tester.widget( + find.byKey(const Key('chat-composer-focus-ring')), + ); + final glow = (container.decoration! as ShapeDecoration).shadows!.single; + final shape = (container.foregroundDecoration! as ShapeDecoration).shape; + return (glow: glow.color, side: (shape as RoundedRectangleBorder).side); +} + +Future _focusField(WidgetTester tester) async { + await tester.tap(find.byKey(const Key('chat-composer-field'))); + await tester.pumpAndSettle(); +} + +void main() { + late ComposerBarGateway gateway; + + setUp(() => gateway = ComposerBarGateway()..page = fixtureTurn()); + tearDown(() => gateway.close()); + + testWidgets('unfocused composer draws no ring or glow', (tester) async { + await tester.pumpWidget(composerThread(gateway)); + await tester.pumpAndSettle(); + + final ring = _ring(tester); + expect(ring.side.color.a, 0); + expect(ring.glow.a, 0); + expect(ring.side.width, ComposerFocusRing.ringWidth); + }); + + testWidgets('focused composer takes the primary colour as its ring', ( + tester, + ) async { + await tester.pumpWidget(composerThread(gateway)); + await tester.pumpAndSettle(); + await _focusField(tester); + + final primary = Theme.of( + tester.element(find.byKey(const Key('chat-composer-field'))), + ).colorScheme.primary; + final ring = _ring(tester); + expect( + ring.side.color, + primary.withValues(alpha: ComposerFocusRing.ringOpacity), + ); + expect(ring.glow, primary.withValues(alpha: ComposerFocusRing.glowOpacity)); + expect(ring.side.width, ComposerFocusRing.ringWidth); + }); + + testWidgets('a coloured chat lends its own shade to the ring', ( + tester, + ) async { + await tester.pumpWidget( + composerThread(gateway, session: {'id': 's', 'color': 'teal'}), + ); + await tester.pumpAndSettle(); + await _focusField(tester); + + final teal = chatColorShade( + tester.element(find.byKey(const Key('chat-composer-field'))), + 'teal', + )!; + expect( + _ring(tester).side.color, + teal.withValues(alpha: ComposerFocusRing.ringOpacity), + ); + }); + + testWidgets('the ring fades out again when focus leaves', (tester) async { + await tester.pumpWidget(composerThread(gateway)); + await tester.pumpAndSettle(); + await _focusField(tester); + expect(_ring(tester).side.color.a, greaterThan(0)); + + FocusManager.instance.primaryFocus?.unfocus(); + // One frame applies the focus change, the next rebuilds the ring towards + // its unfocused decoration, which the container then animates into. + await tester.pump(); + await tester.pump(); + expect(_ring(tester).side.color.a, 0); + await tester.pumpAndSettle(); + expect(_ring(tester).glow.a, 0); + }); + + testWidgets('Cupertino composer rings in the theme primary colour', ( + tester, + ) async { + await tester.pumpWidget(composerThread(gateway, cupertino: true)); + await tester.pumpAndSettle(); + await _focusField(tester); + + final primary = CupertinoTheme.of( + tester.element(find.byKey(const Key('chat-composer-field'))), + ).primaryColor; + expect( + _ring(tester).side.color, + primary.withValues(alpha: ComposerFocusRing.ringOpacity), + ); + }); +}