Files
pipelines/app/lib/features/chat/workspace/chat_float_host.dart
T
alan 7ff012880b Add explicit surface visibility signal
Provide composable shown/current visibility for retained surfaces and migrate visibility readers away from TickerMode. This keeps ticker muting separate from painted and current-surface state.
2026-11-10 20:28:09 +00:00

338 lines
10 KiB
Dart

import 'dart:async';
import 'package:flutter/material.dart';
import 'package:flutter/scheduler.dart';
import 'package:flutter/services.dart';
import '../../../ui/floating/floating_layer.dart';
import '../../../ui/motion/motion.dart';
import '../../../ui/motion/surface_visibility.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 chats over the app: their
/// windows, show and hide motion, focus and shortcut (see
/// [chatFloatShortcut]). [content] is a floating pane's live view, moved here
/// from the tiling rather than rebuilt.
///
/// The windows show while [enabled] (a wide layout), over every destination,
/// like the floating terminal. They show and hide together.
class ChatFloatHost extends StatefulWidget {
const ChatFloatHost({
super.key,
required this.controller,
required this.frames,
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 ChatFloatFrames frames;
final bool enabled;
final String Function(ChatWorkspacePane pane) title;
final Widget Function(ChatWorkspacePane pane) content;
/// A floating pane's focus scope.
final FocusScopeNode? Function(ChatWorkspacePane pane) 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> {
bool _visible = false;
Set<String> _paneIds = const {};
FocusNode? _previous;
@override
void initState() {
super.initState();
FocusManager.instance.addEarlyKeyEventHandler(_key);
widget.controller.addListener(_sync);
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);
super.dispose();
}
void _sync() {
if (!mounted) return;
final panes = widget.controller.floatingPanes;
final ids = {for (final pane in panes) pane.id};
final visible = widget.enabled && widget.controller.floatShown;
for (final (index, pane) in panes.indexed) {
widget.frames.place(pane.id, index: index);
}
if (panes.isEmpty) {
// Docked or closed: the views went back to the tiling.
_previous = null;
} else if (visible != _visible) {
if (visible) {
_remember();
_focusSoon(panes.last);
} else {
_release();
}
} else if (visible) {
// A newly floated chat takes the keyboard.
final added = panes.where((p) => !_paneIds.contains(p.id)).lastOrNull;
if (added != null) _focusSoon(added);
}
_paneIds = ids;
if (visible != _visible) setState(() => _visible = visible);
}
bool _inside(FocusNode node) => widget.controller.floatingPanes.any((pane) {
final scope = widget.scope(pane);
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.isFloating(pane.id)) return;
final focus = widget.onFocusPane;
if (focus != null) {
focus(pane);
} else {
widget.scope(pane)?.requestFocus();
}
})
..ensureVisualUpdate();
}
/// Gives the keyboard back to what had it before the chats showed, if a
/// floating chat has it now.
void _release() {
final previous = _previous;
_previous = null;
final current = FocusManager.instance.primaryFocus;
if (current == null || !_inside(current)) return;
if (previous != null &&
previous.context != null &&
previous.canRequestFocus) {
previous.requestFocus();
} else {
current.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 ||
!widget.enabled ||
!chatFloatShortcut(event, HardwareKeyboard.instance)) {
return KeyEventResult.ignored;
}
final controller = widget.controller;
if (controller.floatingPanes.isEmpty) {
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 panes = widget.controller.floatingPanes;
final cupertino =
chatControlsStyleOf(context) == ChatControlsStyle.cupertino;
return Stack(
fit: StackFit.expand,
children: [
widget.child,
for (final (index, pane) in panes.indexed)
Positioned.fill(
key: ValueKey(pane.id),
// Shown over every destination; the window's motion keeps
// running there (see [_ChatFloatSlot]).
child: FloatingLayer(
open: _visible,
coverOverlay: true,
builder: (context, bounds) => [
ListenableBuilder(
listenable: widget.frames,
builder: (context, _) => _ChatFloatSlot(
visible: _visible,
rect: widget.frames.rectFor(pane.id, index: index),
currentRect: () =>
widget.frames.rectFor(pane.id, index: index),
onMove: (rect) => widget.frames.move(pane.id, rect),
onCommit: widget.frames.commit,
bounds: bounds,
title: widget.title(pane),
cupertino: cupertino,
onDock: () => widget.controller.dock(pane.id),
onHide: () => widget.controller.setFloatShown(false),
child: widget.content(pane),
),
),
],
),
),
],
);
}
}
/// One floating chat's window and its own grow-and-fade motion, so a chat
/// floated while the others show animates in alone.
class _ChatFloatSlot extends StatefulWidget {
const _ChatFloatSlot({
required this.visible,
required this.rect,
required this.currentRect,
required this.onMove,
required this.onCommit,
required this.bounds,
required this.title,
required this.cupertino,
required this.onDock,
required this.onHide,
required this.child,
});
final bool visible;
final Rect rect;
final Rect Function() currentRect;
final ValueChanged<Rect> onMove;
final VoidCallback onCommit;
final Size bounds;
final String title;
final bool cupertino;
final VoidCallback onDock;
final VoidCallback onHide;
final Widget child;
@override
State<_ChatFloatSlot> createState() => _ChatFloatSlotState();
}
class _ChatFloatSlotState extends State<_ChatFloatSlot>
implements TickerProvider {
Ticker? _ticker;
/// A ticker the hidden destination's [TickerMode] does not mute: the
/// window must still show and hide over another destination, and a
/// TickerMode cannot re-enable what an ancestor turned off.
@override
Ticker createTicker(TickerCallback onTick) {
assert(_ticker == null, 'one reveal ticker per window');
return _ticker = Ticker(onTick, debugLabel: 'chat float reveal');
}
late final AnimationController _reveal = AnimationController(
vsync: this,
duration: Motion.standard,
);
late final CurvedAnimation _curve = CurvedAnimation(
parent: _reveal,
curve: Motion.curve,
reverseCurve: Curves.easeInCubic,
);
@override
void initState() {
super.initState();
if (widget.visible) {
WidgetsBinding.instance.addPostFrameCallback((_) => _run());
}
}
@override
void didUpdateWidget(covariant _ChatFloatSlot oldWidget) {
super.didUpdateWidget(oldWidget);
if (oldWidget.visible != widget.visible) _run();
}
void _run() {
if (!mounted) return;
_reveal.duration = Motion.of(context, Motion.standard);
unawaited(widget.visible ? _reveal.forward() : _reveal.reverse());
}
@override
void dispose() {
_curve.dispose();
_reveal.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) => AnimatedBuilder(
animation: _reveal,
builder: (context, _) {
final offstage = !widget.visible && _reveal.isDismissed;
return ChatFloatWindow(
rect: widget.rect,
currentRect: widget.currentRect,
onMove: widget.onMove,
onCommit: widget.onCommit,
bounds: widget.bounds,
title: widget.title,
cupertino: widget.cupertino,
reveal: _curve,
hiding: !widget.visible,
offstage: offstage,
shortcut: chatFloatShortcutLabel(),
onDock: widget.onDock,
onHide: widget.onHide,
// A hidden window's chat pauses its tickers like a hidden tab.
child: TickerMode(
enabled: !offstage,
child: SurfaceVisibility(
shown: !offstage,
current: !offstage,
child: widget.child,
),
),
);
},
);
}