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

424 lines
15 KiB
Dart

import 'package:flutter/semantics.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import '../../../ui/motion/quick_switch_animation.dart';
import 'chat_center_stage_layout.dart';
import 'chat_center_stage_motion.dart';
import 'chat_center_stage_strip.dart';
import 'chat_workspace_controller.dart';
import 'chat_workspace_geometry.dart';
import 'chat_mobile_panes.dart';
import 'chat_pane_switch_motion.dart';
import 'chat_pane_backdrop.dart';
import 'chat_workspace_surface.dart';
import '../../../ui/input/keyboard_owner.dart';
export 'chat_workspace_controller.dart';
export 'chat_workspace_geometry.dart' show ChatPaneDirection;
typedef ChatWorkspacePaneBuilder =
Widget Function(BuildContext context, ChatWorkspacePane pane, bool active);
/// Describes the edge ownership of the pane currently being built.
class ChatWorkspacePaneScope extends InheritedWidget {
const ChatWorkspacePaneScope({
super.key,
required this.topEdgeShared,
required this.bottomEdgeShared,
required this.leftEdgeShared,
required this.rightEdgeShared,
required super.child,
});
final bool topEdgeShared;
final bool bottomEdgeShared;
final bool leftEdgeShared;
final bool rightEdgeShared;
static ChatWorkspacePaneScope? maybeOf(BuildContext context) =>
context.dependOnInheritedWidgetOfExactType<ChatWorkspacePaneScope>();
@override
bool updateShouldNotify(ChatWorkspacePaneScope oldWidget) =>
topEdgeShared != oldWidget.topEdgeShared ||
bottomEdgeShared != oldWidget.bottomEdgeShared ||
leftEdgeShared != oldWidget.leftEdgeShared ||
rightEdgeShared != oldWidget.rightEdgeShared;
}
/// 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.animationStyle,
this.paneTitle,
this.onVisibleSessionIdsChanged,
this.centerStage,
this.paneColor,
});
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 QuickSwitchAnimation? animationStyle;
final String Function(ChatWorkspacePane)? paneTitle;
final ValueChanged<Set<String>>? onVisibleSessionIdsChanged;
/// While true on a wide window, the active chat takes center stage and the
/// others line up beside it (see [ChatCenterStageLayout]).
final ValueListenable<bool>? centerStage;
/// A pane's chat colour, for its strip beside the stage.
final Color? Function(ChatWorkspacePane)? paneColor;
/// 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>
with TickerProviderStateMixin {
final _focus = FocusNode(debugLabel: 'Chat workspace');
final Map<String, FocusScopeNode> _panes = {};
late final ChatPaneSwitchMotion _motion;
late final ChatCenterStageMotion _stage = ChatCenterStageMotion(vsync: this);
ChatWorkspaceGeometry? _geometry;
String? _lastActiveId;
Set<String> _visibleSessionIds = const {};
late final ChatPaneBackdrop _backdrop;
void _backdropChanged() {
if (mounted) setState(() {});
}
@override
void initState() {
super.initState();
_motion = ChatPaneSwitchMotion(vsync: this);
_motion.animation.addStatusListener(_motionSettled);
_backdrop = ChatPaneBackdrop(_motion.animation)
..addListener(_backdropChanged);
HardwareKeyboard.instance.addHandler(_key);
}
void _reportVisible(Set<String> ids) {
if (setEquals(ids, _visibleSessionIds)) return;
_visibleSessionIds = Set.unmodifiable(ids);
WidgetsBinding.instance.addPostFrameCallback((_) {
if (mounted && setEquals(ids, _visibleSessionIds)) {
widget.onVisibleSessionIdsChanged?.call(_visibleSessionIds);
}
});
}
void _motionSettled(AnimationStatus status) {
if (status != AnimationStatus.completed) return;
WidgetsBinding.instance.addPostFrameCallback((_) {
if (mounted) setState(() {});
});
}
bool _key(KeyEvent event) {
if (!widget.shortcutsEnabled ||
widget.controller.paneCount <= 1 ||
!_focus.hasFocus ||
event is! KeyDownEvent ||
primaryFocusIsTypingSurface()) {
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 stage = _stage.stage;
final target = id == null
? null
: stage != null
? stage.neighbor(id, direction)
: _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);
_backdrop.dispose();
_motion.animation.removeStatusListener(_motionSettled);
_motion.dispose();
_stage.dispose();
_focus.dispose();
for (final node in _panes.values) {
node.dispose();
}
super.dispose();
}
@override
Widget build(BuildContext context) => Focus(
focusNode: _focus,
child: ListenableBuilder(
listenable: Listenable.merge([
widget.controller,
QuickSwitchAnimationController.instance,
?widget.centerStage,
]),
builder: (context, _) => LayoutBuilder(
builder: (context, constraints) {
final root = widget.controller.root;
if (root == null) {
_reportVisible({});
return const SizedBox.shrink();
}
final geometry = ChatWorkspaceGeometry(root, constraints.biggest);
_geometry = geometry;
final collapsed = widget.singlePane || geometry.collapsed;
final panes = widget.controller.panes;
// Finish one joined loop before taking the latest requested role.
// Repeated taps/chords never tear the tape or duplicate a live chat.
final activeId =
_motion.isAnimating &&
panes.any((pane) => pane.id == _lastActiveId)
? _lastActiveId
: widget.controller.activePaneId;
final switching = _lastActiveId != activeId;
if (switching) {
_lastActiveId = activeId;
}
final mobile = widget.mobilePeeks && collapsed && activeId != null
? ChatMobilePanes(
panes: panes,
activeId: activeId,
size: constraints.biggest,
peekFraction: widget.controller.mobilePeekFraction,
)
: null;
var animate = !MediaQuery.disableAnimationsOf(context);
if (mobile != null &&
switching &&
animate &&
(widget.animationStyle ??
QuickSwitchAnimationController.instance.value) ==
QuickSwitchAnimation.tape) {
// The top exit requires a fresh picture. If painting is not ready,
// settle safely instead of moving the only live tree offscreen.
animate = _backdrop.capture(context);
}
if (mobile == null) {
_motion.rest();
} else {
_motion.layout(
rects: mobile.rects,
size: constraints.biggest,
activeId: activeId!,
switching: switching,
animate: animate,
style:
widget.animationStyle ??
QuickSwitchAnimationController.instance.value,
);
}
final engaged = !collapsed && mobile == null;
_stage.layout(
engaged: engaged,
split: geometry.panes,
stage: engaged && widget.centerStage?.value == true
? ChatCenterStageLayout.of(constraints.biggest, [
for (final pane in panes) pane.id,
], activeId)
: null,
animate: !MediaQuery.disableAnimationsOf(context),
);
_reportVisible({
for (final pane in panes)
if (mobile != null
? mobile.rects.containsKey(pane.id)
: !collapsed || pane.id == activeId)
pane.sessionId,
});
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());
}
bool sharesEdge(Rect pane, String edge) => geometry.dividers.any((
divider,
) {
final horizontalOverlap =
pane.left < divider.rect.right &&
pane.right > divider.rect.left;
final verticalOverlap =
pane.top < divider.rect.bottom &&
pane.bottom > divider.rect.top;
return switch (edge) {
'top' =>
(pane.top - divider.rect.bottom).abs() < .5 &&
horizontalOverlap,
'bottom' =>
(pane.bottom - divider.rect.top).abs() < .5 &&
horizontalOverlap,
'left' =>
(pane.left - divider.rect.right).abs() < .5 && verticalOverlap,
'right' =>
(pane.right - divider.rect.left).abs() < .5 && verticalOverlap,
_ => false,
};
});
final sharedEdges = <String, Set<String>>{
for (final entry in geometry.panes.entries)
entry.key: {
for (final edge in const ['top', 'bottom', 'left', 'right'])
if (!collapsed &&
mobile == null &&
_stage.stage == null &&
sharesEdge(entry.value, edge))
edge,
},
};
return chatWorkspaceSurface(
context: context,
backdrop: _backdrop,
motion: _motion,
stage: _stage,
stageStrip: _strip,
controller: widget.controller,
geometry: geometry,
mobile: mobile,
collapsed: collapsed,
size: constraints.biggest,
panes: panes,
paneView: (pane) =>
_paneView(pane, mobile, collapsed, activeId, sharedEdges),
);
},
),
),
);
Widget _strip(ChatWorkspacePane pane) => ChatCenterStageStrip(
paneId: pane.id,
title: widget.paneTitle?.call(pane) ?? pane.sessionId,
color: widget.paneColor?.call(pane),
onSelected: () {
FocusManager.instance.primaryFocus?.unfocus();
widget.controller.activate(pane.id);
// Choosing a strip is choosing that chat: its composer takes the
// keyboard once it is on stage.
WidgetsBinding.instance.addPostFrameCallback((_) {
if (!mounted || widget.controller.activePaneId != pane.id) return;
widget.onFocusPane?.call(pane);
});
},
);
Widget _paneView(
ChatWorkspacePane pane,
ChatMobilePanes? mobile,
bool collapsed,
String? activeId,
Map<String, Set<String>> sharedEdges,
) {
final outgoing = _motion.isRetainedOutgoing(pane.id);
final peek = mobile?.peekId == pane.id || outgoing;
final active = pane.id == activeId;
return Offstage(
offstage: mobile != null
? !mobile.rects.containsKey(pane.id) && !outgoing
: collapsed && !active,
child: ExcludeFocus(
excluding: collapsed && !active,
child: ChatMobilePaneViewport(
peek: peek,
active: active,
barReveal: _motion.revealFor(pane.id),
fixedChromeLayout: _motion.isAnimating && !_motion.isTape,
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 && 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),
),
),
),
),
),
),
),
);
}
}