Files
pipelines/app/lib/features/chat/workspace/chat_workspace.dart
T

229 lines
8.5 KiB
Dart

import 'package:flutter/semantics.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'chat_workspace_controller.dart';
import 'chat_workspace_divider.dart';
import 'chat_workspace_geometry.dart';
import 'chat_mobile_panes.dart';
export 'chat_workspace_controller.dart';
export 'chat_workspace_geometry.dart' show ChatPaneDirection;
typedef ChatWorkspacePaneBuilder =
Widget Function(BuildContext context, ChatWorkspacePane pane, bool active);
/// All chat views are stable siblings, independent of the split tree. Moving a
/// divider or adding/removing a neighbouring split never reparents a chat view.
class ChatWorkspace extends StatefulWidget {
const ChatWorkspace({
super.key,
required this.controller,
required this.paneBuilder,
this.onFocusPane,
this.shortcutsEnabled = true,
this.singlePane = false,
this.mobilePeeks = false,
this.paneTitle,
});
final ChatWorkspaceController controller;
final ChatWorkspacePaneBuilder paneBuilder;
final bool shortcutsEnabled;
/// Keeps the retained layout while presenting only the active chat.
final bool singlePane;
final bool mobilePeeks;
final String Function(ChatWorkspacePane)? paneTitle;
/// Keyboard navigation only: the owner can focus the target composer.
/// Pointer activation leaves text-selection and pointer focus alone.
final ValueChanged<ChatWorkspacePane>? onFocusPane;
@override
State<ChatWorkspace> createState() => _ChatWorkspaceState();
}
class _ChatWorkspaceState extends State<ChatWorkspace> {
final _focus = FocusNode(debugLabel: 'Chat workspace');
final Map<String, FocusScopeNode> _panes = {};
ChatWorkspaceGeometry? _geometry;
String? _lastActiveId;
String? _peekId;
@override
void initState() {
super.initState();
HardwareKeyboard.instance.addHandler(_key);
}
bool _key(KeyEvent event) {
if (!widget.shortcutsEnabled ||
widget.controller.paneCount <= 1 ||
!_focus.hasFocus ||
event is! KeyDownEvent) {
return false;
}
final keyboard = HardwareKeyboard.instance;
final modifier =
keyboard.isControlPressed && !keyboard.isMetaPressed ||
defaultTargetPlatform == TargetPlatform.macOS &&
keyboard.isMetaPressed &&
!keyboard.isControlPressed;
if (!modifier || !keyboard.isShiftPressed || keyboard.isAltPressed) {
return false;
}
final direction = switch (event.logicalKey) {
LogicalKeyboardKey.arrowLeft => ChatPaneDirection.left,
LogicalKeyboardKey.arrowRight => ChatPaneDirection.right,
LogicalKeyboardKey.arrowUp => ChatPaneDirection.up,
LogicalKeyboardKey.arrowDown => ChatPaneDirection.down,
_ => null,
};
if (direction == null) return false;
final id = widget.controller.activePaneId;
final target = id == null ? null : _geometry?.neighbor(id, direction);
if (target != null) {
widget.controller.activate(target);
final pane = widget.controller.activePane!;
WidgetsBinding.instance.addPostFrameCallback((_) {
if (!mounted || widget.controller.activePaneId != target) return;
if (widget.onFocusPane != null) {
widget.onFocusPane!(pane);
} else {
_panes[target]?.requestFocus();
}
});
}
// Consume a workspace navigation chord at an edge too: it must not select
// words in the current composer when there is no neighbouring pane.
return true;
}
@override
void dispose() {
HardwareKeyboard.instance.removeHandler(_key);
_focus.dispose();
for (final node in _panes.values) {
node.dispose();
}
super.dispose();
}
@override
Widget build(BuildContext context) => Focus(
focusNode: _focus,
child: ListenableBuilder(
listenable: widget.controller,
builder: (context, _) => LayoutBuilder(
builder: (context, constraints) {
final root = widget.controller.root;
if (root == null) return const SizedBox.shrink();
final geometry = ChatWorkspaceGeometry(root, constraints.biggest);
_geometry = geometry;
final collapsed = widget.singlePane || geometry.collapsed;
final panes = widget.controller.panes;
final activeId = widget.controller.activePaneId;
if (_lastActiveId != activeId) {
_peekId = _lastActiveId;
_lastActiveId = activeId;
}
final mobile = widget.mobilePeeks && activeId != null
? ChatMobilePanes(
panes: panes,
activeId: activeId,
peekId: _peekId,
size: constraints.biggest,
)
: null;
final existing = panes.map((p) => p.id).toSet();
for (final id
in _panes.keys.where((id) => !existing.contains(id)).toList()) {
final node = _panes.remove(id)!;
WidgetsBinding.instance.addPostFrameCallback((_) => node.dispose());
}
return Stack(
fit: StackFit.expand,
clipBehavior: Clip.hardEdge,
children: [
for (final pane in panes)
Positioned.fromRect(
key: ValueKey('chat-workspace-${pane.id}'),
rect:
mobile?.rects[pane.id] ??
(collapsed
? Offset.zero & constraints.biggest
: geometry.panes[pane.id]!),
child: Offstage(
offstage: mobile != null
? !mobile.rects.containsKey(pane.id)
: collapsed &&
pane.id != widget.controller.activePaneId,
child: ExcludeFocus(
excluding:
collapsed &&
pane.id != widget.controller.activePaneId,
child: ChatMobilePaneViewport(
peek: mobile?.peekId == pane.id,
active: pane.id == activeId,
animate:
mobile != null &&
!MediaQuery.disableAnimationsOf(context),
contentHeight: mobile?.contentHeight,
label: widget.paneTitle?.call(pane) ?? pane.sessionId,
paneId: pane.id,
onActivate: () {
FocusManager.instance.primaryFocus?.unfocus();
widget.controller.activate(pane.id);
},
child: FocusScope(
node: _panes.putIfAbsent(
pane.id,
() => FocusScopeNode(debugLabel: pane.id),
),
onFocusChange: (focused) {
if (focused && !widget.mobilePeeks) {
widget.controller.activate(pane.id);
}
},
child: Listener(
behavior: HitTestBehavior.translucent,
onPointerDown: (_) =>
widget.controller.activate(pane.id),
child: Semantics(
identifier: 'chat-pane-${pane.id}',
container: true,
sortKey: mobile == null
? null
: const OrdinalSortKey(0),
child: widget.paneBuilder(
context,
pane,
pane.id == widget.controller.activePaneId,
),
),
),
),
),
),
),
),
if (!collapsed && mobile == null)
for (final divider in geometry.dividers)
Positioned.fromRect(
key: ValueKey('chat-workspace-${divider.split.id}'),
rect: divider.rect,
child: ChatWorkspaceDivider(
geometry: divider,
onChanged: (ratio) =>
widget.controller.resize(divider.split.id, ratio),
),
),
],
);
},
),
),
);
}