fdc730422d
Phase 2.3 and 2.4 of docs/plans/floating-windows.md. A floating chat is a window of the chat kind over the app's WindowManager, built from the app-lifetime ChatRuntime, so it shows over every destination and at start without the Chat destination being built. Float and Dock move the same keyed view between the tiling and the window host. The pipelines app keeps one runtime and one ChatWindows; saved chatFloat records (v1 and v2) are brought over once. ChatFloatHost, ChatFloatWindow, the float frames and binding, the controller's float list and FloatingFocusRoot are gone; the workspace only asks whether a chat is out in a window. Every MenuAnchor targets the root overlay (guarded by a test), and menus and tooltips name the Alt chords.
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.toggleGroup(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);
|
|
}
|