229 lines
8.5 KiB
Dart
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),
|
|
),
|
|
),
|
|
],
|
|
);
|
|
},
|
|
),
|
|
),
|
|
);
|
|
}
|