04ba81e0ea
Keep chat and folder-picker UI on the Material path by removing obsolete Cupertino imports, icon metadata, flags, and alternate control handling while preserving existing behavior and focused test coverage.
394 lines
14 KiB
Dart
394 lines
14 KiB
Dart
part of 'screen.dart';
|
|
|
|
/// Pane layout, focus and route publication for one Chat destination visit.
|
|
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;
|
|
Widget _thread(ChatWorkspacePane pane);
|
|
|
|
ChatSidebarMode _sidebarMode = ChatSidebarMode.expanded;
|
|
void _setSidebarMode(ChatSidebarMode mode) {
|
|
if (_sidebarMode == mode) return;
|
|
setState(() => _sidebarMode = mode);
|
|
_workspaceBinding?.changed();
|
|
}
|
|
|
|
Widget _sidebarList(Widget full, String? selected, bool beside) {
|
|
final mode = selected == null || !beside
|
|
? ChatSidebarMode.expanded
|
|
: _sidebarMode;
|
|
final navigation = ShellBarScope.maybeOf(context);
|
|
return Stack(
|
|
fit: StackFit.expand,
|
|
children: [
|
|
Offstage(
|
|
offstage: mode != ChatSidebarMode.expanded,
|
|
child: ExcludeFocus(
|
|
excluding: mode != ChatSidebarMode.expanded,
|
|
child: full,
|
|
),
|
|
),
|
|
if (mode == ChatSidebarMode.compact)
|
|
ChatCompactSidebar(
|
|
navigation: navigation?.registry.canNavigate == true
|
|
? ShellDestinationMenu(
|
|
cupertino: false,
|
|
current: AppDestination.chat,
|
|
onSelected: navigation!.registry.navigateTo,
|
|
)
|
|
: null,
|
|
controller: _sessionsForSidebar,
|
|
folds: _foldsForSidebar,
|
|
activeSessionId: selected,
|
|
visibleSessionIds: _visibleSidebarSessions,
|
|
onOpen: _openSidebarSession,
|
|
onExpand: () => _setSidebarMode(ChatSidebarMode.expanded),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
Set<String> _visibleWorkspaceSessions = const {};
|
|
|
|
void _workspaceVisibilityChanged(Set<String> sessions) {
|
|
if (!mounted || setEquals(_visibleWorkspaceSessions, sessions)) return;
|
|
setState(() => _visibleWorkspaceSessions = Set.unmodifiable(sessions));
|
|
}
|
|
|
|
Set<String> get _visibleSidebarSessions {
|
|
if (!_workspaceVisible) return const {};
|
|
final retained = _workspace.panes.map((pane) => pane.sessionId).toSet();
|
|
final visible = _visibleWorkspaceSessions.intersection(retained);
|
|
final active = _workspace.activePane?.sessionId;
|
|
return visible.isNotEmpty ? visible : {?active};
|
|
}
|
|
|
|
ChatSessionsController get _sessionsForSidebar;
|
|
ChatSectionFolds get _foldsForSidebar;
|
|
void _openSidebarSession(JsonMap session);
|
|
|
|
final ChatWorkspaceController _workspace = ChatWorkspaceController();
|
|
ChatWorkspaceBinding? _workspaceBinding;
|
|
String? _workspaceScope;
|
|
|
|
void _bindWorkspacePersistence() {
|
|
if (!widget.persistWorkspace) return;
|
|
final scope = serverStorageScope(serverIdentity(widget.gateway));
|
|
_workspaceScope = scope;
|
|
_workspaceBinding = ChatWorkspaceBinding(
|
|
controller: _workspace,
|
|
store: widget.gateway is FederatedChatGateway
|
|
? FederatedWorkspaceStore(
|
|
primary: (widget.gateway as FederatedChatGateway).primary(),
|
|
)
|
|
: SharedPreferencesChatWorkspaceStore(serverScope: scope),
|
|
sidebarMode: () => _sidebarMode.name,
|
|
onRestored: (snapshot) {
|
|
if (!mounted) return;
|
|
setState(() {
|
|
_sidebarMode = ChatSidebarMode.values.firstWhere(
|
|
(mode) => mode.name == snapshot.sidebarMode,
|
|
);
|
|
// Older snapshots could hide the rail. Keep their recovery affordance
|
|
// now that layout changes happen at the divider instead of a menu.
|
|
if (_sidebarMode == ChatSidebarMode.hidden) {
|
|
_sidebarMode = ChatSidebarMode.compact;
|
|
}
|
|
_usedWorkspace = true;
|
|
_workspaceVisible = _workspace.paneCount > 0;
|
|
});
|
|
_publishWorkspaceRoute();
|
|
},
|
|
);
|
|
unawaited(
|
|
_workspaceBinding!.start(initialSessionId: widget.initialSessionId),
|
|
);
|
|
}
|
|
|
|
bool _updateWorkspacePersistence(ChatScreen oldWidget) {
|
|
final scope = serverStorageScope(serverIdentity(widget.gateway));
|
|
if (oldWidget.persistWorkspace == widget.persistWorkspace &&
|
|
(!widget.persistWorkspace || scope == _workspaceScope)) {
|
|
return false;
|
|
}
|
|
_workspaceBinding?.dispose();
|
|
_workspaceBinding = null;
|
|
if (_workspaceScope != null && scope != _workspaceScope) {
|
|
_workspace.restoreLayout(ChatWorkspaceSnapshot.fromLayout(null, null)!);
|
|
_forgetRecentSessions();
|
|
_workspaceVisible = false;
|
|
_usedWorkspace = true;
|
|
_sidebarMode = ChatSidebarMode.expanded;
|
|
_publishedWorkspaceSession = null;
|
|
final initial = widget.initialSessionId;
|
|
if (initial != null && initial.isNotEmpty) {
|
|
_workspace.open(initial);
|
|
_workspaceVisible = true;
|
|
}
|
|
}
|
|
_workspaceScope = null;
|
|
_bindWorkspacePersistence();
|
|
return true;
|
|
}
|
|
|
|
final GlobalKey _workspaceKey = GlobalKey();
|
|
bool _workspaceVisible = false;
|
|
bool _usedWorkspace = false;
|
|
String? _publishedWorkspaceSession;
|
|
String _workspaceSignature = '';
|
|
|
|
/// Ctrl+Tab cycles retained panes even when the sidebar or toolbar owns
|
|
/// 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. While the app's
|
|
/// terminal is shown, Ctrl+Tab moves between its tabs instead.
|
|
bool _cycleChatKey(KeyEvent event) {
|
|
final keyboard = HardwareKeyboard.instance;
|
|
if (event is! KeyDownEvent ||
|
|
TerminalScope.peek(context)?.claimsTabKeys == true ||
|
|
event.logicalKey != LogicalKeyboardKey.tab ||
|
|
!keyboard.isControlPressed ||
|
|
keyboard.isMetaPressed ||
|
|
keyboard.isAltPressed ||
|
|
!_workspaceVisible ||
|
|
_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,
|
|
);
|
|
final direction = keyboard.isShiftPressed ? -1 : 1;
|
|
final target =
|
|
panes[((active < 0 ? 0 : active) + direction) % panes.length];
|
|
_workspace.activate(target.id);
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
if (!mounted ||
|
|
!_workspaceVisible ||
|
|
_workspace.activePaneId != target.id) {
|
|
return;
|
|
}
|
|
final destination = ShellBarScope.maybeOf(context)?.registry.focus;
|
|
if (destination == null || destination == AppDestination.chat) {
|
|
_composerFocus.request(target.sessionId);
|
|
}
|
|
});
|
|
WidgetsBinding.instance.ensureVisualUpdate();
|
|
return true;
|
|
}
|
|
|
|
void _workspaceChanged() {
|
|
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;
|
|
_workspaceSignature = signature;
|
|
void update() {
|
|
if (!mounted) return;
|
|
setState(() {});
|
|
_publishWorkspaceRoute();
|
|
}
|
|
|
|
if (SchedulerBinding.instance.schedulerPhase ==
|
|
SchedulerPhase.persistentCallbacks) {
|
|
WidgetsBinding.instance.addPostFrameCallback((_) => update());
|
|
} else {
|
|
update();
|
|
}
|
|
}
|
|
|
|
void _publishWorkspaceRoute() {
|
|
if (!mounted) return;
|
|
final id = _workspace.activePane?.sessionId;
|
|
final destination = ShellBarScope.maybeOf(context)?.registry.focus;
|
|
if (!_workspaceVisible ||
|
|
id == null ||
|
|
id == _publishedWorkspaceSession ||
|
|
(destination != null && destination != AppDestination.chat)) {
|
|
return;
|
|
}
|
|
_publishedWorkspaceSession = id;
|
|
widget.onSessionSelected?.call(id);
|
|
}
|
|
|
|
void _split(JsonMap session, ChatSplitAxis axis) {
|
|
final id = '${session['id'] ?? ''}';
|
|
if (id.isEmpty) return;
|
|
_openedSessions[id] = session;
|
|
_workspaceVisible = true;
|
|
if (!_pageOpen && showsListBesideDetail(context)) _usedWorkspace = true;
|
|
_workspace.splitActive(id, axis);
|
|
if (showsListBesideDetail(context) ||
|
|
chatSelectionFocusesComposer(const {})) {
|
|
_composerFocus.request(id);
|
|
} else {
|
|
_composerFocus.cancel();
|
|
FocusManager.instance.primaryFocus?.unfocus();
|
|
}
|
|
}
|
|
|
|
void _openBeside(JsonMap session) =>
|
|
_split(session, ChatSplitAxis.horizontal);
|
|
void _openBelow(JsonMap session) => _split(session, ChatSplitAxis.vertical);
|
|
|
|
/// The pane's chat trades places with [targetPaneId]'s and keeps focus; the
|
|
/// retained view moves, so its scroll, draft and running turn stay.
|
|
void _movePane(String paneId, String targetPaneId) {
|
|
_workspace.swap(paneId, targetPaneId);
|
|
final session = _workspace.activePane?.sessionId;
|
|
if (session != null) _composerFocus.request(session);
|
|
}
|
|
|
|
void _closePane(String paneId) {
|
|
_workspace.close(paneId);
|
|
if (_workspace.paneCount == 0) _back();
|
|
}
|
|
|
|
void _pickPane(BuildContext context) => showChatPanePicker(
|
|
context,
|
|
panes: [
|
|
for (final pane in _workspace.panes)
|
|
(
|
|
id: pane.id,
|
|
title: '${_rowFor(pane.sessionId)?['title'] ?? pane.sessionId}',
|
|
),
|
|
],
|
|
activeId: _workspace.activePaneId,
|
|
onSelected: (id) {
|
|
_workspace.activate(id);
|
|
final session = _workspace.activePane?.sessionId;
|
|
if (session != null && chatSelectionFocusesComposer(const {})) {
|
|
_composerFocus.request(session);
|
|
}
|
|
},
|
|
);
|
|
|
|
void _addPane(BuildContext context) {
|
|
// The action normally lives in the pane's More menu. Let that menu finish
|
|
// closing before pushing the picker, otherwise its root-overlay teardown
|
|
// can hide the newly opened anchored menu.
|
|
Future<void>.delayed(Duration.zero, () {
|
|
if (!context.mounted) return;
|
|
unawaited(
|
|
showAddChatPanePicker(
|
|
context,
|
|
controller: _sessionsForSidebar,
|
|
sidebarFolds: _foldsForSidebar,
|
|
excludedSessionIds: _workspace.panes
|
|
.map((pane) => pane.sessionId)
|
|
.toSet(),
|
|
onSelected: (session) {
|
|
if (!showsListBesideDetail(context)) {
|
|
// Save a horizontal desktop layout underneath the phone tape.
|
|
// Keep the rail compact so unfolding leaves room for the panes.
|
|
_setSidebarMode(ChatSidebarMode.compact);
|
|
_openBeside(session);
|
|
} else {
|
|
_openBelow(session);
|
|
}
|
|
},
|
|
),
|
|
);
|
|
});
|
|
}
|
|
|
|
Widget _workspaceView() => SafeArea(
|
|
top: false,
|
|
child: ChatCenterStageKeys(
|
|
controller: ChatCenterStageController.instance,
|
|
enabled: () =>
|
|
_workspaceVisible &&
|
|
_workspace.paneCount > 0 &&
|
|
showsListBesideDetail(context) &&
|
|
_chatOwnsKeyboard(),
|
|
child: ChatWorkspace(
|
|
key: _workspaceKey,
|
|
centerStage: ChatCenterStageController.instance,
|
|
paneColor: (pane) =>
|
|
chatColorShade(context, chatSessionColor(_rowFor(pane.sessionId))),
|
|
controller: _workspace,
|
|
onVisibleSessionIdsChanged: _workspaceVisibilityChanged,
|
|
shortcutsEnabled: _workspaceVisible,
|
|
singlePane: !showsListBesideDetail(context),
|
|
mobilePeeks: true,
|
|
paneTitle: (pane) =>
|
|
'${_rowFor(pane.sessionId)?['title'] ?? pane.sessionId}',
|
|
onFocusPane: (pane) => _composerFocus.request(pane.sessionId),
|
|
paneBuilder: (context, pane, active) {
|
|
final scope = ChatWorkspacePaneScope.maybeOf(context);
|
|
final topShared = scope?.topEdgeShared ?? false;
|
|
final bottomShared = scope?.bottomEdgeShared ?? false;
|
|
final leftShared = scope?.leftEdgeShared ?? false;
|
|
final rightShared = scope?.rightEdgeShared ?? false;
|
|
final activeColor = _workspace.paneCount > 1 && active
|
|
? chatColorShade(
|
|
context,
|
|
chatSessionColor(_rowFor(pane.sessionId)),
|
|
) ??
|
|
Theme.of(context).colorScheme.primary
|
|
: Colors.transparent;
|
|
return Semantics(
|
|
selected: active,
|
|
child: AnimatedContainer(
|
|
duration: showsListBesideDetail(context)
|
|
? Motion.of(context, Motion.standard)
|
|
: Duration.zero,
|
|
curve: Motion.curve,
|
|
foregroundDecoration: BoxDecoration(
|
|
border: showsListBesideDetail(context)
|
|
? Border(
|
|
top: bottomShared && !topShared
|
|
? BorderSide(color: activeColor)
|
|
: BorderSide.none,
|
|
bottom: BorderSide(
|
|
color: bottomShared
|
|
? Colors.transparent
|
|
: activeColor,
|
|
),
|
|
left: bottomShared && topShared && !leftShared
|
|
? BorderSide(color: activeColor)
|
|
: BorderSide.none,
|
|
right:
|
|
bottomShared &&
|
|
topShared &&
|
|
leftShared &&
|
|
!rightShared
|
|
? BorderSide(color: activeColor)
|
|
: BorderSide.none,
|
|
)
|
|
: Border(
|
|
bottom: BorderSide(
|
|
color: bottomShared
|
|
? Colors.transparent
|
|
: activeColor,
|
|
),
|
|
),
|
|
),
|
|
// Every pane's bar carries its own chat's colour; beside the
|
|
// active pane the others fade theirs.
|
|
child: ChatPaneActivity(
|
|
inactive: _workspace.paneCount > 1 && !active,
|
|
child: KeyedSubtree(
|
|
key: ValueKey('chat-pane-detail-${pane.id}'),
|
|
child: _thread(pane),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
},
|
|
),
|
|
),
|
|
);
|
|
}
|