4668deeaf7
Raise the most recently used chat when Ctrl+Y is invoked from another window, then rely on the existing host lifecycle to focus its composer. Preserve toggle behavior while chat is active and retain the Apple shortcut aliases.
281 lines
8.6 KiB
Dart
281 lines
8.6 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter/services.dart';
|
|
|
|
import '../../../core/api_gateway.dart';
|
|
import '../../../shell/list_detail_policy.dart';
|
|
import '../../../shell/windows/window_entry.dart';
|
|
import '../../../shell/windows/window_kind.dart';
|
|
import '../../../shell/windows/window_manager.dart';
|
|
import '../chat_runtime.dart';
|
|
import '../domain/chat_commands.dart';
|
|
import '../workspace/chat_float_shortcut.dart';
|
|
import '../workspace/chat_float_store.dart';
|
|
import 'chat_window_content.dart';
|
|
|
|
const chatWindowKind = 'chat';
|
|
|
|
/// What the mounted Chat destination offers the chat windows: its tiling.
|
|
class ChatTiling {
|
|
const ChatTiling({
|
|
required this.holds,
|
|
required this.dock,
|
|
required this.canFloatActive,
|
|
required this.floatActive,
|
|
});
|
|
|
|
/// Whether the tiling shows [sessionId].
|
|
final bool Function(String sessionId) holds;
|
|
|
|
/// Puts a chat back into the tiling.
|
|
final void Function(String sessionId) dock;
|
|
|
|
/// Whether the chord can float the active pane now.
|
|
final bool Function() canFloatActive;
|
|
final VoidCallback floatActive;
|
|
}
|
|
|
|
/// The floating chat windows, for the app's lifetime: the `chat` window kind
|
|
/// over the app's [WindowManager], its chord (see [chatFloatShortcut]), and
|
|
/// what `/new` and `/close` do to a chat in a window. The windows are built
|
|
/// from [runtime], so they show whatever destination is open, also when the
|
|
/// Chat destination has never been built.
|
|
class ChatWindows {
|
|
ChatWindows({
|
|
required this.manager,
|
|
required this.runtime,
|
|
required this.openInChat,
|
|
this._ready,
|
|
Listenable? readiness,
|
|
}) : readiness = readiness ?? const _Never();
|
|
|
|
final WindowManager manager;
|
|
final ChatRuntime runtime;
|
|
|
|
/// Opens a chat in the Chat destination (when no tiling is mounted to
|
|
/// dock into).
|
|
final void Function(String sessionId) openInChat;
|
|
final bool Function()? _ready;
|
|
|
|
/// Notifies when [ready] may have changed.
|
|
final Listenable readiness;
|
|
|
|
/// The mounted Chat destination's tiling, if it is built.
|
|
ChatTiling? tiling;
|
|
|
|
late final ChatWindowKind kind = ChatWindowKind(this);
|
|
bool _started = false;
|
|
|
|
/// Whether the server has been reached, so a chat can be read.
|
|
bool get ready => _ready?.call() ?? true;
|
|
|
|
Iterable<WindowEntry> get windows =>
|
|
manager.windows.where((w) => w.kind == chatWindowKind);
|
|
|
|
/// Registers the kind and starts answering the chord. Call before the
|
|
/// manager restores, so saved chat windows are kept.
|
|
void start() {
|
|
if (_started) return;
|
|
_started = true;
|
|
manager.kinds.register(kind);
|
|
FocusManager.instance.addEarlyKeyEventHandler(_key);
|
|
runtime.addSessionReplacedListener(_replacedElsewhere);
|
|
runtime.sessions.addListener(_rowsChanged);
|
|
manager.addListener(_rowsChanged);
|
|
readiness.addListener(_rowsChanged);
|
|
}
|
|
|
|
void dispose() {
|
|
if (!_started) return;
|
|
_started = false;
|
|
FocusManager.instance.removeEarlyKeyEventHandler(_key);
|
|
runtime.removeSessionReplacedListener(_replacedElsewhere);
|
|
runtime.sessions.removeListener(_rowsChanged);
|
|
manager.removeListener(_rowsChanged);
|
|
readiness.removeListener(_rowsChanged);
|
|
manager.kinds.unregister(chatWindowKind);
|
|
}
|
|
|
|
/// Opens the windows an older build saved (`pipelines.next.chatFloat.v1`,
|
|
/// both formats) once, after the manager restored and found none.
|
|
Future<void> migrate(ChatFloatStore legacy) async {
|
|
final record = await legacy.read();
|
|
if (record == null || record.panes.isEmpty || !_started) return;
|
|
if (windows.isEmpty) {
|
|
for (final pane in record.panes) {
|
|
manager.open(
|
|
chatWindowKind,
|
|
pane.sessionId,
|
|
frame: record.frames[pane.id],
|
|
);
|
|
}
|
|
if (!record.shown) manager.setGroupShown(chatWindowKind, false);
|
|
}
|
|
await legacy.write(const ChatFloatRecord());
|
|
}
|
|
|
|
/// Shows the window [sessionId] is in; false when it is in none.
|
|
bool show(String sessionId) {
|
|
final entry = manager.find(chatWindowKind, sessionId);
|
|
if (entry == null) return false;
|
|
manager.show(entry.id);
|
|
return true;
|
|
}
|
|
|
|
/// Opens [sessionId] in a window (the caller took it out of the tiling).
|
|
void float(String sessionId) => manager.open(chatWindowKind, sessionId);
|
|
|
|
/// Puts the window's chat back into the tiling, or opens it in the Chat
|
|
/// destination when that is not built.
|
|
void dock(WindowEntry entry) {
|
|
final tiling = this.tiling;
|
|
manager.close(entry.id);
|
|
if (tiling != null) {
|
|
tiling.dock(entry.contentId);
|
|
} else {
|
|
openInChat(entry.contentId);
|
|
}
|
|
}
|
|
|
|
/// `/new` in a window's chat: the window follows the new session, unless
|
|
/// that session is already open elsewhere.
|
|
void startedNewSession(
|
|
String windowId,
|
|
String previousId,
|
|
JsonMap session,
|
|
String notice,
|
|
) {
|
|
runtime.sessions.replaceSession(previousId, session);
|
|
_follow(windowId, previousId, session, notice);
|
|
unawaited(runtime.sessions.refresh());
|
|
}
|
|
|
|
void _replacedElsewhere(String previousId, JsonMap session) {
|
|
final entry = manager.find(chatWindowKind, previousId);
|
|
if (entry == null) return;
|
|
_follow(entry.id, previousId, session, chatNewSessionElsewhereNotice);
|
|
}
|
|
|
|
void _follow(
|
|
String windowId,
|
|
String previousId,
|
|
JsonMap session,
|
|
String notice,
|
|
) {
|
|
final id = '${session['id'] ?? ''}';
|
|
if (id.isEmpty) return;
|
|
final elsewhere =
|
|
manager.find(chatWindowKind, id) != null ||
|
|
(tiling?.holds(id) ?? false);
|
|
if (elsewhere) {
|
|
manager.close(windowId);
|
|
return;
|
|
}
|
|
runtime.movedToSession(previousId, session, notice);
|
|
manager.setContent(windowId, id);
|
|
}
|
|
|
|
/// `/close` was accepted for a window's chat.
|
|
void sessionClosed(String windowId) {
|
|
manager.close(windowId);
|
|
unawaited(runtime.sessions.refresh());
|
|
}
|
|
|
|
bool _reading = false;
|
|
|
|
/// The windows' chats take their rows (title, model, mode) from the
|
|
/// session list, which nothing else reads while the Chat destination is
|
|
/// not built.
|
|
void _rowsChanged() {
|
|
final ids = {for (final w in windows) w.contentId};
|
|
if (ids.isEmpty || !ready) return;
|
|
final sessions = runtime.sessions;
|
|
if (ids.any((id) => runtime.rowFor(id) == null) && !_reading) {
|
|
_reading = true;
|
|
unawaited(sessions.refresh().whenComplete(() => _reading = false));
|
|
}
|
|
final rows = sessions.sessions;
|
|
scheduleMicrotask(() {
|
|
if (_started) runtime.adoptRows(rows, selected: null, retained: ids);
|
|
});
|
|
}
|
|
|
|
bool get _wide {
|
|
final view = WidgetsBinding.instance.platformDispatcher.views.firstOrNull;
|
|
return view == null ||
|
|
view.physicalSize.width / view.devicePixelRatio >= kListDetailMinWidth;
|
|
}
|
|
|
|
/// Handled before any focused widget sees the key, so it works from a
|
|
/// composer or the terminal; ignored (left to them) when it does nothing.
|
|
KeyEventResult _key(KeyEvent event) {
|
|
if (!_wide || !chatFloatShortcut(event, HardwareKeyboard.instance)) {
|
|
return KeyEventResult.ignored;
|
|
}
|
|
if (windows.isEmpty) {
|
|
final tiling = this.tiling;
|
|
if (tiling == null || !tiling.canFloatActive()) {
|
|
return KeyEventResult.ignored;
|
|
}
|
|
if (event is KeyDownEvent) tiling.floatActive();
|
|
return KeyEventResult.handled;
|
|
}
|
|
if (event is KeyDownEvent) manager.toggleOrRaiseGroup(chatWindowKind);
|
|
return KeyEventResult.handled;
|
|
}
|
|
}
|
|
|
|
class _Never implements Listenable {
|
|
const _Never();
|
|
@override
|
|
void addListener(VoidCallback listener) {}
|
|
@override
|
|
void removeListener(VoidCallback listener) {}
|
|
}
|
|
|
|
/// A chat in a floating window.
|
|
class ChatWindowKind extends WindowKind {
|
|
ChatWindowKind(this.windows);
|
|
|
|
final ChatWindows windows;
|
|
|
|
@override
|
|
String get key => chatWindowKind;
|
|
@override
|
|
bool get serverScoped => true;
|
|
@override
|
|
IconData get icon => Icons.chat_bubble_outline;
|
|
@override
|
|
Size get minSize => chatFloatMinSize;
|
|
@override
|
|
Rect get defaultFrame => chatFloatDefaultRect;
|
|
|
|
/// Chats float beside the chat list, on a wide layout only.
|
|
@override
|
|
double get minHostWidth => kListDetailMinWidth;
|
|
@override
|
|
Listenable get changes => windows.runtime;
|
|
|
|
@override
|
|
String title(BuildContext context, WindowEntry entry) =>
|
|
windows.runtime.titleFor(entry.contentId);
|
|
|
|
@override
|
|
Widget build(BuildContext context, WindowEntry entry) =>
|
|
ChatWindowContent(windows: windows, entry: entry);
|
|
|
|
@override
|
|
List<WindowAction> actions(BuildContext context, WindowEntry entry) => [
|
|
WindowAction(
|
|
label: 'Dock',
|
|
icon: Icons.vertical_split_outlined,
|
|
onPressed: () => windows.dock(entry),
|
|
),
|
|
];
|
|
|
|
@override
|
|
void focusContent(WindowEntry entry) =>
|
|
windows.runtime.composerFocus.request(entry.contentId);
|
|
}
|