Float one chat pane over the app and toggle it with Ctrl+Y / Cmd+Y
This commit is contained in:
@@ -0,0 +1,85 @@
|
||||
part of 'screen.dart';
|
||||
|
||||
/// The floating chat for one Chat destination visit: its menu choices, its
|
||||
/// window frame and its persistence (see `notes/chat-floating-pane.md`).
|
||||
mixin _ChatScreenFloat on State<ChatScreen>, _ChatScreenWorkspace {
|
||||
@override
|
||||
final ChatFloatFrame _floatFrame = ChatFloatFrame();
|
||||
ChatFloatBinding? _floatBinding;
|
||||
|
||||
/// Restores and saves the floating chat in [store] once [restored] (the
|
||||
/// workspace layout's own restore) completes.
|
||||
@override
|
||||
void _bindFloat(ChatFloatStore store, Future<void> restored) {
|
||||
_floatBinding?.dispose();
|
||||
final binding = _floatBinding = ChatFloatBinding(
|
||||
controller: _workspace,
|
||||
frame: _floatFrame,
|
||||
store: store,
|
||||
);
|
||||
unawaited(
|
||||
restored.then((_) {
|
||||
if (mounted && identical(_floatBinding, binding)) {
|
||||
return binding.start();
|
||||
}
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
@override
|
||||
void _unbindFloat() {
|
||||
_floatBinding?.dispose();
|
||||
_floatBinding = null;
|
||||
}
|
||||
|
||||
void _disposeFloat() {
|
||||
_unbindFloat();
|
||||
_floatFrame.dispose();
|
||||
}
|
||||
|
||||
/// Panes float only on a wide layout, beside the chat list.
|
||||
bool get _floatsHere => !_pageOpen && showsListBesideDetail(context);
|
||||
|
||||
void _dockFloat() {
|
||||
final pane = _workspace.floatingPane;
|
||||
_workspace.dock();
|
||||
if (pane != null) _composerFocus.request(pane.sessionId);
|
||||
}
|
||||
|
||||
/// The pane menu's floating choices: Float on a tiled pane that can, and
|
||||
/// Dock, Hide and Close on the floating chat.
|
||||
List<Widget> _floatControls(ChatWorkspacePane pane) {
|
||||
final shortcut = chatFloatShortcutLabel();
|
||||
if (_workspace.floatingPane?.id == pane.id) {
|
||||
return [
|
||||
ChatBarAction(
|
||||
label: 'Dock',
|
||||
onPressed: _dockFloat,
|
||||
materialIcon: Icons.vertical_split_outlined,
|
||||
cupertinoIcon: CupertinoIcons.rectangle_split_3x1,
|
||||
),
|
||||
ChatBarAction(
|
||||
label: 'Hide floating chat ($shortcut)',
|
||||
onPressed: () => _workspace.setFloatShown(false),
|
||||
materialIcon: Icons.visibility_off_outlined,
|
||||
cupertinoIcon: CupertinoIcons.eye_slash,
|
||||
),
|
||||
ChatBarAction(
|
||||
label: 'Close pane',
|
||||
onPressed: () => _closePane(pane.id),
|
||||
materialIcon: Icons.close,
|
||||
cupertinoIcon: CupertinoIcons.xmark,
|
||||
),
|
||||
];
|
||||
}
|
||||
if (!_floatsHere || !_workspace.canFloat(pane.id)) return const [];
|
||||
return [
|
||||
ChatBarAction(
|
||||
label: 'Float ($shortcut)',
|
||||
onPressed: () => _workspace.float(pane.id),
|
||||
materialIcon: Icons.picture_in_picture_alt_outlined,
|
||||
cupertinoIcon: CupertinoIcons.rectangle_on_rectangle,
|
||||
),
|
||||
];
|
||||
}
|
||||
}
|
||||
@@ -11,6 +11,9 @@ mixin _ChatScreenWorkspace on State<ChatScreen> {
|
||||
JsonMap? _rowFor(String id);
|
||||
void _back();
|
||||
bool get _pageOpen;
|
||||
ChatFloatFrame get _floatFrame;
|
||||
void _bindFloat(ChatFloatStore store, Future<void> restored);
|
||||
void _unbindFloat();
|
||||
Widget _thread(
|
||||
String selected,
|
||||
VoidCallback onBack, {
|
||||
@@ -114,8 +117,17 @@ mixin _ChatScreenWorkspace on State<ChatScreen> {
|
||||
_publishWorkspaceRoute();
|
||||
},
|
||||
);
|
||||
unawaited(
|
||||
_workspaceBinding!.start(initialSessionId: widget.initialSessionId),
|
||||
final restored = _workspaceBinding!.start(
|
||||
initialSessionId: widget.initialSessionId,
|
||||
);
|
||||
unawaited(restored);
|
||||
_bindFloat(
|
||||
SharedPreferencesChatFloatStore(
|
||||
serverScope: widget.gateway is FederatedChatGateway
|
||||
? 'all-saved-servers'
|
||||
: scope,
|
||||
),
|
||||
restored,
|
||||
);
|
||||
}
|
||||
|
||||
@@ -127,6 +139,7 @@ mixin _ChatScreenWorkspace on State<ChatScreen> {
|
||||
}
|
||||
_workspaceBinding?.dispose();
|
||||
_workspaceBinding = null;
|
||||
_unbindFloat();
|
||||
if (_workspaceScope != null && scope != _workspaceScope) {
|
||||
_workspace.restoreLayout(ChatWorkspaceSnapshot.fromLayout(null, null)!);
|
||||
_forgetRecentSessions();
|
||||
@@ -297,6 +310,7 @@ mixin _ChatScreenWorkspace on State<ChatScreen> {
|
||||
controller: _workspace,
|
||||
onVisibleSessionIdsChanged: _workspaceVisibilityChanged,
|
||||
shortcutsEnabled: _workspaceVisible,
|
||||
floatFrame: _floatFrame,
|
||||
singlePane: !showsListBesideDetail(context),
|
||||
mobilePeeks: true,
|
||||
paneTitle: (pane) =>
|
||||
|
||||
@@ -20,6 +20,9 @@ import 'package:flutter/services.dart';
|
||||
|
||||
import '../../core/api_gateway.dart';
|
||||
import '../../core/servers/server_scope.dart';
|
||||
import 'workspace/chat_float_binding.dart';
|
||||
import 'workspace/chat_float_shortcut.dart';
|
||||
import 'workspace/chat_float_store.dart';
|
||||
import 'workspace/chat_workspace_binding.dart';
|
||||
import 'workspace/chat_workspace_snapshot.dart';
|
||||
import 'workspace/chat_workspace_store.dart';
|
||||
@@ -50,6 +53,7 @@ import 'ui/sessions/chat_sessions_controller.dart';
|
||||
import 'ui/sessions/chat_sessions_screen.dart';
|
||||
import '../../ui/input/keyboard_owner.dart';
|
||||
|
||||
part 'chat_screen_float.dart';
|
||||
part 'chat_screen_keys.dart';
|
||||
part 'chat_screen_workspace.dart';
|
||||
|
||||
@@ -94,7 +98,7 @@ class ChatScreen extends StatefulWidget {
|
||||
}
|
||||
|
||||
class _ChatScreenState extends State<ChatScreen>
|
||||
with _ChatScreenWorkspace, _ChatScreenKeys {
|
||||
with _ChatScreenWorkspace, _ChatScreenKeys, _ChatScreenFloat {
|
||||
/// 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
|
||||
@@ -273,10 +277,7 @@ class _ChatScreenState extends State<ChatScreen>
|
||||
/// 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;
|
||||
}
|
||||
if (!mounted || !_workspace.holdsSession(previousId)) return;
|
||||
_followNewSession(previousId, session, chatNewSessionElsewhereNotice);
|
||||
}
|
||||
|
||||
@@ -314,6 +315,8 @@ class _ChatScreenState extends State<ChatScreen>
|
||||
.toList()) {
|
||||
_closePane(pane.id);
|
||||
}
|
||||
final floating = _workspace.floatingPane;
|
||||
if (floating?.sessionId == sessionId) _closePane(floating!.id);
|
||||
unawaited(_sessions.refresh());
|
||||
}
|
||||
|
||||
@@ -452,6 +455,7 @@ class _ChatScreenState extends State<ChatScreen>
|
||||
HardwareKeyboard.instance.removeHandler(_slashFocusKey);
|
||||
_page.dispose();
|
||||
_workspaceBinding?.dispose();
|
||||
_disposeFloat();
|
||||
_workspace.removeListener(_workspaceChanged);
|
||||
_workspace.dispose();
|
||||
_sessions.removeListener(_nextChanged);
|
||||
@@ -505,6 +509,8 @@ class _ChatScreenState extends State<ChatScreen>
|
||||
: _page.open || !showsListBesideDetail(context),
|
||||
paneControls: pane == null
|
||||
? const []
|
||||
: _workspace.floatingPane?.id == pane.id
|
||||
? _floatControls(pane)
|
||||
: [
|
||||
ChatBarAction(
|
||||
label: 'Add chat pane',
|
||||
@@ -526,6 +532,7 @@ class _ChatScreenState extends State<ChatScreen>
|
||||
materialIcon: Icons.close,
|
||||
cupertinoIcon: CupertinoIcons.xmark,
|
||||
),
|
||||
..._floatControls(pane),
|
||||
],
|
||||
);
|
||||
return ChatComposerFocusScope(
|
||||
|
||||
@@ -0,0 +1,120 @@
|
||||
import 'dart:async';
|
||||
import 'dart:ui';
|
||||
|
||||
import 'package:flutter/foundation.dart';
|
||||
|
||||
import 'chat_float_store.dart';
|
||||
import 'chat_workspace_controller.dart';
|
||||
|
||||
/// The floating chat window's frame. A drag moves it every pointer event
|
||||
/// without saving; [commit] marks the end of the drag.
|
||||
class ChatFloatFrame extends ChangeNotifier {
|
||||
ChatFloatFrame([this._rect = chatFloatDefaultRect]);
|
||||
Rect _rect;
|
||||
Rect get rect => _rect;
|
||||
int _commits = 0;
|
||||
|
||||
/// Advances when a move or resize ends (the binding saves then).
|
||||
int get commits => _commits;
|
||||
|
||||
void move(Rect rect) {
|
||||
if (rect == _rect) return;
|
||||
_rect = rect;
|
||||
notifyListeners();
|
||||
}
|
||||
|
||||
void commit() {
|
||||
_commits++;
|
||||
notifyListeners();
|
||||
}
|
||||
}
|
||||
|
||||
/// Saves which chat floats, whether it shows and the window's frame, and
|
||||
/// restores them once the workspace layout itself has been restored.
|
||||
class ChatFloatBinding {
|
||||
ChatFloatBinding({
|
||||
required this.controller,
|
||||
required this.frame,
|
||||
required this.store,
|
||||
this.debounce = const Duration(milliseconds: 250),
|
||||
}) {
|
||||
controller.addListener(_changed);
|
||||
frame.addListener(_frameChanged);
|
||||
}
|
||||
|
||||
final ChatWorkspaceController controller;
|
||||
final ChatFloatFrame frame;
|
||||
final ChatFloatStore store;
|
||||
final Duration debounce;
|
||||
ChatFloatRecord? _saved;
|
||||
bool _loading = true;
|
||||
bool _disposed = false;
|
||||
int _commits = 0;
|
||||
Timer? _timer;
|
||||
Future<void> _writes = Future.value();
|
||||
|
||||
ChatFloatRecord get _current => ChatFloatRecord(
|
||||
pane: controller.floatingPane,
|
||||
shown: controller.floatShown,
|
||||
rect: frame.rect,
|
||||
);
|
||||
|
||||
/// Call after the workspace layout restored, so a saved float can tell
|
||||
/// whether its chat is already open in the tiling.
|
||||
Future<void> start() async {
|
||||
ChatFloatRecord? record;
|
||||
try {
|
||||
record = await store.read();
|
||||
} on Object {
|
||||
// Unavailable preferences leave the default frame and no float.
|
||||
}
|
||||
if (_disposed) return;
|
||||
if (record != null) {
|
||||
_saved = record;
|
||||
_commits = frame.commits;
|
||||
frame.move(record.rect);
|
||||
final pane = record.pane;
|
||||
if (pane != null && controller.floatingPane == null) {
|
||||
controller.restoreFloat(pane, shown: record.shown);
|
||||
}
|
||||
}
|
||||
_loading = false;
|
||||
_changed();
|
||||
}
|
||||
|
||||
void _frameChanged() {
|
||||
if (frame.commits == _commits) return;
|
||||
_commits = frame.commits;
|
||||
_changed();
|
||||
}
|
||||
|
||||
void _changed() {
|
||||
if (_disposed || _loading || _current == _saved) return;
|
||||
_timer?.cancel();
|
||||
_timer = Timer(debounce, flush);
|
||||
}
|
||||
|
||||
Future<void> flush() {
|
||||
_timer?.cancel();
|
||||
_timer = null;
|
||||
final record = _current;
|
||||
if (_loading || record == _saved) return _writes;
|
||||
_saved = record;
|
||||
_writes = _writes.then((_) async {
|
||||
try {
|
||||
await store.write(record);
|
||||
} on Object {
|
||||
// A storage failure must not interrupt the chat.
|
||||
}
|
||||
});
|
||||
return _writes;
|
||||
}
|
||||
|
||||
void dispose() {
|
||||
if (_disposed) return;
|
||||
controller.removeListener(_changed);
|
||||
frame.removeListener(_frameChanged);
|
||||
unawaited(flush());
|
||||
_disposed = true;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,236 @@
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:flutter/services.dart';
|
||||
|
||||
import '../../../ui/floating/floating_layer.dart';
|
||||
import '../../../ui/motion/motion.dart';
|
||||
import '../ui/sessions/chat_adaptive.dart';
|
||||
import 'chat_float_binding.dart';
|
||||
import 'chat_float_shortcut.dart';
|
||||
import 'chat_float_window.dart';
|
||||
import 'chat_workspace_controller.dart';
|
||||
|
||||
/// The split workspace ([child]) with its floating chat over the app: the
|
||||
/// window, its show and hide motion, its focus and its shortcut (see
|
||||
/// [chatFloatShortcut]). [content] is the floating pane's live view, moved
|
||||
/// here from the tiling rather than rebuilt.
|
||||
///
|
||||
/// The window shows only while [enabled] (a wide layout) and the Chat
|
||||
/// destination is current; otherwise the floating chat is kept, unpainted.
|
||||
class ChatFloatHost extends StatefulWidget {
|
||||
const ChatFloatHost({
|
||||
super.key,
|
||||
required this.controller,
|
||||
required this.frame,
|
||||
required this.enabled,
|
||||
required this.title,
|
||||
required this.content,
|
||||
required this.scope,
|
||||
required this.focusedPane,
|
||||
required this.onFocusPane,
|
||||
required this.child,
|
||||
});
|
||||
|
||||
final ChatWorkspaceController controller;
|
||||
final ChatFloatFrame frame;
|
||||
final bool enabled;
|
||||
final String title;
|
||||
final Widget? content;
|
||||
|
||||
/// The floating pane's focus scope.
|
||||
final FocusScopeNode? scope;
|
||||
|
||||
/// The tiled pane with the keyboard, which the shortcut floats when no
|
||||
/// chat floats yet.
|
||||
final ChatWorkspacePane? Function() focusedPane;
|
||||
final ValueChanged<ChatWorkspacePane>? onFocusPane;
|
||||
final Widget child;
|
||||
|
||||
@override
|
||||
State<ChatFloatHost> createState() => _ChatFloatHostState();
|
||||
}
|
||||
|
||||
class _ChatFloatHostState extends State<ChatFloatHost>
|
||||
with SingleTickerProviderStateMixin {
|
||||
late final AnimationController _reveal = AnimationController(
|
||||
vsync: this,
|
||||
duration: Motion.standard,
|
||||
);
|
||||
late final CurvedAnimation _curve = CurvedAnimation(
|
||||
parent: _reveal,
|
||||
curve: Motion.curve,
|
||||
reverseCurve: Curves.easeInCubic,
|
||||
);
|
||||
bool _current = true;
|
||||
bool _visible = false;
|
||||
String? _paneId;
|
||||
FocusNode? _previous;
|
||||
|
||||
@override
|
||||
void initState() {
|
||||
super.initState();
|
||||
FocusManager.instance.addEarlyKeyEventHandler(_key);
|
||||
widget.controller.addListener(_sync);
|
||||
}
|
||||
|
||||
@override
|
||||
void didChangeDependencies() {
|
||||
super.didChangeDependencies();
|
||||
// Another destination mutes this one's tickers and takes its focus.
|
||||
_current = TickerMode.valuesOf(context).enabled;
|
||||
WidgetsBinding.instance.addPostFrameCallback((_) => _sync());
|
||||
}
|
||||
|
||||
@override
|
||||
void didUpdateWidget(covariant ChatFloatHost oldWidget) {
|
||||
super.didUpdateWidget(oldWidget);
|
||||
if (oldWidget.controller != widget.controller) {
|
||||
oldWidget.controller.removeListener(_sync);
|
||||
widget.controller.addListener(_sync);
|
||||
}
|
||||
if (oldWidget.enabled != widget.enabled) {
|
||||
WidgetsBinding.instance.addPostFrameCallback((_) => _sync());
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
void dispose() {
|
||||
FocusManager.instance.removeEarlyKeyEventHandler(_key);
|
||||
widget.controller.removeListener(_sync);
|
||||
_curve.dispose();
|
||||
_reveal.dispose();
|
||||
super.dispose();
|
||||
}
|
||||
|
||||
bool get _presentable => widget.enabled && _current;
|
||||
|
||||
void _sync() {
|
||||
if (!mounted) return;
|
||||
final pane = widget.controller.floatingPane;
|
||||
final visible = _presentable && widget.controller.floatShown;
|
||||
_reveal.duration = Motion.of(context, Motion.standard);
|
||||
if (pane == null) {
|
||||
// Docked or closed: the view went back to the tiling, so no motion.
|
||||
_previous = null;
|
||||
_reveal.value = 0;
|
||||
} else if (visible != _visible) {
|
||||
if (visible) {
|
||||
_remember();
|
||||
unawaited(_reveal.forward());
|
||||
_focusSoon(pane);
|
||||
} else {
|
||||
_release();
|
||||
unawaited(_reveal.reverse());
|
||||
}
|
||||
} else if (visible && pane.id != _paneId) {
|
||||
// Another chat replaced the floating one.
|
||||
_focusSoon(pane);
|
||||
}
|
||||
_paneId = pane?.id;
|
||||
if (visible != _visible) setState(() => _visible = visible);
|
||||
}
|
||||
|
||||
bool _inside(FocusNode node) {
|
||||
final scope = widget.scope;
|
||||
return scope != null &&
|
||||
(identical(node, scope) || node.ancestors.contains(scope));
|
||||
}
|
||||
|
||||
void _remember() {
|
||||
final current = FocusManager.instance.primaryFocus;
|
||||
if (current == null || _inside(current)) return;
|
||||
_previous = identical(current, FocusManager.instance.rootScope)
|
||||
? null
|
||||
: current;
|
||||
}
|
||||
|
||||
void _focusSoon(ChatWorkspacePane pane) {
|
||||
WidgetsBinding.instance
|
||||
..addPostFrameCallback((_) {
|
||||
if (!mounted || widget.controller.floatingPane?.id != pane.id) return;
|
||||
final focus = widget.onFocusPane;
|
||||
if (focus != null) {
|
||||
focus(pane);
|
||||
} else {
|
||||
widget.scope?.requestFocus();
|
||||
}
|
||||
})
|
||||
..ensureVisualUpdate();
|
||||
}
|
||||
|
||||
/// Gives the keyboard back to what had it before the chat showed, if the
|
||||
/// floating chat has it now.
|
||||
void _release() {
|
||||
final previous = _previous;
|
||||
_previous = null;
|
||||
final scope = widget.scope;
|
||||
if (scope == null || !scope.hasFocus) return;
|
||||
if (previous != null &&
|
||||
previous.context != null &&
|
||||
previous.canRequestFocus) {
|
||||
previous.requestFocus();
|
||||
} else {
|
||||
scope.unfocus();
|
||||
}
|
||||
}
|
||||
|
||||
/// 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 (!mounted ||
|
||||
!_presentable ||
|
||||
!chatFloatShortcut(event, HardwareKeyboard.instance)) {
|
||||
return KeyEventResult.ignored;
|
||||
}
|
||||
final controller = widget.controller;
|
||||
if (controller.floatingPane == null) {
|
||||
final pane = widget.focusedPane();
|
||||
if (pane == null || !controller.canFloat(pane.id)) {
|
||||
return KeyEventResult.ignored;
|
||||
}
|
||||
if (event is KeyDownEvent) controller.float(pane.id);
|
||||
return KeyEventResult.handled;
|
||||
}
|
||||
if (event is KeyDownEvent) controller.toggleFloatShown();
|
||||
return KeyEventResult.handled;
|
||||
}
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
final content = widget.content;
|
||||
return Stack(
|
||||
fit: StackFit.expand,
|
||||
children: [
|
||||
widget.child,
|
||||
if (content != null)
|
||||
Positioned.fill(
|
||||
child: FloatingLayer(
|
||||
open: _visible,
|
||||
coverOverlay: true,
|
||||
builder: (context, bounds) => [
|
||||
ListenableBuilder(
|
||||
listenable: Listenable.merge([widget.frame, _reveal]),
|
||||
builder: (context, _) => ChatFloatWindow(
|
||||
frame: widget.frame,
|
||||
bounds: bounds,
|
||||
title: widget.title,
|
||||
cupertino:
|
||||
chatControlsStyleOf(context) ==
|
||||
ChatControlsStyle.cupertino,
|
||||
reveal: _curve,
|
||||
hiding: !_visible,
|
||||
offstage: !_visible && _reveal.isDismissed,
|
||||
shortcut: chatFloatShortcutLabel(),
|
||||
onDock: widget.controller.dock,
|
||||
onHide: () => widget.controller.setFloatShown(false),
|
||||
child: content,
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
],
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
import 'package:flutter/foundation.dart';
|
||||
import 'package:flutter/services.dart';
|
||||
|
||||
import '../../../ui/input/keyboard_owner.dart';
|
||||
|
||||
/// Whether [event] shows or hides the floating chat: Ctrl+Y, and Cmd+Y on
|
||||
/// Apple platforms. It is a global key handler like the terminal's toggle,
|
||||
/// so it works while a composer or the terminal has the keyboard; a plain Y
|
||||
/// (or Shift+Y, Alt+Y) always types. On Apple platforms Ctrl+Y inside a
|
||||
/// terminal is left to the shell (yank), since Cmd+Y is there; elsewhere
|
||||
/// Ctrl+Y is the chord, so it takes priority over the shell's yank.
|
||||
///
|
||||
/// A held chord's repeats match too (and are swallowed); only its first
|
||||
/// press toggles.
|
||||
bool chatFloatShortcut(
|
||||
KeyEvent event,
|
||||
HardwareKeyboard keyboard, {
|
||||
TargetPlatform? platform,
|
||||
}) {
|
||||
if (event is KeyUpEvent ||
|
||||
event.logicalKey != LogicalKeyboardKey.keyY ||
|
||||
keyboard.isShiftPressed ||
|
||||
keyboard.isAltPressed) {
|
||||
return false;
|
||||
}
|
||||
final control = keyboard.isControlPressed;
|
||||
final meta = keyboard.isMetaPressed;
|
||||
if (control == meta) return false;
|
||||
if (!_apple(platform ?? defaultTargetPlatform)) return control;
|
||||
return meta || !primaryFocusIsTypingSurface();
|
||||
}
|
||||
|
||||
bool _apple(TargetPlatform platform) =>
|
||||
platform == TargetPlatform.macOS || platform == TargetPlatform.iOS;
|
||||
|
||||
/// The floating chat's shortcut as it reads on this platform, for menus and
|
||||
/// tooltips.
|
||||
String chatFloatShortcutLabel([TargetPlatform? platform]) =>
|
||||
_apple(platform ?? defaultTargetPlatform) ? 'Cmd+Y' : 'Ctrl+Y';
|
||||
@@ -0,0 +1,121 @@
|
||||
import 'dart:convert';
|
||||
import 'dart:ui';
|
||||
|
||||
import 'package:shared_preferences/shared_preferences.dart';
|
||||
|
||||
import '../../../core/servers/server_scope.dart';
|
||||
import 'chat_workspace_nodes.dart';
|
||||
|
||||
const chatFloatPreferenceKey = 'pipelines.next.chatFloat.v1';
|
||||
|
||||
/// The floating window's default frame and smallest size; frames clamp to
|
||||
/// what the window allows.
|
||||
const Rect chatFloatDefaultRect = Rect.fromLTWH(120, 96, 480, 560);
|
||||
const Size chatFloatMinSize = Size(320, 240);
|
||||
|
||||
/// The floating chat as saved on this device: which pane floats (if any),
|
||||
/// whether it is shown, and the window's frame. Identities and geometry only,
|
||||
/// like the workspace snapshot.
|
||||
class ChatFloatRecord {
|
||||
const ChatFloatRecord({this.pane, this.shown = false, required this.rect});
|
||||
|
||||
final ChatWorkspacePane? pane;
|
||||
final bool shown;
|
||||
final Rect rect;
|
||||
|
||||
String encode() => jsonEncode({
|
||||
'version': 1,
|
||||
'pane': pane == null
|
||||
? null
|
||||
: {'id': pane!.id, 'session_id': pane!.sessionId},
|
||||
'shown': shown,
|
||||
'rect': [rect.left, rect.top, rect.width, rect.height],
|
||||
});
|
||||
|
||||
static ChatFloatRecord? decode(String source) {
|
||||
if (source.length > 4096) return null;
|
||||
try {
|
||||
final data = jsonDecode(source);
|
||||
if (data is! Map || data['version'] != 1) return null;
|
||||
final values = data['rect'];
|
||||
if (values is! List ||
|
||||
values.length != 4 ||
|
||||
values.any((v) => v is! num || !v.isFinite)) {
|
||||
return null;
|
||||
}
|
||||
final [left, top, width, height] = [
|
||||
for (final v in values) (v as num).toDouble(),
|
||||
];
|
||||
if (width <= 0 || height <= 0) return null;
|
||||
final pane = data['pane'];
|
||||
ChatWorkspacePane? floating;
|
||||
if (pane is Map) {
|
||||
final id = pane['id'], session = pane['session_id'];
|
||||
if (!_identity(id, 256) || !_identity(session, 512)) return null;
|
||||
floating = ChatWorkspacePane(id as String, session as String);
|
||||
} else if (pane != null) {
|
||||
return null;
|
||||
}
|
||||
return ChatFloatRecord(
|
||||
pane: floating,
|
||||
shown: data['shown'] == true,
|
||||
rect: Rect.fromLTWH(left, top, width, height),
|
||||
);
|
||||
} on Object {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
bool operator ==(Object other) =>
|
||||
other is ChatFloatRecord &&
|
||||
other.pane?.id == pane?.id &&
|
||||
other.pane?.sessionId == pane?.sessionId &&
|
||||
other.shown == shown &&
|
||||
other.rect == rect;
|
||||
|
||||
@override
|
||||
int get hashCode => Object.hash(pane?.id, pane?.sessionId, shown, rect);
|
||||
}
|
||||
|
||||
bool _identity(Object? value, int limit) =>
|
||||
value is String &&
|
||||
value.isNotEmpty &&
|
||||
value.length <= limit &&
|
||||
value.trim() == value &&
|
||||
!value.contains(RegExp(r'[\x00-\x20\x7f]'));
|
||||
|
||||
abstract interface class ChatFloatStore {
|
||||
Future<ChatFloatRecord?> read();
|
||||
Future<bool> write(ChatFloatRecord record);
|
||||
}
|
||||
|
||||
/// Device-local, scoped like the workspace layout it belongs to.
|
||||
class SharedPreferencesChatFloatStore implements ChatFloatStore {
|
||||
const SharedPreferencesChatFloatStore({required this.serverScope});
|
||||
final String serverScope;
|
||||
|
||||
String get key => scopedServerKey(chatFloatPreferenceKey, serverScope);
|
||||
|
||||
@override
|
||||
Future<ChatFloatRecord?> read() async {
|
||||
try {
|
||||
final source = (await SharedPreferences.getInstance()).getString(key);
|
||||
return source == null ? null : ChatFloatRecord.decode(source);
|
||||
} on Object {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
Future<bool> write(ChatFloatRecord record) async {
|
||||
try {
|
||||
return await (await SharedPreferences.getInstance()).setString(
|
||||
key,
|
||||
record.encode(),
|
||||
);
|
||||
} on Object {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,217 @@
|
||||
import 'package:flutter/cupertino.dart';
|
||||
import 'package:flutter/gestures.dart';
|
||||
import 'package:flutter/material.dart';
|
||||
|
||||
import '../../terminal/terminal_float_frame.dart' show terminalFloatChrome;
|
||||
import 'chat_float_binding.dart';
|
||||
import 'chat_float_store.dart';
|
||||
|
||||
/// [rect] moved and shrunk to fit inside [bounds], at least the smallest
|
||||
/// window where the bounds allow it.
|
||||
Rect fitChatFloat(Rect rect, Size bounds) {
|
||||
final width = rect.width
|
||||
.clamp(chatFloatMinSize.width, double.infinity)
|
||||
.clamp(0.0, bounds.width);
|
||||
final height = rect.height
|
||||
.clamp(chatFloatMinSize.height, double.infinity)
|
||||
.clamp(0.0, bounds.height);
|
||||
return Rect.fromLTWH(
|
||||
rect.left.clamp(0.0, bounds.width - width),
|
||||
rect.top.clamp(0.0, bounds.height - height),
|
||||
width,
|
||||
height,
|
||||
);
|
||||
}
|
||||
|
||||
/// The floating chat's window: moved by its title bar, resized from its
|
||||
/// lower right corner, kept inside [bounds]. It grows and fades in from its
|
||||
/// place as [reveal] runs forward and leaves the same way in reverse.
|
||||
class ChatFloatWindow extends StatelessWidget {
|
||||
const ChatFloatWindow({
|
||||
super.key,
|
||||
required this.frame,
|
||||
required this.bounds,
|
||||
required this.title,
|
||||
required this.cupertino,
|
||||
required this.reveal,
|
||||
required this.hiding,
|
||||
this.offstage = false,
|
||||
required this.shortcut,
|
||||
required this.onDock,
|
||||
required this.onHide,
|
||||
required this.child,
|
||||
});
|
||||
|
||||
final ChatFloatFrame frame;
|
||||
final Size bounds;
|
||||
final String title;
|
||||
final bool cupertino;
|
||||
final Animation<double> reveal;
|
||||
|
||||
/// While the window hides it takes no input.
|
||||
final bool hiding;
|
||||
|
||||
/// Hidden and settled: kept built (the chat keeps its state) but unpainted.
|
||||
final bool offstage;
|
||||
final String shortcut;
|
||||
final VoidCallback onDock;
|
||||
final VoidCallback onHide;
|
||||
final Widget child;
|
||||
|
||||
static const double revealScale = 0.92;
|
||||
|
||||
void _resize(Offset delta) {
|
||||
final rect = fitChatFloat(frame.rect, bounds);
|
||||
frame.move(
|
||||
fitChatFloat(
|
||||
Rect.fromLTWH(
|
||||
rect.left,
|
||||
rect.top,
|
||||
rect.width + delta.dx,
|
||||
rect.height + delta.dy,
|
||||
),
|
||||
bounds,
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
final rect = fitChatFloat(frame.rect, bounds);
|
||||
final window = SizedBox.fromSize(
|
||||
size: rect.size,
|
||||
child: Stack(
|
||||
children: [
|
||||
Column(
|
||||
crossAxisAlignment: CrossAxisAlignment.stretch,
|
||||
children: [
|
||||
_titleBar(context, rect),
|
||||
Expanded(
|
||||
child: MediaQuery.removePadding(
|
||||
context: context,
|
||||
removeTop: true,
|
||||
removeBottom: true,
|
||||
removeLeft: true,
|
||||
removeRight: true,
|
||||
child: child,
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
PositionedDirectional(end: 0, bottom: 0, child: _corner()),
|
||||
],
|
||||
),
|
||||
);
|
||||
return Positioned(
|
||||
left: rect.left,
|
||||
top: rect.top,
|
||||
child: Offstage(
|
||||
offstage: offstage,
|
||||
child: IgnorePointer(
|
||||
ignoring: hiding,
|
||||
child: ExcludeFocus(
|
||||
excluding: hiding,
|
||||
child: FadeTransition(
|
||||
opacity: reveal,
|
||||
child: ScaleTransition(
|
||||
scale: Tween<double>(
|
||||
begin: revealScale,
|
||||
end: 1,
|
||||
).animate(reveal),
|
||||
child: Semantics(
|
||||
container: true,
|
||||
label: 'Floating chat',
|
||||
identifier: 'chat-float-window',
|
||||
child: terminalFloatChrome(context, cupertino, window),
|
||||
),
|
||||
),
|
||||
),
|
||||
),
|
||||
),
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
Widget _titleBar(BuildContext context, Rect rect) {
|
||||
final label = Text(
|
||||
title,
|
||||
maxLines: 1,
|
||||
overflow: TextOverflow.ellipsis,
|
||||
style: cupertino
|
||||
? CupertinoTheme.of(context).textTheme.navTitleTextStyle
|
||||
: Theme.of(context).textTheme.titleSmall,
|
||||
);
|
||||
final drag = MouseRegion(
|
||||
cursor: SystemMouseCursors.move,
|
||||
child: GestureDetector(
|
||||
key: const ValueKey('chat-float-title'),
|
||||
behavior: HitTestBehavior.opaque,
|
||||
dragStartBehavior: DragStartBehavior.down,
|
||||
onPanUpdate: (details) => frame.move(
|
||||
fitChatFloat(
|
||||
fitChatFloat(frame.rect, bounds).shift(details.delta),
|
||||
bounds,
|
||||
),
|
||||
),
|
||||
onPanEnd: (_) => frame.commit(),
|
||||
child: Padding(
|
||||
padding: const EdgeInsetsDirectional.only(start: 12),
|
||||
child: Align(
|
||||
alignment: AlignmentDirectional.centerStart,
|
||||
child: label,
|
||||
),
|
||||
),
|
||||
),
|
||||
);
|
||||
return Row(
|
||||
children: [
|
||||
Expanded(child: drag),
|
||||
_button(
|
||||
'Dock',
|
||||
Icons.vertical_split_outlined,
|
||||
CupertinoIcons.rectangle_split_3x1,
|
||||
onDock,
|
||||
),
|
||||
_button(
|
||||
'Hide floating chat ($shortcut)',
|
||||
Icons.close,
|
||||
CupertinoIcons.xmark,
|
||||
onHide,
|
||||
),
|
||||
],
|
||||
);
|
||||
}
|
||||
|
||||
Widget _button(
|
||||
String label,
|
||||
IconData material,
|
||||
IconData cupertinoIcon,
|
||||
VoidCallback onPressed,
|
||||
) => cupertino
|
||||
? CupertinoButton(
|
||||
padding: const EdgeInsets.symmetric(horizontal: 8),
|
||||
onPressed: onPressed,
|
||||
child: Icon(cupertinoIcon, semanticLabel: label),
|
||||
)
|
||||
: IconButton(tooltip: label, onPressed: onPressed, icon: Icon(material));
|
||||
|
||||
Widget _corner() => Semantics(
|
||||
label: 'Resize floating chat',
|
||||
child: MouseRegion(
|
||||
cursor: SystemMouseCursors.resizeDownRight,
|
||||
child: GestureDetector(
|
||||
key: const ValueKey('chat-float-resize'),
|
||||
behavior: HitTestBehavior.opaque,
|
||||
dragStartBehavior: DragStartBehavior.down,
|
||||
onPanUpdate: (details) => _resize(details.delta),
|
||||
onPanEnd: (_) => frame.commit(),
|
||||
child: Padding(
|
||||
padding: const EdgeInsets.all(4),
|
||||
child: Icon(
|
||||
cupertino ? CupertinoIcons.arrow_down_right : Icons.south_east,
|
||||
),
|
||||
),
|
||||
),
|
||||
),
|
||||
);
|
||||
}
|
||||
@@ -4,6 +4,8 @@ import 'package:flutter/material.dart';
|
||||
import 'package:flutter/services.dart';
|
||||
|
||||
import '../../../ui/motion/quick_switch_animation.dart';
|
||||
import 'chat_float_binding.dart';
|
||||
import 'chat_float_host.dart';
|
||||
import 'chat_workspace_controller.dart';
|
||||
import 'chat_workspace_geometry.dart';
|
||||
import 'chat_mobile_panes.dart';
|
||||
@@ -59,6 +61,7 @@ class ChatWorkspace extends StatefulWidget {
|
||||
this.animationStyle,
|
||||
this.paneTitle,
|
||||
this.onVisibleSessionIdsChanged,
|
||||
this.floatFrame,
|
||||
});
|
||||
final ChatWorkspaceController controller;
|
||||
final ChatWorkspacePaneBuilder paneBuilder;
|
||||
@@ -71,6 +74,10 @@ class ChatWorkspace extends StatefulWidget {
|
||||
final String Function(ChatWorkspacePane)? paneTitle;
|
||||
final ValueChanged<Set<String>>? onVisibleSessionIdsChanged;
|
||||
|
||||
/// Offers the floating chat (see [ChatFloatHost]) in this frame; null for a
|
||||
/// workspace without one. It shows only while the panes are not collapsed.
|
||||
final ChatFloatFrame? floatFrame;
|
||||
|
||||
/// Keyboard navigation only: the owner can focus the target composer.
|
||||
/// Pointer activation leaves text-selection and pointer focus alone.
|
||||
final ValueChanged<ChatWorkspacePane>? onFocusPane;
|
||||
@@ -83,6 +90,10 @@ class _ChatWorkspaceState extends State<ChatWorkspace>
|
||||
with SingleTickerProviderStateMixin {
|
||||
final _focus = FocusNode(debugLabel: 'Chat workspace');
|
||||
final Map<String, FocusScopeNode> _panes = {};
|
||||
|
||||
/// Each pane's view keeps its State when it moves into or out of the
|
||||
/// floating window.
|
||||
final Map<String, GlobalKey> _views = {};
|
||||
late final ChatPaneSwitchMotion _motion;
|
||||
ChatWorkspaceGeometry? _geometry;
|
||||
String? _lastActiveId;
|
||||
@@ -246,7 +257,11 @@ class _ChatWorkspaceState extends State<ChatWorkspace>
|
||||
: !collapsed || pane.id == activeId)
|
||||
pane.sessionId,
|
||||
});
|
||||
final existing = panes.map((p) => p.id).toSet();
|
||||
final floating = widget.floatFrame == null
|
||||
? null
|
||||
: widget.controller.floatingPane;
|
||||
final existing = {...panes.map((p) => p.id), ?floating?.id};
|
||||
_views.removeWhere((id, _) => !existing.contains(id));
|
||||
for (final id
|
||||
in _panes.keys.where((id) => !existing.contains(id)).toList()) {
|
||||
final node = _panes.remove(id)!;
|
||||
@@ -285,7 +300,7 @@ class _ChatWorkspaceState extends State<ChatWorkspace>
|
||||
edge,
|
||||
},
|
||||
};
|
||||
return chatWorkspaceSurface(
|
||||
final surface = chatWorkspaceSurface(
|
||||
context: context,
|
||||
backdrop: _backdrop,
|
||||
motion: _motion,
|
||||
@@ -298,6 +313,23 @@ class _ChatWorkspaceState extends State<ChatWorkspace>
|
||||
paneView: (pane) =>
|
||||
_paneView(pane, mobile, collapsed, activeId, sharedEdges),
|
||||
);
|
||||
final frame = widget.floatFrame;
|
||||
if (frame == null) return surface;
|
||||
return ChatFloatHost(
|
||||
controller: widget.controller,
|
||||
frame: frame,
|
||||
enabled: !widget.singlePane,
|
||||
title: floating == null
|
||||
? ''
|
||||
: widget.paneTitle?.call(floating) ?? floating.sessionId,
|
||||
content: floating == null ? null : _floatView(floating),
|
||||
scope: floating == null ? null : _panes[floating.id],
|
||||
focusedPane: () => widget.controller.panes
|
||||
.where((pane) => _panes[pane.id]?.hasFocus ?? false)
|
||||
.firstOrNull,
|
||||
onFocusPane: widget.onFocusPane,
|
||||
child: surface,
|
||||
);
|
||||
},
|
||||
),
|
||||
),
|
||||
@@ -330,44 +362,59 @@ class _ChatWorkspaceState extends State<ChatWorkspace>
|
||||
FocusManager.instance.primaryFocus?.unfocus();
|
||||
widget.controller.activate(pane.id);
|
||||
},
|
||||
child: FocusScope(
|
||||
node: _panes.putIfAbsent(
|
||||
pane.id,
|
||||
() => FocusScopeNode(debugLabel: pane.id),
|
||||
),
|
||||
onFocusChange: (focused) {
|
||||
if (focused && mobile == null) {
|
||||
widget.controller.activate(pane.id);
|
||||
}
|
||||
},
|
||||
child: Listener(
|
||||
behavior: HitTestBehavior.translucent,
|
||||
// A press in the peek scrolls or taps; the tap alone activates.
|
||||
onPointerDown: peek
|
||||
? null
|
||||
: (_) => widget.controller.activate(pane.id),
|
||||
child: Semantics(
|
||||
identifier: 'chat-pane-${pane.id}',
|
||||
container: true,
|
||||
sortKey: mobile == null ? null : const OrdinalSortKey(0),
|
||||
child: ChatWorkspacePaneScope(
|
||||
topEdgeShared: sharedEdges[pane.id]?.contains('top') ?? false,
|
||||
bottomEdgeShared:
|
||||
sharedEdges[pane.id]?.contains('bottom') ?? false,
|
||||
leftEdgeShared:
|
||||
sharedEdges[pane.id]?.contains('left') ?? false,
|
||||
rightEdgeShared:
|
||||
sharedEdges[pane.id]?.contains('right') ?? false,
|
||||
child: Builder(
|
||||
builder: (paneContext) =>
|
||||
widget.paneBuilder(paneContext, pane, active),
|
||||
),
|
||||
),
|
||||
),
|
||||
),
|
||||
child: _paneContent(
|
||||
pane,
|
||||
active: active,
|
||||
peek: peek,
|
||||
mobile: mobile != null,
|
||||
edges: sharedEdges[pane.id] ?? const {},
|
||||
),
|
||||
),
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
/// The floating chat's view: the same keyed content as in the tiling, so
|
||||
/// floating and docking move it without rebuilding the chat.
|
||||
Widget _floatView(ChatWorkspacePane pane) =>
|
||||
_paneContent(pane, active: true, peek: false, mobile: false, edges: {});
|
||||
|
||||
Widget _paneContent(
|
||||
ChatWorkspacePane pane, {
|
||||
required bool active,
|
||||
required bool peek,
|
||||
required bool mobile,
|
||||
required Set<String> edges,
|
||||
}) => KeyedSubtree(
|
||||
key: _views.putIfAbsent(pane.id, () => GlobalKey(debugLabel: pane.id)),
|
||||
child: FocusScope(
|
||||
node: _panes.putIfAbsent(
|
||||
pane.id,
|
||||
() => FocusScopeNode(debugLabel: pane.id),
|
||||
),
|
||||
onFocusChange: (focused) {
|
||||
if (focused && !mobile) widget.controller.activate(pane.id);
|
||||
},
|
||||
child: Listener(
|
||||
behavior: HitTestBehavior.translucent,
|
||||
// A press in the peek scrolls or taps; the tap alone activates.
|
||||
onPointerDown: peek ? null : (_) => widget.controller.activate(pane.id),
|
||||
child: Semantics(
|
||||
identifier: 'chat-pane-${pane.id}',
|
||||
container: true,
|
||||
sortKey: mobile ? const OrdinalSortKey(0) : null,
|
||||
child: ChatWorkspacePaneScope(
|
||||
topEdgeShared: edges.contains('top'),
|
||||
bottomEdgeShared: edges.contains('bottom'),
|
||||
leftEdgeShared: edges.contains('left'),
|
||||
rightEdgeShared: edges.contains('right'),
|
||||
child: Builder(
|
||||
builder: (paneContext) =>
|
||||
widget.paneBuilder(paneContext, pane, active),
|
||||
),
|
||||
),
|
||||
),
|
||||
),
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
@@ -5,10 +5,16 @@ import 'chat_workspace_snapshot.dart';
|
||||
|
||||
export 'chat_workspace_nodes.dart';
|
||||
|
||||
part 'chat_workspace_float.dart';
|
||||
|
||||
/// Pane identities survive nested splits, resizing and validated restoration.
|
||||
class ChatWorkspaceController extends ChangeNotifier {
|
||||
ChatWorkspaceNode? _root;
|
||||
String? _active;
|
||||
|
||||
/// The chat taken out of the tiling into the floating window, if any.
|
||||
ChatWorkspacePane? _floating;
|
||||
bool _floatShown = false;
|
||||
double _mobilePeekFraction = .2;
|
||||
double get mobilePeekFraction => _mobilePeekFraction;
|
||||
void resizeMobilePeek(double fraction) {
|
||||
@@ -49,6 +55,7 @@ class ChatWorkspaceController extends ChangeNotifier {
|
||||
}
|
||||
|
||||
collect(_root);
|
||||
collect(_floating);
|
||||
String id;
|
||||
do {
|
||||
id = 'chat-$kind-${++_serial}';
|
||||
@@ -62,6 +69,7 @@ class ChatWorkspaceController extends ChangeNotifier {
|
||||
_root = snapshot.root;
|
||||
_active = snapshot.activePaneId;
|
||||
_mobilePeekFraction = snapshot.mobilePeekFraction;
|
||||
_floating = null;
|
||||
_serial = 0;
|
||||
_changed();
|
||||
return true;
|
||||
@@ -82,7 +90,7 @@ class ChatWorkspaceController extends ChangeNotifier {
|
||||
|
||||
/// Ordinary opening replaces the active pane; an already-open chat is focused.
|
||||
void open(String sessionId) {
|
||||
if (sessionId.isEmpty) return;
|
||||
if (sessionId.isEmpty || _showFloating(sessionId)) return;
|
||||
final existing = panes.where((p) => p.sessionId == sessionId).firstOrNull;
|
||||
if (existing != null) {
|
||||
activate(existing.id);
|
||||
@@ -105,7 +113,7 @@ class ChatWorkspaceController extends ChangeNotifier {
|
||||
}
|
||||
|
||||
void splitActive(String sessionId, ChatSplitAxis axis) {
|
||||
if (sessionId.isEmpty) return;
|
||||
if (sessionId.isEmpty || _showFloating(sessionId)) return;
|
||||
if (_root == null) {
|
||||
open(sessionId);
|
||||
return;
|
||||
@@ -161,10 +169,12 @@ class ChatWorkspaceController extends ChangeNotifier {
|
||||
}
|
||||
|
||||
void close(String paneId) {
|
||||
if (_closeFloating(paneId)) return;
|
||||
final before = panes;
|
||||
final index = before.indexWhere((p) => p.id == paneId);
|
||||
if (index < 0) return;
|
||||
_root = _remove(_root!, paneId);
|
||||
_adoptFloatingIfEmpty();
|
||||
final after = panes;
|
||||
if (_active == paneId) {
|
||||
_active = after.isEmpty
|
||||
@@ -175,7 +185,9 @@ class ChatWorkspaceController extends ChangeNotifier {
|
||||
}
|
||||
|
||||
void replaceSession(String oldId, String newId) {
|
||||
if (oldId == newId || newId.isEmpty) return;
|
||||
if (oldId == newId || newId.isEmpty || _replaceFloating(oldId, newId)) {
|
||||
return;
|
||||
}
|
||||
final pane = panes.where((p) => p.sessionId == oldId).firstOrNull;
|
||||
if (pane == null) return;
|
||||
final existing = panes.where((p) => p.sessionId == newId).firstOrNull;
|
||||
|
||||
@@ -0,0 +1,137 @@
|
||||
part of 'chat_workspace_controller.dart';
|
||||
|
||||
/// One chat at a time can leave the split tiling for a floating window over
|
||||
/// the app. The floating pane keeps its id (and so its live view) while it
|
||||
/// floats, hides, docks or swaps places with another pane.
|
||||
extension ChatWorkspaceFloat on ChatWorkspaceController {
|
||||
/// The floating chat, shown or hidden.
|
||||
ChatWorkspacePane? get floatingPane => _floating;
|
||||
|
||||
/// Whether the floating chat is shown (rather than hidden by Ctrl+Y).
|
||||
bool get floatShown => _floating != null && _floatShown;
|
||||
|
||||
/// Whether [sessionId] is open in the tiling or the floating window.
|
||||
bool holdsSession(String sessionId) =>
|
||||
_floating?.sessionId == sessionId ||
|
||||
panes.any((pane) => pane.sessionId == sessionId);
|
||||
|
||||
/// A tiled pane can float when another chat stays in the tiling: a second
|
||||
/// tiled pane, or the chat floating now (which takes its place).
|
||||
bool canFloat(String paneId) =>
|
||||
panes.any((pane) => pane.id == paneId) &&
|
||||
(paneCount > 1 || _floating != null);
|
||||
|
||||
/// Floats the tiled pane [paneId]. A chat already floating returns to the
|
||||
/// tiling in the place [paneId] leaves.
|
||||
void float(String paneId) {
|
||||
if (!canFloat(paneId)) return;
|
||||
final pane = panes.firstWhere((pane) => pane.id == paneId);
|
||||
final previous = _floating;
|
||||
if (previous != null) {
|
||||
_root = _replace(_root!, paneId, previous);
|
||||
if (_active == paneId) _active = previous.id;
|
||||
} else {
|
||||
final index = panes.indexWhere((p) => p.id == paneId);
|
||||
_root = _remove(_root!, paneId);
|
||||
if (_active == paneId) {
|
||||
final after = panes;
|
||||
_active = after[index.clamp(0, after.length - 1)].id;
|
||||
}
|
||||
}
|
||||
_floating = pane;
|
||||
_floatShown = true;
|
||||
_changed();
|
||||
}
|
||||
|
||||
/// Puts the floating chat back into the tiling, to the right of the
|
||||
/// active pane, and makes it the active pane.
|
||||
void dock() {
|
||||
final pane = _floating;
|
||||
if (pane == null) return;
|
||||
final split = _id('split');
|
||||
_floating = null;
|
||||
if (_root == null) {
|
||||
_root = pane;
|
||||
} else {
|
||||
final target = activePane ?? panes.first;
|
||||
_root = _replace(
|
||||
_root!,
|
||||
target.id,
|
||||
ChatWorkspaceSplit(split, ChatSplitAxis.horizontal, target, pane),
|
||||
);
|
||||
}
|
||||
_active = pane.id;
|
||||
_changed();
|
||||
}
|
||||
|
||||
void setFloatShown(bool shown) {
|
||||
if (_floating == null || _floatShown == shown) return;
|
||||
_floatShown = shown;
|
||||
_changed();
|
||||
}
|
||||
|
||||
void toggleFloatShown() => setFloatShown(!_floatShown);
|
||||
|
||||
/// Restores a saved floating chat unless its session is already open or
|
||||
/// its pane id is taken. With no tiled pane it becomes the tiling instead.
|
||||
bool restoreFloat(ChatWorkspacePane pane, {required bool shown}) {
|
||||
if (_floating != null || holdsSession(pane.sessionId)) return false;
|
||||
bool taken(ChatWorkspaceNode? node) =>
|
||||
node != null &&
|
||||
(node.id == pane.id ||
|
||||
node is ChatWorkspaceSplit &&
|
||||
(taken(node.first) || taken(node.second)));
|
||||
if (taken(_root)) return false;
|
||||
if (_root == null) {
|
||||
_root = pane;
|
||||
_active = pane.id;
|
||||
} else {
|
||||
_floating = pane;
|
||||
_floatShown = shown;
|
||||
}
|
||||
_changed();
|
||||
return true;
|
||||
}
|
||||
|
||||
/// Opening the floating chat (from the list, a link) shows it.
|
||||
bool _showFloating(String sessionId) {
|
||||
if (_floating?.sessionId != sessionId) return false;
|
||||
setFloatShown(true);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool _closeFloating(String paneId) {
|
||||
if (_floating?.id != paneId) return false;
|
||||
_floating = null;
|
||||
_changed();
|
||||
return true;
|
||||
}
|
||||
|
||||
/// The tiling never empties while a chat floats: the floating chat docks.
|
||||
void _adoptFloatingIfEmpty() {
|
||||
if (_root != null || _floating == null) return;
|
||||
_root = _floating;
|
||||
_floating = null;
|
||||
}
|
||||
|
||||
/// `/new` in the floating chat keeps it floating under the new session.
|
||||
bool _replaceFloating(String oldId, String newId) {
|
||||
final pane = _floating;
|
||||
if (pane == null) return false;
|
||||
if (pane.sessionId == oldId) {
|
||||
if (panes.any((p) => p.sessionId == newId)) {
|
||||
_closeFloating(pane.id);
|
||||
} else {
|
||||
_floating = ChatWorkspacePane(pane.id, newId);
|
||||
_changed();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
if (pane.sessionId != newId) return false;
|
||||
// A tiled chat moved to the session that floats: the float stays.
|
||||
final tiled = panes.where((p) => p.sessionId == oldId).firstOrNull;
|
||||
if (tiled != null) close(tiled.id);
|
||||
setFloatShown(true);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,6 @@
|
||||
import 'package:flutter/widgets.dart';
|
||||
|
||||
import '../../ui/floating/floating_layer.dart';
|
||||
import 'terminal_float.dart';
|
||||
import 'terminal_hub.dart';
|
||||
import 'terminal_layout.dart';
|
||||
@@ -81,16 +82,25 @@ class TerminalStage extends StatelessWidget {
|
||||
),
|
||||
),
|
||||
),
|
||||
// The window shares the app's floating layer, so it and a
|
||||
// floating chat stack by which was used last.
|
||||
if (float)
|
||||
TerminalFloat(
|
||||
key: const ValueKey('terminal-float'),
|
||||
hub: hub,
|
||||
layout: layout,
|
||||
cupertino: cupertino,
|
||||
bounds: constraints.biggest,
|
||||
reveal: reveal,
|
||||
focus: focus,
|
||||
hiding: hiding,
|
||||
Positioned.fill(
|
||||
child: FloatingLayer(
|
||||
open: layout.visible,
|
||||
builder: (context, bounds) => [
|
||||
TerminalFloat(
|
||||
key: const ValueKey('terminal-float'),
|
||||
hub: hub,
|
||||
layout: layout,
|
||||
cupertino: cupertino,
|
||||
bounds: bounds,
|
||||
reveal: reveal,
|
||||
focus: focus,
|
||||
hiding: hiding,
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
],
|
||||
);
|
||||
|
||||
@@ -0,0 +1,99 @@
|
||||
import 'package:flutter/widgets.dart';
|
||||
|
||||
/// A layer of floating windows painted in the app's root overlay, above the
|
||||
/// page, while it keeps its place in the tree (its inherited widgets, focus
|
||||
/// and state stay where it is built). Every [FloatingLayer] shares that one
|
||||
/// overlay, so windows from different features (the terminal, a floating
|
||||
/// chat) stack by use: the layer last pressed, focused or opened is on top.
|
||||
///
|
||||
/// [builder] returns the windows as [Positioned] children of a [Stack] the
|
||||
/// size of [bounds]: this widget's own box, or the whole overlay when
|
||||
/// [coverOverlay] is set. Space between windows takes no input. Without an
|
||||
/// overlay (a bare widget test) the layer paints in place.
|
||||
class FloatingLayer extends StatefulWidget {
|
||||
const FloatingLayer({
|
||||
super.key,
|
||||
required this.builder,
|
||||
this.open = true,
|
||||
this.coverOverlay = false,
|
||||
});
|
||||
|
||||
final List<Widget> Function(BuildContext context, Size bounds) builder;
|
||||
|
||||
/// Turning true brings the layer to the top, as its window opens.
|
||||
final bool open;
|
||||
|
||||
final bool coverOverlay;
|
||||
|
||||
@override
|
||||
State<FloatingLayer> createState() => _FloatingLayerState();
|
||||
}
|
||||
|
||||
class _FloatingLayerState extends State<FloatingLayer> {
|
||||
final OverlayPortalController _portal = OverlayPortalController(
|
||||
debugLabel: 'floating layer',
|
||||
);
|
||||
|
||||
@override
|
||||
void initState() {
|
||||
super.initState();
|
||||
_portal.show();
|
||||
}
|
||||
|
||||
@override
|
||||
void didUpdateWidget(covariant FloatingLayer oldWidget) {
|
||||
super.didUpdateWidget(oldWidget);
|
||||
if (widget.open && !oldWidget.open) {
|
||||
WidgetsBinding.instance.addPostFrameCallback((_) => _raise());
|
||||
}
|
||||
}
|
||||
|
||||
void _raise() {
|
||||
if (mounted) _portal.show();
|
||||
}
|
||||
|
||||
Widget _layer(BuildContext context, Size bounds) => Listener(
|
||||
behavior: HitTestBehavior.deferToChild,
|
||||
onPointerDown: (_) => _raise(),
|
||||
child: Focus(
|
||||
canRequestFocus: false,
|
||||
skipTraversal: true,
|
||||
onFocusChange: (focused) {
|
||||
if (focused) _raise();
|
||||
},
|
||||
child: SizedBox.fromSize(
|
||||
size: bounds,
|
||||
child: Stack(
|
||||
clipBehavior: Clip.none,
|
||||
children: widget.builder(context, bounds),
|
||||
),
|
||||
),
|
||||
),
|
||||
);
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
if (Overlay.maybeOf(context, rootOverlay: true) == null) {
|
||||
return LayoutBuilder(
|
||||
builder: (context, constraints) => _layer(context, constraints.biggest),
|
||||
);
|
||||
}
|
||||
return OverlayPortal.overlayChildLayoutBuilder(
|
||||
controller: _portal,
|
||||
overlayLocation: OverlayChildLocation.rootOverlay,
|
||||
overlayChildBuilder: (context, info) => widget.coverOverlay
|
||||
? Positioned.fill(child: _layer(context, info.overlaySize))
|
||||
: Positioned(
|
||||
left: 0,
|
||||
top: 0,
|
||||
width: info.childSize.width,
|
||||
height: info.childSize.height,
|
||||
child: Transform(
|
||||
transform: info.childPaintTransform,
|
||||
child: _layer(context, info.childSize),
|
||||
),
|
||||
),
|
||||
child: const SizedBox.expand(),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
# Floating chat pane
|
||||
|
||||
On a wide layout one chat at a time can leave the split tiling and float in a
|
||||
window over the app, like the floating terminal. Ctrl+Y (Cmd+Y on macOS)
|
||||
shows or hides it.
|
||||
|
||||
## Behaviour
|
||||
|
||||
- **Float**: a tiled pane's More menu offers `Float (Ctrl+Y)` (`Cmd+Y` on Apple
|
||||
platforms) when another chat stays in the tiling. A single chat cannot float,
|
||||
because the tiling would be empty. Floating a second chat swaps them: the chat
|
||||
that was floating goes back into the tiling where the new one was.
|
||||
- **Window**: you drag it by its title bar and resize it from the lower right
|
||||
corner. The title bar has Dock and Hide buttons. The window keeps its frame
|
||||
inside the app when the browser window resizes (`fitChatFloat`). Grow and fade
|
||||
in, and shrink and fade out, use `Motion.standard` through `Motion.of`, so
|
||||
reduced motion and the animation speed apply.
|
||||
- **Floating chat's menu**: Dock (back into the tiling, right of the active pane,
|
||||
which it becomes), `Hide floating chat (Ctrl+Y)`, and Close pane (removes it
|
||||
from the workspace; no backend close). If the last tiled pane closes, the
|
||||
floating chat docks in its place.
|
||||
- **Shortcut**: Ctrl+Y on every platform, and Cmd+Y on macOS and iOS. It is an
|
||||
early key handler, so it works from a composer or the terminal; Y, Shift+Y and
|
||||
Alt+Y still type. When no chat floats, Ctrl+Y floats the tiled pane that has
|
||||
the keyboard. When no pane has the keyboard, or that pane cannot float, the
|
||||
chord is left alone. So in the terminal Ctrl+Y stays the shell's yank until a
|
||||
chat floats. After that, on Windows, Linux and web, Ctrl+Y toggles even from
|
||||
the terminal (yank is unavailable there, as with Ctrl+T). On macOS, Ctrl+Y in
|
||||
a `TypingSurface` (terminal) always goes to the shell, and Cmd+Y toggles.
|
||||
- **Focus**: showing the chat focuses its composer. Hiding it gives the keyboard
|
||||
back to whatever had it before (as `TerminalFocus` does), otherwise the
|
||||
keyboard is unfocused.
|
||||
- **Where it shows**: only on a wide layout and while Chat is the current
|
||||
destination. On narrow or phone layouts, and on other destinations, the menu
|
||||
item is absent and the chord passes through. A chat that is already floating
|
||||
stays floating there, unpainted, with its state, and reappears when the
|
||||
window is wide again.
|
||||
- **Persistence**: `pipelines.next.chatFloat.v1` is stored device-locally and
|
||||
scoped like the workspace layout. It records the floating pane's id and
|
||||
session, whether it is shown, and the frame. It is restored after the
|
||||
workspace layout. A saved float whose session is already tiled is dropped.
|
||||
|
||||
## Design
|
||||
|
||||
- `ChatWorkspaceController` keeps the floating pane outside the tree
|
||||
(`chat_workspace_float.dart`, a `part` with the `ChatWorkspaceFloat`
|
||||
extension). `panes` and `paneCount` stay tiled-only. The pane keeps its id
|
||||
through float, swap, hide and dock.
|
||||
- `ChatWorkspace` gives each pane's content a `GlobalKey`. The floating chat is
|
||||
that same keyed subtree, built by `ChatFloatHost` inside the workspace, so the
|
||||
`ChatThreadView` State, draft, scroll and running turn move with it and are
|
||||
not rebuilt. Its inherited context and focus tree stay in the workspace.
|
||||
- `FloatingLayer` (`lib/ui/floating/`) paints a layer in the root overlay
|
||||
through `OverlayPortal`. The chat window covers the whole app. The terminal's
|
||||
floating window now uses the same layer, so the two share one z-order: the
|
||||
last one pressed, focused or opened is on top. Without an overlay (bare
|
||||
widget tests) the layer paints in place.
|
||||
- New files: `chat_float_{host,window,binding,store,shortcut}.dart`,
|
||||
`chat_workspace_float.dart`, `chat_screen_float.dart` and
|
||||
`ui/floating/floating_layer.dart`. Existing files changed: workspace
|
||||
controller hooks (open, split, close, replace, restore), the
|
||||
`ChatWorkspace.floatFrame` parameter and keyed content, the pane controls and
|
||||
`/close` and `/new` handling in `screen.dart`, the persistence wiring in
|
||||
`chat_screen_workspace.dart`, and `terminal_stage.dart`.
|
||||
|
||||
## Not done
|
||||
|
||||
- The sidebar's "visible" highlight does not count the floating chat.
|
||||
- Cmd+Y in a browser on macOS may be taken by the browser (History) before the
|
||||
app sees it. Ctrl+Y works there.
|
||||
@@ -0,0 +1,187 @@
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:shared_preferences/shared_preferences.dart';
|
||||
import 'package:pipelines_app/core/api_gateway.dart';
|
||||
import 'package:pipelines_app/core/servers/server_scope.dart';
|
||||
import 'package:pipelines_app/features/chat/conversation/chat_thread_view.dart';
|
||||
import 'package:pipelines_app/features/chat/screen.dart';
|
||||
import 'package:pipelines_app/features/chat/workspace/chat_float_store.dart';
|
||||
import 'package:pipelines_app/features/chat/workspace/chat_workspace.dart';
|
||||
import 'package:pipelines_app/features/chat/workspace/chat_workspace_store.dart';
|
||||
|
||||
import 'conversation/chat_thread_fixtures.dart';
|
||||
|
||||
class _Gateway extends FakeChatGateway {
|
||||
@override
|
||||
Future<JsonMap> call(String type, [JsonMap fields = const {}]) {
|
||||
if (type == 'chat_sessions') {
|
||||
return Future.value({
|
||||
'chat_sessions': [
|
||||
for (final id in ['a', 'b', 'c']) {'id': id, 'title': 'Chat $id'},
|
||||
],
|
||||
});
|
||||
}
|
||||
if (type == 'chat_shells') return Future.value({'chat_shells': []});
|
||||
return super.call(type, fields);
|
||||
}
|
||||
}
|
||||
|
||||
Finder _thread(String id) => find.byWidgetPredicate(
|
||||
(widget) => widget is ChatThreadView && widget.sessionId == id,
|
||||
skipOffstage: false,
|
||||
);
|
||||
Finder _input(String id) => find.descendant(
|
||||
of: find.byKey(ValueKey('chat-composer-$id'), skipOffstage: false),
|
||||
matching: find.byType(EditableText, skipOffstage: false),
|
||||
skipOffstage: false,
|
||||
);
|
||||
ChatWorkspaceController _workspace(WidgetTester tester) =>
|
||||
tester.widget<ChatWorkspace>(find.byType(ChatWorkspace)).controller;
|
||||
|
||||
Future<_Gateway> _mount(
|
||||
WidgetTester tester, {
|
||||
Size size = const Size(1800, 1000),
|
||||
}) async {
|
||||
tester.view.physicalSize = size;
|
||||
tester.view.devicePixelRatio = 1;
|
||||
addTearDown(tester.view.reset);
|
||||
final gateway = _Gateway()..history = (_) async => chatPage([]);
|
||||
bindServerIdentity(gateway, 'server-a');
|
||||
addTearDown(gateway.close);
|
||||
await tester.pumpWidget(
|
||||
MaterialApp(
|
||||
home: Scaffold(
|
||||
body: ChatScreen(gateway: gateway, persistWorkspace: true),
|
||||
),
|
||||
),
|
||||
);
|
||||
await tester.pumpAndSettle();
|
||||
return gateway;
|
||||
}
|
||||
|
||||
/// Opens [session]'s pane menu (wherever it is) and chooses [label].
|
||||
Future<void> _menu(WidgetTester tester, String session, String label) async {
|
||||
await tester.tap(
|
||||
find
|
||||
.descendant(
|
||||
of: _thread(session),
|
||||
matching: find.byTooltip('More actions'),
|
||||
)
|
||||
.hitTestable(),
|
||||
);
|
||||
await tester.pumpAndSettle();
|
||||
await tester.tap(find.text(label).last);
|
||||
await tester.pumpAndSettle();
|
||||
}
|
||||
|
||||
Future<void> _saved(String a, String b) async {
|
||||
final layout = ChatWorkspaceController()
|
||||
..open(a)
|
||||
..splitActive(b, ChatSplitAxis.horizontal);
|
||||
SharedPreferences.setMockInitialValues({
|
||||
scopedServerKey(chatWorkspacePreferenceKey, 'server-a'): layout
|
||||
.snapshot()!
|
||||
.encode(),
|
||||
});
|
||||
}
|
||||
|
||||
void main() {
|
||||
testWidgets('Float and Dock move the live chat with its draft', (
|
||||
tester,
|
||||
) async {
|
||||
await _saved('a', 'b');
|
||||
final gateway = await _mount(tester);
|
||||
final b = tester.state(_thread('b'));
|
||||
await tester.enterText(_input('b'), 'Draft B');
|
||||
await _menu(tester, 'b', 'Float (Ctrl+Y)');
|
||||
final controller = _workspace(tester);
|
||||
expect(controller.floatingPane?.sessionId, 'b');
|
||||
expect(controller.panes.map((p) => p.sessionId), ['a']);
|
||||
expect(find.byKey(const ValueKey('chat-float-title')), findsOneWidget);
|
||||
expect(tester.state(_thread('b')), same(b));
|
||||
expect(tester.widget<EditableText>(_input('b')).controller.text, 'Draft B');
|
||||
// The window floats over the app, not inside a pane.
|
||||
final window = tester.getRect(
|
||||
find.byKey(const ValueKey('chat-float-title')),
|
||||
);
|
||||
expect(window.width, lessThan(1800 / 2));
|
||||
|
||||
// The lone tiled pane can still float, swapping with the floating one.
|
||||
await tester.tap(
|
||||
find
|
||||
.descendant(
|
||||
of: _thread('a'),
|
||||
matching: find.byTooltip('More actions'),
|
||||
)
|
||||
.hitTestable(),
|
||||
);
|
||||
await tester.pumpAndSettle();
|
||||
expect(find.text('Float (Ctrl+Y)'), findsOneWidget);
|
||||
await tester.tapAt(const Offset(5, 995));
|
||||
await tester.pumpAndSettle();
|
||||
|
||||
await _menu(tester, 'b', 'Dock');
|
||||
expect(controller.floatingPane, isNull);
|
||||
expect(controller.panes.map((p) => p.sessionId), ['a', 'b']);
|
||||
expect(tester.state(_thread('b')), same(b));
|
||||
expect(tester.widget<EditableText>(_input('b')).controller.text, 'Draft B');
|
||||
expect(
|
||||
gateway.calls.where(
|
||||
(call) => ['chat_close', 'chat_interrupt'].contains(call.type),
|
||||
),
|
||||
isEmpty,
|
||||
);
|
||||
expect(tester.takeException(), isNull);
|
||||
await tester.pumpWidget(const SizedBox.shrink());
|
||||
});
|
||||
|
||||
testWidgets('the floating chat and its frame survive a reload', (
|
||||
tester,
|
||||
) async {
|
||||
await _saved('a', 'b');
|
||||
await _mount(tester);
|
||||
await _menu(tester, 'b', 'Float (Ctrl+Y)');
|
||||
await tester.drag(
|
||||
find.byKey(const ValueKey('chat-float-title')),
|
||||
const Offset(200, 40),
|
||||
);
|
||||
await tester.pumpAndSettle();
|
||||
await _menu(tester, 'b', 'Hide floating chat (Ctrl+Y)');
|
||||
expect(find.byKey(const ValueKey('chat-float-title')), findsNothing);
|
||||
await tester.pump(const Duration(seconds: 1));
|
||||
final preferences = await SharedPreferences.getInstance();
|
||||
final record = ChatFloatRecord.decode(
|
||||
preferences.getString(
|
||||
scopedServerKey(chatFloatPreferenceKey, 'server-a'),
|
||||
)!,
|
||||
)!;
|
||||
expect(record.pane?.sessionId, 'b');
|
||||
expect(record.shown, isFalse);
|
||||
expect(record.rect.left, chatFloatDefaultRect.left + 200);
|
||||
|
||||
await tester.pumpWidget(const SizedBox.shrink());
|
||||
await _mount(tester);
|
||||
final controller = _workspace(tester);
|
||||
expect(controller.floatingPane?.sessionId, 'b');
|
||||
expect(controller.floatShown, isFalse);
|
||||
expect(controller.panes.map((p) => p.sessionId), ['a']);
|
||||
controller.setFloatShown(true);
|
||||
await tester.pumpAndSettle();
|
||||
expect(
|
||||
tester.getTopLeft(find.byKey(const ValueKey('chat-float-title'))).dx,
|
||||
greaterThanOrEqualTo(chatFloatDefaultRect.left + 200),
|
||||
);
|
||||
await tester.pumpWidget(const SizedBox.shrink());
|
||||
});
|
||||
|
||||
testWidgets('narrow layouts offer no Float', (tester) async {
|
||||
await _saved('a', 'b');
|
||||
await _mount(tester, size: const Size(430, 900));
|
||||
final finder = find.byTooltip('More actions').hitTestable();
|
||||
await tester.tap(finder.first);
|
||||
await tester.pumpAndSettle();
|
||||
expect(find.textContaining('Float'), findsNothing);
|
||||
expect(find.text('Open chats (2)'), findsOneWidget);
|
||||
await tester.pumpWidget(const SizedBox.shrink());
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,229 @@
|
||||
import 'package:flutter/foundation.dart';
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:flutter/services.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:pipelines_app/features/chat/workspace/chat_float_binding.dart';
|
||||
import 'package:pipelines_app/features/chat/workspace/chat_float_shortcut.dart';
|
||||
import 'package:pipelines_app/features/chat/workspace/chat_workspace.dart';
|
||||
import 'package:pipelines_app/ui/input/keyboard_owner.dart';
|
||||
|
||||
class _Pane extends StatefulWidget {
|
||||
const _Pane(this.id);
|
||||
final String id;
|
||||
@override
|
||||
State<_Pane> createState() => _PaneState();
|
||||
}
|
||||
|
||||
class _PaneState extends State<_Pane> {
|
||||
final text = TextEditingController();
|
||||
final focus = FocusNode();
|
||||
@override
|
||||
void dispose() {
|
||||
text.dispose();
|
||||
focus.dispose();
|
||||
super.dispose();
|
||||
}
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) => Material(
|
||||
child: TextField(
|
||||
key: ValueKey('field-${widget.id}'),
|
||||
controller: text,
|
||||
focusNode: focus,
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
Finder _pane(String id) => find.byWidgetPredicate(
|
||||
(w) => w is _Pane && w.id == id,
|
||||
skipOffstage: false,
|
||||
);
|
||||
|
||||
class _Harness {
|
||||
final controller = ChatWorkspaceController()
|
||||
..open('a')
|
||||
..splitActive('b', ChatSplitAxis.horizontal);
|
||||
final frame = ChatFloatFrame();
|
||||
final typing = FocusNode(debugLabel: 'terminal');
|
||||
final typed = <LogicalKeyboardKey>[];
|
||||
|
||||
Widget app({bool narrow = false}) => MaterialApp(
|
||||
home: Scaffold(
|
||||
body: Column(
|
||||
children: [
|
||||
Expanded(
|
||||
child: ChatWorkspace(
|
||||
controller: controller,
|
||||
floatFrame: frame,
|
||||
singlePane: narrow,
|
||||
onFocusPane: (pane) => _focus(pane.sessionId),
|
||||
paneBuilder: (context, pane, active) => _Pane(pane.sessionId),
|
||||
),
|
||||
),
|
||||
TypingSurface(
|
||||
child: Focus(
|
||||
focusNode: typing,
|
||||
onKeyEvent: (node, event) {
|
||||
if (event is KeyDownEvent &&
|
||||
event.logicalKey == LogicalKeyboardKey.keyY) {
|
||||
typed.add(event.logicalKey);
|
||||
}
|
||||
return KeyEventResult.handled;
|
||||
},
|
||||
child: const SizedBox(height: 40, child: Text('terminal')),
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
);
|
||||
|
||||
WidgetTester? tester;
|
||||
void _focus(String session) =>
|
||||
tester!.state<_PaneState>(_pane(session)).focus.requestFocus();
|
||||
|
||||
void dispose() {
|
||||
controller.dispose();
|
||||
frame.dispose();
|
||||
typing.dispose();
|
||||
}
|
||||
}
|
||||
|
||||
Future<void> _chord(
|
||||
WidgetTester tester,
|
||||
LogicalKeyboardKey modifier, {
|
||||
LogicalKeyboardKey key = LogicalKeyboardKey.keyY,
|
||||
}) async {
|
||||
await tester.sendKeyDownEvent(modifier);
|
||||
await tester.sendKeyEvent(key);
|
||||
await tester.sendKeyUpEvent(modifier);
|
||||
await tester.pumpAndSettle();
|
||||
}
|
||||
|
||||
void main() {
|
||||
test('the chord is Ctrl+Y, and Cmd+Y on Apple platforms', () {
|
||||
expect(chatFloatShortcutLabel(TargetPlatform.linux), 'Ctrl+Y');
|
||||
expect(chatFloatShortcutLabel(TargetPlatform.windows), 'Ctrl+Y');
|
||||
expect(chatFloatShortcutLabel(TargetPlatform.macOS), 'Cmd+Y');
|
||||
});
|
||||
|
||||
Future<_Harness> pump(WidgetTester tester, {bool narrow = false}) async {
|
||||
tester.view.physicalSize = const Size(1280, 800);
|
||||
tester.view.devicePixelRatio = 1;
|
||||
addTearDown(tester.view.reset);
|
||||
final h = _Harness()..tester = tester;
|
||||
addTearDown(h.dispose);
|
||||
await tester.pumpWidget(h.app(narrow: narrow));
|
||||
await tester.pumpAndSettle();
|
||||
return h;
|
||||
}
|
||||
|
||||
testWidgets('Ctrl+Y floats the focused pane, then hides and shows it', (
|
||||
tester,
|
||||
) async {
|
||||
final h = await pump(tester);
|
||||
final b = tester.state<_PaneState>(_pane('b'));
|
||||
await tester.enterText(find.byKey(const ValueKey('field-b')), 'draft');
|
||||
await tester.tap(find.byKey(const ValueKey('field-a')));
|
||||
await tester.pump();
|
||||
// Plain Y and Shift+Y type; only the chord acts.
|
||||
await tester.sendKeyEvent(LogicalKeyboardKey.keyY);
|
||||
await _chord(tester, LogicalKeyboardKey.shiftLeft);
|
||||
expect(h.controller.floatingPane, isNull);
|
||||
|
||||
tester.state<_PaneState>(_pane('b')).focus.requestFocus();
|
||||
await tester.pump();
|
||||
await _chord(tester, LogicalKeyboardKey.controlLeft);
|
||||
expect(h.controller.floatingPane?.sessionId, 'b');
|
||||
expect(h.controller.paneCount, 1);
|
||||
expect(find.byKey(const ValueKey('chat-float-title')), findsOneWidget);
|
||||
// The chat moved: same State, same draft, its field has the keyboard.
|
||||
expect(tester.state<_PaneState>(_pane('b')), same(b));
|
||||
expect(b.text.text, 'draft');
|
||||
expect(b.focus.hasFocus, isTrue);
|
||||
|
||||
await _chord(tester, LogicalKeyboardKey.controlLeft);
|
||||
expect(h.controller.floatShown, isFalse);
|
||||
expect(find.byKey(const ValueKey('chat-float-title')), findsNothing);
|
||||
expect(tester.state<_PaneState>(_pane('b')), same(b));
|
||||
|
||||
// Showing focuses the floating chat; hiding gives the keyboard back.
|
||||
final a = tester.state<_PaneState>(_pane('a'));
|
||||
a.focus.requestFocus();
|
||||
await tester.pump();
|
||||
await _chord(tester, LogicalKeyboardKey.controlLeft);
|
||||
expect(h.controller.floatShown, isTrue);
|
||||
expect(b.focus.hasFocus, isTrue);
|
||||
await _chord(tester, LogicalKeyboardKey.controlLeft);
|
||||
expect(a.focus.hasFocus, isTrue);
|
||||
|
||||
// Docking returns the same chat to the tiling.
|
||||
h.controller.dock();
|
||||
await tester.pumpAndSettle();
|
||||
expect(h.controller.paneCount, 2);
|
||||
expect(tester.state<_PaneState>(_pane('b')), same(b));
|
||||
expect(b.text.text, 'draft');
|
||||
expect(tester.takeException(), isNull);
|
||||
});
|
||||
|
||||
testWidgets('in a terminal, Ctrl+Y acts only when a chat floats', (
|
||||
tester,
|
||||
) async {
|
||||
final h = await pump(tester);
|
||||
h.typing.requestFocus();
|
||||
await tester.pump();
|
||||
await tester.sendKeyEvent(LogicalKeyboardKey.keyY);
|
||||
await _chord(tester, LogicalKeyboardKey.controlLeft);
|
||||
// Nothing to float from the terminal: the shell gets Ctrl+Y (yank).
|
||||
expect(h.controller.floatingPane, isNull);
|
||||
expect(h.typed, contains(LogicalKeyboardKey.keyY));
|
||||
expect(h.typed.where((k) => k == LogicalKeyboardKey.keyY).length, 2);
|
||||
|
||||
h.controller.float(h.controller.panes.last.id);
|
||||
await tester.pumpAndSettle();
|
||||
h.typing.requestFocus();
|
||||
await tester.pump();
|
||||
h.typed.clear();
|
||||
await _chord(tester, LogicalKeyboardKey.controlLeft);
|
||||
expect(h.controller.floatShown, isFalse);
|
||||
expect(h.typed, isNot(contains(LogicalKeyboardKey.keyY)));
|
||||
await tester.sendKeyEvent(LogicalKeyboardKey.keyY);
|
||||
expect(h.typed, [LogicalKeyboardKey.keyY]);
|
||||
});
|
||||
|
||||
testWidgets(
|
||||
'on macOS Cmd+Y toggles and Ctrl+Y in a terminal stays with it',
|
||||
(tester) async {
|
||||
final h = await pump(tester);
|
||||
h.controller.float(h.controller.panes.last.id);
|
||||
await tester.pumpAndSettle();
|
||||
h.typing.requestFocus();
|
||||
await tester.pump();
|
||||
await _chord(tester, LogicalKeyboardKey.controlLeft);
|
||||
expect(h.controller.floatShown, isTrue);
|
||||
expect(h.typed, [LogicalKeyboardKey.keyY]);
|
||||
await _chord(tester, LogicalKeyboardKey.metaLeft);
|
||||
expect(h.controller.floatShown, isFalse);
|
||||
await _chord(tester, LogicalKeyboardKey.metaLeft);
|
||||
expect(h.controller.floatShown, isTrue);
|
||||
},
|
||||
variant: const TargetPlatformVariant({TargetPlatform.macOS}),
|
||||
);
|
||||
|
||||
testWidgets('narrow layouts never show the window or take the chord', (
|
||||
tester,
|
||||
) async {
|
||||
final h = await pump(tester, narrow: true);
|
||||
tester.state<_PaneState>(_pane('b')).focus.requestFocus();
|
||||
await tester.pump();
|
||||
await _chord(tester, LogicalKeyboardKey.controlLeft);
|
||||
expect(h.controller.floatingPane, isNull);
|
||||
// A float saved on a wide window stays, unpainted, with its state.
|
||||
h.controller.float(h.controller.panes.last.id);
|
||||
await tester.pumpAndSettle();
|
||||
expect(find.byKey(const ValueKey('chat-float-title')), findsNothing);
|
||||
expect(_pane('b'), findsOneWidget);
|
||||
await _chord(tester, LogicalKeyboardKey.controlLeft);
|
||||
expect(h.controller.floatShown, isTrue);
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,191 @@
|
||||
import 'dart:ui';
|
||||
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:pipelines_app/features/chat/workspace/chat_float_binding.dart';
|
||||
import 'package:pipelines_app/features/chat/workspace/chat_float_store.dart';
|
||||
import 'package:pipelines_app/features/chat/workspace/chat_workspace_controller.dart';
|
||||
|
||||
ChatWorkspaceController _three() => ChatWorkspaceController()
|
||||
..open('a')
|
||||
..splitActive('b', ChatSplitAxis.horizontal)
|
||||
..splitActive('c', ChatSplitAxis.vertical);
|
||||
|
||||
List<String> _sessions(ChatWorkspaceController c) =>
|
||||
c.panes.map((p) => p.sessionId).toList();
|
||||
|
||||
class _Store implements ChatFloatStore {
|
||||
_Store([this.record]);
|
||||
ChatFloatRecord? record;
|
||||
int writes = 0;
|
||||
@override
|
||||
Future<ChatFloatRecord?> read() async => record;
|
||||
@override
|
||||
Future<bool> write(ChatFloatRecord value) async {
|
||||
writes++;
|
||||
record = value;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
void main() {
|
||||
test('float takes a pane out of the tiling and keeps its id', () {
|
||||
final c = _three();
|
||||
final b = c.panes.firstWhere((p) => p.sessionId == 'b');
|
||||
c.activate(b.id);
|
||||
c.float(b.id);
|
||||
expect(c.floatingPane?.id, b.id);
|
||||
expect(c.floatShown, isTrue);
|
||||
expect(_sessions(c), ['a', 'c']);
|
||||
expect(c.activePane?.sessionId, isNot('b'));
|
||||
expect(c.holdsSession('b'), isTrue);
|
||||
});
|
||||
|
||||
test('a lone pane cannot float; the tiling never empties', () {
|
||||
final c = ChatWorkspaceController()..open('a');
|
||||
expect(c.canFloat(c.panes.single.id), isFalse);
|
||||
c.float(c.panes.single.id);
|
||||
expect(c.floatingPane, isNull);
|
||||
c.splitActive('b', ChatSplitAxis.horizontal);
|
||||
final b = c.activePane!;
|
||||
c.float(b.id);
|
||||
// Closing the last tiled pane docks the floating chat in its place.
|
||||
c.close(c.panes.single.id);
|
||||
expect(c.floatingPane, isNull);
|
||||
expect(c.panes.single.id, b.id);
|
||||
expect(c.activePaneId, b.id);
|
||||
});
|
||||
|
||||
test('floating another chat swaps it with the floating one', () {
|
||||
final c = _three();
|
||||
final a = c.panes.firstWhere((p) => p.sessionId == 'a');
|
||||
final c3 = c.panes.firstWhere((p) => p.sessionId == 'c');
|
||||
c.float(a.id);
|
||||
c.setFloatShown(false);
|
||||
c.float(c3.id);
|
||||
expect(c.floatingPane?.id, c3.id);
|
||||
expect(c.floatShown, isTrue);
|
||||
expect(_sessions(c), ['b', 'a']);
|
||||
expect(c.panes.last.id, a.id);
|
||||
});
|
||||
|
||||
test('dock puts the chat right of the active pane and activates it', () {
|
||||
final c = _three();
|
||||
final b = c.panes.firstWhere((p) => p.sessionId == 'b');
|
||||
c.float(b.id);
|
||||
final active = c.activePane!;
|
||||
c.dock();
|
||||
expect(c.floatingPane, isNull);
|
||||
expect(c.activePaneId, b.id);
|
||||
final panes = c.panes.map((p) => p.id).toList();
|
||||
expect(panes.indexOf(b.id), panes.indexOf(active.id) + 1);
|
||||
expect(_sessions(c).toSet(), {'a', 'b', 'c'});
|
||||
});
|
||||
|
||||
test('hide, show, reopen, close and /new follow the floating chat', () {
|
||||
final c = _three();
|
||||
final b = c.panes.firstWhere((p) => p.sessionId == 'b');
|
||||
c.float(b.id);
|
||||
c.toggleFloatShown();
|
||||
expect(c.floatShown, isFalse);
|
||||
c.open('b');
|
||||
expect(c.floatShown, isTrue);
|
||||
expect(_sessions(c), ['a', 'c']);
|
||||
c.splitActive('b', ChatSplitAxis.vertical);
|
||||
expect(c.paneCount, 2);
|
||||
c.replaceSession('b', 'b2');
|
||||
expect(c.floatingPane?.id, b.id);
|
||||
expect(c.floatingPane?.sessionId, 'b2');
|
||||
c.close(b.id);
|
||||
expect(c.floatingPane, isNull);
|
||||
expect(c.paneCount, 2);
|
||||
});
|
||||
|
||||
test('restoreFloat skips open sessions and taken ids', () {
|
||||
final c = ChatWorkspaceController()
|
||||
..open('a')
|
||||
..splitActive('b', ChatSplitAxis.horizontal);
|
||||
final taken = c.panes.first.id;
|
||||
expect(
|
||||
c.restoreFloat(const ChatWorkspacePane('x', 'a'), shown: true),
|
||||
isFalse,
|
||||
);
|
||||
expect(c.restoreFloat(ChatWorkspacePane(taken, 'z'), shown: true), isFalse);
|
||||
expect(
|
||||
c.restoreFloat(const ChatWorkspacePane('x', 'z'), shown: false),
|
||||
isTrue,
|
||||
);
|
||||
expect(c.floatingPane?.sessionId, 'z');
|
||||
expect(c.floatShown, isFalse);
|
||||
// A new split id never collides with the floating pane's.
|
||||
c.splitActive('d', ChatSplitAxis.vertical);
|
||||
expect(c.panes.map((p) => p.id), isNot(contains('x')));
|
||||
});
|
||||
|
||||
test('a restored layout drops any floating chat', () {
|
||||
final c = _three();
|
||||
c.float(c.panes.first.id);
|
||||
final snapshot = c.snapshot()!;
|
||||
c.restoreLayout(snapshot);
|
||||
expect(c.floatingPane, isNull);
|
||||
});
|
||||
|
||||
test('records round-trip and reject malformed input', () {
|
||||
const record = ChatFloatRecord(
|
||||
pane: ChatWorkspacePane('p1', 'server:abc'),
|
||||
shown: true,
|
||||
rect: Rect.fromLTWH(10, 20, 400, 300),
|
||||
);
|
||||
expect(ChatFloatRecord.decode(record.encode()), record);
|
||||
const none = ChatFloatRecord(rect: chatFloatDefaultRect);
|
||||
expect(ChatFloatRecord.decode(none.encode()), none);
|
||||
for (final bad in [
|
||||
'',
|
||||
'[]',
|
||||
'{"version":2,"rect":[0,0,1,1]}',
|
||||
'{"version":1,"rect":[0,0,-1,1]}',
|
||||
'{"version":1,"rect":[0,0,1]}',
|
||||
'{"version":1,"rect":[0,0,1,1],"pane":{"id":" x","session_id":"a"}}',
|
||||
'{"version":1,"rect":[0,0,1,1],"pane":7}',
|
||||
]) {
|
||||
expect(ChatFloatRecord.decode(bad), isNull, reason: bad);
|
||||
}
|
||||
});
|
||||
|
||||
test('binding restores after the layout and saves changes', () async {
|
||||
final c = ChatWorkspaceController()
|
||||
..open('a')
|
||||
..splitActive('b', ChatSplitAxis.horizontal);
|
||||
final store = _Store(
|
||||
const ChatFloatRecord(
|
||||
pane: ChatWorkspacePane('f', 'c'),
|
||||
shown: true,
|
||||
rect: Rect.fromLTWH(5, 6, 400, 300),
|
||||
),
|
||||
);
|
||||
final frame = ChatFloatFrame();
|
||||
final binding = ChatFloatBinding(
|
||||
controller: c,
|
||||
frame: frame,
|
||||
store: store,
|
||||
debounce: Duration.zero,
|
||||
);
|
||||
await binding.start();
|
||||
expect(c.floatingPane?.sessionId, 'c');
|
||||
expect(c.floatShown, isTrue);
|
||||
expect(frame.rect, const Rect.fromLTWH(5, 6, 400, 300));
|
||||
expect(store.writes, 0);
|
||||
c.setFloatShown(false);
|
||||
await Future<void>.delayed(Duration.zero);
|
||||
await binding.flush();
|
||||
expect(store.record?.shown, isFalse);
|
||||
frame.move(const Rect.fromLTWH(50, 60, 400, 300));
|
||||
final writes = store.writes;
|
||||
await binding.flush();
|
||||
expect(store.writes, writes + 1);
|
||||
expect(store.record?.rect.left, 50);
|
||||
c.dock();
|
||||
binding.dispose();
|
||||
await Future<void>.delayed(Duration.zero);
|
||||
expect(store.record?.pane, isNull);
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:pipelines_app/ui/floating/floating_layer.dart';
|
||||
|
||||
void main() {
|
||||
testWidgets('the layer last pressed or focused paints on top', (
|
||||
tester,
|
||||
) async {
|
||||
tester.view.physicalSize = const Size(800, 600);
|
||||
tester.view.devicePixelRatio = 1;
|
||||
addTearDown(tester.view.reset);
|
||||
final hits = <String>[];
|
||||
final focus = FocusNode();
|
||||
addTearDown(focus.dispose);
|
||||
Widget window(String name, double left, {FocusNode? node}) => Positioned(
|
||||
left: left,
|
||||
top: 100,
|
||||
width: 200,
|
||||
height: 200,
|
||||
child: Focus(
|
||||
focusNode: node,
|
||||
child: GestureDetector(
|
||||
behavior: HitTestBehavior.opaque,
|
||||
onTap: () => hits.add(name),
|
||||
child: const SizedBox.expand(),
|
||||
),
|
||||
),
|
||||
);
|
||||
var behind = 0;
|
||||
await tester.pumpWidget(
|
||||
MaterialApp(
|
||||
home: Scaffold(
|
||||
body: Stack(
|
||||
children: [
|
||||
Positioned.fill(
|
||||
child: GestureDetector(
|
||||
onTap: () => behind++,
|
||||
child: const ColoredBox(color: Colors.white),
|
||||
),
|
||||
),
|
||||
// Nested inside a page, like the chat workspace.
|
||||
Positioned.fill(
|
||||
child: FloatingLayer(
|
||||
coverOverlay: true,
|
||||
builder: (context, bounds) => [
|
||||
window('chat', 100, node: focus),
|
||||
],
|
||||
),
|
||||
),
|
||||
Positioned.fill(
|
||||
child: FloatingLayer(
|
||||
builder: (context, bounds) => [window('terminal', 200)],
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
),
|
||||
);
|
||||
const overlap = Offset(250, 200);
|
||||
await tester.tapAt(overlap);
|
||||
expect(hits.last, 'terminal');
|
||||
await tester.tapAt(const Offset(120, 200));
|
||||
await tester.pump();
|
||||
await tester.tapAt(overlap);
|
||||
expect(hits.last, 'chat');
|
||||
await tester.tapAt(const Offset(380, 200));
|
||||
await tester.pump();
|
||||
await tester.tapAt(overlap);
|
||||
expect(hits.last, 'terminal');
|
||||
focus.requestFocus();
|
||||
await tester.pump();
|
||||
await tester.pump();
|
||||
await tester.tapAt(overlap);
|
||||
expect(hits.last, 'chat');
|
||||
// Space between windows passes through to the page.
|
||||
await tester.tapAt(const Offset(700, 500));
|
||||
expect(behind, 1);
|
||||
});
|
||||
}
|
||||
Reference in New Issue
Block a user