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.
This commit is contained in:
2026-11-07 00:46:02 +00:00
parent f4ba2ab25e
commit de0c06cec1
5 changed files with 335 additions and 13 deletions
@@ -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<ChatScreen>, _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<String> _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<EditableText>();
return editable != null && !editable.readOnly;
}
}
@@ -4,6 +4,10 @@ part of 'screen.dart';
mixin _ChatScreenWorkspace on State<ChatScreen> {
Map<String, JsonMap> 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<ChatScreen> {
_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<ChatScreen> {
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<ChatScreen> {
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<ChatScreen> {
}
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;
+9 -1
View File
@@ -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<ChatScreen> createState() => _ChatScreenState();
}
class _ChatScreenState extends State<ChatScreen> with _ChatScreenWorkspace {
class _ChatScreenState extends State<ChatScreen>
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<ChatScreen> 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<ChatScreen> 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<ChatScreen> with _ChatScreenWorkspace {
if (accepted != null) _acceptedModels[id] = accepted;
_startNotice = (id: id, notice: notice);
_openedSessions[id] = <String, dynamic>{...session}..remove('running');
_forgetRecentSession(previousId);
_workspace.replaceSession(previousId, id);
if (_workspace.paneCount == 0) _open(session);
}
@@ -271,6 +277,7 @@ class _ChatScreenState extends State<ChatScreen> 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<ChatScreen> with _ChatScreenWorkspace {
@override
void dispose() {
HardwareKeyboard.instance.removeHandler(_cycleChatKey);
HardwareKeyboard.instance.removeHandler(_slashFocusKey);
_page.dispose();
_workspaceBinding?.dispose();
_workspace.removeListener(_workspaceChanged);