de0c06cec1
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.
591 lines
22 KiB
Dart
591 lines
22 KiB
Dart
import '../../shell/destination.dart';
|
|
import '../../shell/shell_bar.dart';
|
|
import '../../shell/detail_page.dart';
|
|
import '../../shell/empty_detail_pane.dart';
|
|
import '../../shell/list_detail.dart';
|
|
import 'dart:async';
|
|
|
|
import 'package:flutter/cupertino.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter/scheduler.dart';
|
|
import 'package:flutter/services.dart';
|
|
|
|
import '../../core/api_gateway.dart';
|
|
import '../../core/servers/server_scope.dart';
|
|
import 'workspace/chat_workspace_binding.dart';
|
|
import 'workspace/chat_workspace_snapshot.dart';
|
|
import 'workspace/chat_workspace_store.dart';
|
|
import 'conversation/chat_models.dart';
|
|
import 'conversation/chat_pane_picker.dart';
|
|
import 'conversation/chat_add_pane_picker.dart';
|
|
import 'conversation/chat_sidebar_controls.dart';
|
|
import 'ui/sessions/chat_compact_sidebar.dart';
|
|
import 'workspace/chat_workspace.dart';
|
|
import 'ui/sessions/chat_adaptive.dart';
|
|
import 'conversation/chat_row_widgets.dart';
|
|
import 'conversation/chat_scroll.dart';
|
|
import 'conversation/chat_thread_view.dart';
|
|
import 'conversation/chat_transcript_cache.dart';
|
|
import 'conversation/composer_focus_request.dart';
|
|
import 'conversation/composer_selection_focus.dart';
|
|
import 'data/chat_repository.dart';
|
|
import 'domain/chat_commands.dart';
|
|
import 'domain/chat_cycle.dart';
|
|
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.
|
|
///
|
|
/// The route names the open session, so a row tap, a deep link and Back all
|
|
/// navigate through the same value. The session list stays mounted (offstage)
|
|
/// while a conversation is open, so returning to it keeps its rows and query.
|
|
/// The destination owns the list controller too, so a session a conversation's
|
|
/// `/new` creates is listed, opened and refreshed from here.
|
|
/// The shell owns the app bar; this screen adds no second one.
|
|
class ChatScreen extends StatefulWidget {
|
|
const ChatScreen({
|
|
super.key,
|
|
required this.gateway,
|
|
this.initialSessionId,
|
|
this.syncToken = 0,
|
|
this.onSessionSelected,
|
|
this.onBack,
|
|
this.persistWorkspace = false,
|
|
});
|
|
|
|
final ApiGateway gateway;
|
|
final bool persistWorkspace;
|
|
|
|
/// The chat session the current route names, or null for the list.
|
|
final String? initialSessionId;
|
|
|
|
/// Advances when the shared socket is replaced. The open conversation
|
|
/// re-subscribes and re-reads in place, so its selection survives.
|
|
final int syncToken;
|
|
|
|
final ValueChanged<String>? onSessionSelected;
|
|
final VoidCallback? onBack;
|
|
|
|
@override
|
|
State<ChatScreen> createState() => _ChatScreenState();
|
|
}
|
|
|
|
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
|
|
/// conversation's command changes a session.
|
|
late final ChatSessionsController _sessions = ChatSessionsController(
|
|
ChatRepository(widget.gateway),
|
|
)..onSessionReplaced = _replacedElsewhere;
|
|
|
|
/// Rows this visit has opened, used for the native title and the recorded
|
|
/// model facts. The mounted list also reports its loaded rows, so a routed id
|
|
/// (a deep link) resolves the same row without a second list request.
|
|
@override
|
|
final Map<String, JsonMap> _openedSessions = {};
|
|
|
|
/// Each row as the list last reported it (without its live `running`), so
|
|
/// [_adoptRows] adopts only what a re-read changed.
|
|
final Map<String, JsonMap> _listedRows = {};
|
|
|
|
/// Model switches the server accepted after a row was opened. The row that
|
|
/// opened the conversation may still carry the pre-switch model, so these win
|
|
/// for the rest of this visit, including when the same chat is reopened.
|
|
final Map<String, ChatModelSelection> _acceptedModels = {};
|
|
|
|
/// Transcript positions for this visit. It lives with the destination, not a
|
|
/// conversation view, so Back and a reopened chat return to the same place.
|
|
final ChatScrollStore _scrollPositions = MemoryChatScrollStore();
|
|
|
|
/// Transcripts of recently left chats for this visit, so a reopened chat
|
|
/// shows its last transcript at once while it re-subscribes and re-reads.
|
|
/// Bounded and in memory only; see [ChatTranscriptCache].
|
|
final ChatTranscriptCache _transcripts = ChatTranscriptCache();
|
|
|
|
/// The line a just-created conversation opens on, tied to the selection
|
|
/// `/new` made. Leaving that conversation drops it, so a later reopen is an
|
|
/// ordinary visit.
|
|
({String id, String notice})? _startNotice;
|
|
|
|
String? _standaloneSelection;
|
|
|
|
/// Ctrl+1…Ctrl+9 put the keyboard in the opened chat's composer; choosing a
|
|
/// chat does too where [chatSelectionFocusesComposer] allows.
|
|
@override
|
|
final ChatComposerFocusRequests _composerFocus = ChatComposerFocusRequests();
|
|
|
|
/// The list's folded sections, kept here so Next chat counts the rows the
|
|
/// list draws.
|
|
final ChatSectionFolds _folds = ChatSectionFolds();
|
|
|
|
/// Whether the last build offered Next chat, so a list change rebuilds only
|
|
/// when that changes.
|
|
bool _offeredNext = false;
|
|
|
|
@override
|
|
ChatSessionsController get _sessionsForSidebar => _sessions;
|
|
@override
|
|
ChatSectionFolds get _foldsForSidebar => _folds;
|
|
@override
|
|
void _openSidebarSession(JsonMap session) => _openBySelection(session);
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
final initial = widget.initialSessionId;
|
|
if (initial != null && initial.isNotEmpty) {
|
|
_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);
|
|
_folds.addListener(_nextChanged);
|
|
}
|
|
|
|
/// The chat after [id] as the list draws it (Starred, then Chats by
|
|
/// directory, then Closed, skipping folded sections), wrapping around. The
|
|
/// embedded list has no search field, so no query narrows it.
|
|
JsonMap? _nextAfter(String id) => chatSessionAfter(
|
|
chatSessionsShown(_sessions.sessions, query: '', isOpen: _folds.isOpen),
|
|
id,
|
|
);
|
|
|
|
/// Next chat opens that row exactly as a tap on it would.
|
|
void _openNext(String id) {
|
|
final next = _nextAfter(id);
|
|
if (next != null) _openBySelection(next);
|
|
}
|
|
|
|
void _nextChanged() {
|
|
if (!mounted) return;
|
|
final id = _selected;
|
|
final offered = id != null && _nextAfter(id) != null;
|
|
if (offered == _offeredNext) return;
|
|
// The list may load while it builds; rebuild after that frame.
|
|
if (SchedulerBinding.instance.schedulerPhase ==
|
|
SchedulerPhase.persistentCallbacks) {
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
if (mounted) setState(() {});
|
|
});
|
|
} else {
|
|
setState(() {});
|
|
}
|
|
}
|
|
|
|
String? get _selected {
|
|
if (_workspaceVisible && _workspace.activePane != null) {
|
|
return _workspace.activePane!.sessionId;
|
|
}
|
|
if (!_workspaceVisible && _usedWorkspace) return null;
|
|
final routed = widget.initialSessionId;
|
|
if (routed != null && routed.isNotEmpty) return routed;
|
|
return _standaloneSelection;
|
|
}
|
|
|
|
/// Opens [session] from the keyboard: its composer takes focus once built,
|
|
/// also when it is the chat already open.
|
|
void _openByShortcut(JsonMap session) => _open(session, focusComposer: true);
|
|
|
|
/// Opens [session] chosen by a tap, click or Next chat: its composer takes
|
|
/// focus on a desktop host or after a mouse click, not from a finger on a
|
|
/// phone or tablet (see [chatSelectionFocusesComposer]).
|
|
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;
|
|
if (focusComposer) {
|
|
_composerFocus.request(id);
|
|
} else {
|
|
_composerFocus.cancel();
|
|
}
|
|
_openedSessions[id] = session;
|
|
_workspaceVisible = true;
|
|
_workspace.open(id);
|
|
if (_startNotice?.id != id) _startNotice = null;
|
|
final select = widget.onSessionSelected;
|
|
if (select != null) {
|
|
if (_publishedWorkspaceSession != id) {
|
|
_publishedWorkspaceSession = id;
|
|
select(id);
|
|
}
|
|
} else {
|
|
setState(() => _standaloneSelection = id);
|
|
}
|
|
}
|
|
|
|
/// `/new` moved the chat [previousId] to a fresh session: [session] takes
|
|
/// its list row, the fresh conversation opens on [notice], then the list
|
|
/// re-reads from the server.
|
|
void _startedNewSession(String previousId, JsonMap session, String notice) {
|
|
final id = '${session['id'] ?? ''}';
|
|
if (id.isEmpty) return;
|
|
_sessions.replaceSession(previousId, session);
|
|
_followNewSession(previousId, session, notice);
|
|
unawaited(_sessions.refresh());
|
|
}
|
|
|
|
/// Another device started a new session in a chat: only an open chat
|
|
/// follows it; the list already swapped the row.
|
|
void _replacedElsewhere(String previousId, JsonMap session) {
|
|
if (!mounted ||
|
|
!_workspace.panes.any((pane) => pane.sessionId == previousId)) {
|
|
return;
|
|
}
|
|
_followNewSession(previousId, session, chatNewSessionElsewhereNotice);
|
|
}
|
|
|
|
/// Opens the chat under its new id on the server's row, which carries every
|
|
/// shared field (an omitted one is unset, so the old row is not merged in).
|
|
/// A model switch accepted here in this visit moved with the chat.
|
|
void _followNewSession(String previousId, JsonMap session, String notice) {
|
|
final id = '${session['id'] ?? ''}';
|
|
final accepted = _acceptedModels[previousId];
|
|
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);
|
|
}
|
|
|
|
/// `/rename` was accepted for [id]: the opened row follows the shared title
|
|
/// and the list re-reads it.
|
|
void _renamed(String id, String title) {
|
|
final row = _openedSessions[id];
|
|
if (row != null) {
|
|
setState(() => _openedSessions[id] = {...row, 'title': title});
|
|
}
|
|
unawaited(_sessions.refresh());
|
|
}
|
|
|
|
/// `/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)
|
|
.toList()) {
|
|
_closePane(pane.id);
|
|
}
|
|
unawaited(_sessions.refresh());
|
|
}
|
|
|
|
/// Adopts the list's loaded rows for the routed session and for every row
|
|
/// this visit has opened. A deep link opens the conversation before any row
|
|
/// has been tapped, and a created or long-open row can predate facts the
|
|
/// list has since read (its mode, a mode another device chose, a title).
|
|
/// The header's title, model and mode controls come from that row, so the
|
|
/// open conversation follows each re-read instead of waiting to be reopened.
|
|
/// Only a listed row that changed since the list last reported it is
|
|
/// adopted, so an unchanged (or still loading) listing never reverts a mode
|
|
/// or model this visit has just accepted. Fields only the opened row carries
|
|
/// (a create's instruction status) are kept. The list's live `running` flag
|
|
/// is ignored: the conversation tracks its own turn, and following it would
|
|
/// rebuild the open thread at every turn. Called after a frame, never during
|
|
/// the list's own build.
|
|
void _adoptRows(List<JsonMap> rows) {
|
|
if (!mounted) return;
|
|
final selected = _selected;
|
|
final retained = _workspace.panes.map((pane) => pane.sessionId).toSet();
|
|
final next = <String, JsonMap>{};
|
|
for (final row in rows) {
|
|
final id = '${row['id'] ?? ''}';
|
|
if (id.isEmpty) continue;
|
|
final listed = <String, dynamic>{...row}..remove('running');
|
|
final previous = _listedRows[id];
|
|
_listedRows[id] = listed;
|
|
final opened = _openedSessions[id];
|
|
if (opened == null && id != selected && !retained.contains(id)) continue;
|
|
if (opened != null && chatJsonEquals(previous, listed)) continue;
|
|
final adopted = <String, dynamic>{...?opened, ...listed};
|
|
if (opened != null && opened.containsKey('running')) {
|
|
adopted['running'] = opened['running'];
|
|
}
|
|
if (!chatJsonEquals(opened, adopted)) next[id] = adopted;
|
|
}
|
|
if (next.isEmpty) return;
|
|
setState(() => _openedSessions.addAll(next));
|
|
}
|
|
|
|
void _modelChanged(String id, ChatModelSelection applied) {
|
|
if (!mounted) return;
|
|
setState(() => _acceptedModels[id] = applied);
|
|
}
|
|
|
|
/// An accepted mode switch updates the opened row, so reopening the chat in
|
|
/// this visit shows it before the list re-reads. The list then re-reads, so
|
|
/// a listing already in flight from before the switch is superseded rather
|
|
/// than adopted over the accepted mode.
|
|
void _modeChanged(String id, String mode, String name) {
|
|
final row = _openedSessions[id];
|
|
if (!mounted || row == null) return;
|
|
setState(
|
|
() => _openedSessions[id] = {...row, 'mode': mode, 'mode_name': name},
|
|
);
|
|
unawaited(_sessions.refresh());
|
|
}
|
|
|
|
/// The row to open for [id], with an accepted model folded in.
|
|
@override
|
|
JsonMap? _rowFor(String id) {
|
|
final row = _openedSessions[id] ?? _listedRows[id];
|
|
final accepted = _acceptedModels[id];
|
|
if (row == null || accepted == null) return row;
|
|
return {
|
|
...row,
|
|
'model': accepted.model,
|
|
'model_provider': accepted.provider,
|
|
'model_selection': accepted.selection,
|
|
};
|
|
}
|
|
|
|
@override
|
|
void _back() {
|
|
_workspaceVisible = false;
|
|
_publishedWorkspaceSession = null;
|
|
_startNotice = null;
|
|
_composerFocus.cancel();
|
|
final back = widget.onBack;
|
|
if (back != null) {
|
|
back();
|
|
} else {
|
|
setState(() => _standaloneSelection = null);
|
|
}
|
|
}
|
|
|
|
/// On a phone the open chat is a real page above the main screen.
|
|
final DetailPageHost _page = DetailPageHost();
|
|
@override
|
|
bool get _pageOpen => _page.open;
|
|
|
|
@override
|
|
void didUpdateWidget(covariant ChatScreen oldWidget) {
|
|
super.didUpdateWidget(oldWidget);
|
|
final reboundWorkspace = _updateWorkspacePersistence(oldWidget);
|
|
if (!reboundWorkspace &&
|
|
oldWidget.initialSessionId != widget.initialSessionId) {
|
|
_workspaceBinding?.changed();
|
|
final id = widget.initialSessionId;
|
|
if (id != null && id.isNotEmpty) {
|
|
_workspaceVisible = true;
|
|
_publishedWorkspaceSession = id;
|
|
_workspace.open(id);
|
|
} else if (widget.onSessionSelected != null) {
|
|
_workspaceVisible = false;
|
|
}
|
|
}
|
|
// Transcripts read through another gateway belong to that server.
|
|
if (oldWidget.gateway != widget.gateway) _transcripts.clear();
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
HardwareKeyboard.instance.removeHandler(_cycleChatKey);
|
|
HardwareKeyboard.instance.removeHandler(_slashFocusKey);
|
|
_page.dispose();
|
|
_workspaceBinding?.dispose();
|
|
_workspace.removeListener(_workspaceChanged);
|
|
_workspace.dispose();
|
|
_sessions.dispose();
|
|
_folds.dispose();
|
|
_composerFocus.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
Widget _thread(
|
|
String selected,
|
|
VoidCallback onBack, {
|
|
ChatWorkspacePane? pane,
|
|
BuildContext? paneContext,
|
|
}) {
|
|
final row = _rowFor(selected);
|
|
final start = _startNotice;
|
|
final thread = ChatThreadView(
|
|
key: ValueKey<String>('chat-session-$selected'),
|
|
gateway: widget.gateway,
|
|
sessionId: selected,
|
|
title: '${row?['title'] ?? ''}'.trim(),
|
|
session: row,
|
|
syncToken: widget.syncToken,
|
|
scrollPositions: _scrollPositions,
|
|
transcripts: _transcripts,
|
|
initialNotice: start != null && start.id == selected
|
|
? start.notice
|
|
: null,
|
|
onBack: onBack,
|
|
onModelChanged: (applied) => _modelChanged(selected, applied),
|
|
onModeChanged: (mode, name) => _modeChanged(selected, mode, name),
|
|
onNewSession: _startedNewSession,
|
|
onSessionRenamed: (title) => _renamed(selected, title),
|
|
onSessionClosed: () => _closed(selected),
|
|
onColorSelected: (color) => _sessions.setColor(selected, color),
|
|
onNextChat: _nextAfter(selected) != null
|
|
? () => _openNext(selected)
|
|
: null,
|
|
useNativeBack: _page.open,
|
|
showBackButton: pane == null
|
|
? null
|
|
: _page.open || !showsListBesideDetail(context),
|
|
sidebarControl:
|
|
pane == null || _page.open || !showsListBesideDetail(context)
|
|
? null
|
|
: ChatSidebarButton(mode: _sidebarMode, onChanged: _setSidebarMode),
|
|
paneControls: pane == null
|
|
? const []
|
|
: [
|
|
ChatBarAction(
|
|
label: 'Add chat pane',
|
|
onPressed: () => _addPane(paneContext ?? context),
|
|
materialIcon: Icons.add_box_outlined,
|
|
cupertinoIcon: CupertinoIcons.plus_square,
|
|
),
|
|
if (_workspace.paneCount > 1)
|
|
ChatBarAction(
|
|
label: 'Open chats (${_workspace.paneCount})',
|
|
onPressed: () => _pickPane(paneContext ?? context),
|
|
materialIcon: Icons.view_quilt_outlined,
|
|
cupertinoIcon: CupertinoIcons.square_split_2x2,
|
|
),
|
|
if (_workspace.paneCount > 1)
|
|
ChatBarAction(
|
|
label: 'Close pane',
|
|
onPressed: () => _closePane(pane.id),
|
|
materialIcon: Icons.close,
|
|
cupertinoIcon: CupertinoIcons.xmark,
|
|
),
|
|
],
|
|
);
|
|
return ChatComposerFocusScope(
|
|
sessionId: selected,
|
|
requests: _composerFocus,
|
|
child: thread,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final selected = _selected;
|
|
if (_workspaceVisible && selected != _publishedWorkspaceSession) {
|
|
WidgetsBinding.instance.addPostFrameCallback(
|
|
(_) => _publishWorkspaceRoute(),
|
|
);
|
|
}
|
|
_offeredNext = selected != null && _nextAfter(selected) != null;
|
|
// A phone opens a chat as a real Navigator page with stock Back. A wide
|
|
// window keeps the destination rail and the chat list beside the open
|
|
// chat, which has no Back: another row, `/close` or a route change swaps it.
|
|
final beside = !_page.open && showsListBesideDetail(context);
|
|
if (beside && selected != null) _usedWorkspace = true;
|
|
_page.sync(
|
|
context,
|
|
selected: selected != null && !beside && !_usedWorkspace,
|
|
destination: AppDestination.chat,
|
|
onClosed: _back,
|
|
builder: (context) => selected == null
|
|
? const SizedBox.shrink()
|
|
: ShellBar(barless: true, child: _workspaceView()),
|
|
);
|
|
// The session list pads its first row by the bar's height itself, so it
|
|
// scrolls behind the shell's floating bar like the other lists.
|
|
final fullList = ChatSessionsScreen(
|
|
gateway: widget.gateway,
|
|
embedded: true,
|
|
syncToken: widget.syncToken,
|
|
controller: _sessions,
|
|
folds: _folds,
|
|
onOpen: _openBySelection,
|
|
onOpenBeside: beside ? _openBeside : null,
|
|
onOpenBelow: _openBelow,
|
|
onShortcutOpen: _openByShortcut,
|
|
onSessions: _adoptRows,
|
|
activeSessionId: selected,
|
|
publishShellBar:
|
|
(selected == null ||
|
|
!beside ||
|
|
_sidebarMode == ChatSidebarMode.expanded) &&
|
|
(beside || !_usedWorkspace || selected == null),
|
|
);
|
|
final list = _sidebarList(fullList, selected, beside);
|
|
if (!beside) {
|
|
if (!_usedWorkspace) return list;
|
|
final media = MediaQuery.of(context);
|
|
final system = ShellSystemInsets.of(context);
|
|
return PopScope(
|
|
canPop: selected == null,
|
|
onPopInvokedWithResult: (didPop, _) {
|
|
if (!didPop && selected != null) _back();
|
|
},
|
|
child: ShellBar(
|
|
active: selected != null,
|
|
barless: true,
|
|
hideNavigation: true,
|
|
child: Stack(
|
|
fit: StackFit.expand,
|
|
children: [
|
|
Offstage(
|
|
offstage: selected != null,
|
|
child: ExcludeFocus(excluding: selected != null, child: list),
|
|
),
|
|
Offstage(
|
|
offstage: selected == null,
|
|
child: ExcludeFocus(
|
|
excluding: selected == null,
|
|
child: MediaQuery(
|
|
data: media.copyWith(
|
|
padding: media.padding.copyWith(top: system.top),
|
|
),
|
|
child: _workspaceView(),
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
return ShellBar(
|
|
active: selected != null && _sidebarMode != ChatSidebarMode.expanded,
|
|
barless: true,
|
|
hideNavigation: true,
|
|
child: ListDetailPanes(
|
|
list: list,
|
|
listWidthOverride: selected == null
|
|
? null
|
|
: switch (_sidebarMode) {
|
|
ChatSidebarMode.expanded => null,
|
|
ChatSidebarMode.compact => ChatCompactSidebar.width,
|
|
ChatSidebarMode.hidden => 0,
|
|
},
|
|
detailIdentity: selected,
|
|
detail: selected == null
|
|
? const EmptyDetailPane(
|
|
destination: AppDestination.chat,
|
|
message: 'Select a chat to open it here.',
|
|
)
|
|
: SizedBox.expand(
|
|
key: const ValueKey('chat-detail-pane'),
|
|
child: _workspaceView(),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|