1087 lines
38 KiB
Dart
1087 lines
38 KiB
Dart
import 'dart:async';
|
|
import 'dart:math' as math;
|
|
|
|
import 'package:flutter/cupertino.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter/services.dart';
|
|
|
|
import '../../../core/api_gateway.dart';
|
|
import '../../../core/transport/pipelines_client.dart';
|
|
import '../data/upload/chat_upload.dart';
|
|
import '../domain/chat_attachment_draft.dart';
|
|
import '../domain/chat_attachment_picker.dart';
|
|
import '../domain/chat_attachment_wire.dart';
|
|
import '../domain/chat_clipboard_paste.dart';
|
|
import '../domain/chat_commands.dart';
|
|
import '../ui/sessions/chat_adaptive.dart';
|
|
import 'chat_command_actions.dart';
|
|
import 'chat_command_palette.dart';
|
|
import 'chat_composer_controller.dart';
|
|
|
|
/// The composer's multiline placeholder, verbatim from the web client.
|
|
const String chatComposerPlaceholder = 'Message the agent… or / for commands';
|
|
|
|
/// The single primary control's words while a turn is and is not running.
|
|
const String chatSendLabel = 'Send';
|
|
const String chatStopLabel = 'Stop';
|
|
|
|
/// The attach control's accessible name, verbatim from the web composer.
|
|
const String chatAttachLabel = 'Attach file';
|
|
|
|
/// The unknown-command report's two actions, verbatim from the web client.
|
|
const String chatCommandSendAsMessageLabel = 'Send as message';
|
|
const String chatCommandCancelLabel = 'Cancel';
|
|
const String chatCommandNoticeLabel = 'Command';
|
|
const String chatCommandFailedLabel = 'Command failed';
|
|
const String chatCommandDismissLabel = 'Dismiss command notice';
|
|
|
|
/// The web's line after `/stop`'s interrupt was accepted.
|
|
const String chatStopCommandNotice = 'Stopping the running turn…';
|
|
|
|
/// Shown while the reply says this prompt waits behind the running turn.
|
|
const String chatQueuedNotice =
|
|
'Queued — it will send when the current turn finishes.';
|
|
|
|
/// The foot of one conversation: a native multiline field and one primary
|
|
/// Send/Stop control, driven by the landed [ChatComposerController].
|
|
///
|
|
/// The field owns only its [TextEditingController] and focus; the durable draft
|
|
/// text lives in the composer controller, so a live transcript rebuild never
|
|
/// replaces the operator's caret. Enter inserts a newline and Ctrl/Cmd+Enter
|
|
/// sends the plain message. A leading `/` opens the recorded command palette
|
|
/// above the field: rows are filtered by name prefix, Up/Down move the
|
|
/// highlight, Enter or a tap completes the highlighted command, Escape closes
|
|
/// the palette. A slash draft is never handed to the prompt path: `/new`,
|
|
/// `/close` and `/rename` run through [commands], `/stop` and `/help` run
|
|
/// locally or through the existing Stop path; text naming no recorded command
|
|
/// becomes the web client's local no-send report with its explicit "Send as
|
|
/// message" offer. Picked files are memory-only chips:
|
|
/// their names are shown with the host's own remove action and the bounded
|
|
/// draft owns every refusal. Send carries the chips as the landed wire parts,
|
|
/// keeps them until the prompt is accepted and leaves them in place on a
|
|
/// refusal. Pasting files takes the same draft path as the picker; pasting text
|
|
/// stays with the host field, so its caret, selection and draft behave exactly
|
|
/// as typing does.
|
|
class ChatComposerBar extends StatefulWidget {
|
|
const ChatComposerBar({
|
|
super.key,
|
|
required this.composer,
|
|
required this.running,
|
|
this.picker,
|
|
this.commands,
|
|
this.paste,
|
|
});
|
|
|
|
final ChatComposerController composer;
|
|
|
|
/// Runs `/new`, `/close` and `/rename` for the open session. A host without a
|
|
/// session (null) keeps those commands on the unavailable report.
|
|
final ChatCommandActions? commands;
|
|
|
|
/// The thread controller's running bit; it alone decides Send versus Stop.
|
|
final bool running;
|
|
|
|
/// The host picker seam; production uses [hostChatAttachmentPicker].
|
|
final ChatAttachmentPicker? picker;
|
|
|
|
/// The host clipboard-file seam; production uses [hostChatClipboardPaste].
|
|
final ChatClipboardPaste? paste;
|
|
|
|
@override
|
|
State<ChatComposerBar> createState() => _ChatComposerBarState();
|
|
}
|
|
|
|
class _ChatComposerBarState extends State<ChatComposerBar> {
|
|
late final TextEditingController _text = TextEditingController(
|
|
text: widget.composer.draft,
|
|
);
|
|
final FocusNode _focus = FocusNode(debugLabel: 'chat-composer');
|
|
final ChatAttachmentDraft _attachments = ChatAttachmentDraft();
|
|
|
|
/// The picked bytes behind each chip, positionally aligned with the draft's
|
|
/// attachments so two picks of the same name stay distinct.
|
|
final List<Uint8List> _bytes = [];
|
|
String? _attachmentError;
|
|
|
|
/// True while the draft's files upload ahead of the prompt.
|
|
bool _uploading = false;
|
|
|
|
/// Upload names by attachment instance, so a retried send reuses the files
|
|
/// already stored instead of uploading them again.
|
|
final Expando<String> _uploaded = Expando();
|
|
|
|
/// The draft text whose palette the operator closed (Escape) or completed
|
|
/// (a row or Enter). The palette stays hidden while the draft still equals
|
|
/// it, so any further typing offers the commands again.
|
|
String? _paletteClosedFor;
|
|
|
|
/// The highlighted command row, wrapped to the filtered list on each build.
|
|
int _selectedCommand = 0;
|
|
|
|
/// The local no-send report shown under the field. Every slash draft takes
|
|
/// this path instead of the prompt, as the web client records: an unknown
|
|
/// command carries [_commandOffer] back for an explicit "Send as message".
|
|
String? _commandNotice;
|
|
String? _commandOffer;
|
|
bool _commandFailed = false;
|
|
|
|
ChatAttachmentPicker get _picker => widget.picker ?? hostChatAttachmentPicker;
|
|
ChatClipboardPaste get _paste => widget.paste ?? hostChatClipboardPaste;
|
|
|
|
ChatPasteUnsubscribe? _stopPaste;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
widget.composer.addListener(_syncDraft);
|
|
_listenForPaste();
|
|
unawaited(widget.composer.loadDraft());
|
|
}
|
|
|
|
@override
|
|
void didUpdateWidget(covariant ChatComposerBar oldWidget) {
|
|
super.didUpdateWidget(oldWidget);
|
|
if (oldWidget.composer != widget.composer) {
|
|
oldWidget.composer.removeListener(_syncDraft);
|
|
widget.composer.addListener(_syncDraft);
|
|
_syncDraft();
|
|
}
|
|
if (oldWidget.paste != widget.paste) {
|
|
_stopListeningForPaste();
|
|
_listenForPaste();
|
|
}
|
|
}
|
|
|
|
void _listenForPaste() {
|
|
if (!_paste.isSupported) return;
|
|
_stopPaste = _paste.listen(
|
|
onFiles: _onPastedFiles,
|
|
canAccept: _canAcceptPaste,
|
|
onError: _onPasteError,
|
|
);
|
|
}
|
|
|
|
void _stopListeningForPaste() {
|
|
final stop = _stopPaste;
|
|
_stopPaste = null;
|
|
stop?.call();
|
|
}
|
|
|
|
/// A pasted file is taken only while this composer owns the field and no
|
|
/// prompt is in flight, which is the same window as the attach control. The
|
|
/// host checks this before it suppresses the paste's default behaviour, so a
|
|
/// paste elsewhere is never swallowed.
|
|
bool _canAcceptPaste() =>
|
|
mounted && _focus.hasFocus && !widget.composer.sending;
|
|
|
|
void _onPastedFiles(List<ChatPickedFile> files) {
|
|
if (!mounted) return;
|
|
_addFiles(files);
|
|
}
|
|
|
|
void _onPasteError(Object error) {
|
|
if (!mounted) return;
|
|
setState(() => _attachmentError = '$error');
|
|
}
|
|
|
|
/// External draft changes (saved-draft load, send clear, refusal restore)
|
|
/// replace the field's text but never the focus node, so the caret survives
|
|
/// live transcript rebuilds.
|
|
void _syncDraft() {
|
|
if (!mounted) return;
|
|
final draft = widget.composer.draft;
|
|
if (_text.text == draft) return;
|
|
_text.value = TextEditingValue(
|
|
text: draft,
|
|
selection: TextSelection.collapsed(offset: draft.length),
|
|
);
|
|
}
|
|
|
|
/// The recorded commands matching the current draft while the palette is
|
|
/// open. A dismissed or completed draft keeps its palette closed until the
|
|
/// operator types something newer.
|
|
List<ChatCommand> _paletteCommands() {
|
|
final draft = widget.composer.draft;
|
|
if (_paletteClosedFor == draft) return const <ChatCommand>[];
|
|
return chatCommandSuggestions(draft);
|
|
}
|
|
|
|
/// Mirrors the typed text into the composer after clearing the per-keystroke
|
|
/// command state: a fresh edit reopens a dismissed palette, hides an old
|
|
/// report, and resets the highlight when the filtered list no longer holds it
|
|
/// (the web client's `refreshComposerControls`).
|
|
void _onDraftEdited(String value) {
|
|
final suggestions = chatCommandSuggestions(value);
|
|
setState(() {
|
|
_paletteClosedFor = null;
|
|
_dismissCommandReport();
|
|
if (_selectedCommand >= suggestions.length) _selectedCommand = 0;
|
|
});
|
|
unawaited(widget.composer.setDraft(value));
|
|
}
|
|
|
|
KeyEventResult _onKey(FocusNode node, KeyEvent event) {
|
|
final key = event.logicalKey;
|
|
final commands = _paletteCommands();
|
|
final word = chatCommandWord(widget.composer.draft);
|
|
final slashDraft = word != null;
|
|
if (key == LogicalKeyboardKey.escape) {
|
|
if (commands.isEmpty && _commandNotice == null) {
|
|
return KeyEventResult.ignored;
|
|
}
|
|
if (event is KeyDownEvent) {
|
|
setState(() {
|
|
if (commands.isNotEmpty) _paletteClosedFor = widget.composer.draft;
|
|
_dismissCommandReport();
|
|
});
|
|
}
|
|
return KeyEventResult.handled;
|
|
}
|
|
if (commands.isNotEmpty &&
|
|
(key == LogicalKeyboardKey.arrowDown ||
|
|
key == LogicalKeyboardKey.arrowUp)) {
|
|
if (event is! KeyDownEvent) return KeyEventResult.handled;
|
|
final step = key == LogicalKeyboardKey.arrowDown ? 1 : -1;
|
|
final selected = _selectedCommand % commands.length;
|
|
setState(() => _selectedCommand = (selected + step) % commands.length);
|
|
return KeyEventResult.handled;
|
|
}
|
|
if (key != LogicalKeyboardKey.enter &&
|
|
key != LogicalKeyboardKey.numpadEnter) {
|
|
return KeyEventResult.ignored;
|
|
}
|
|
final keyboard = HardwareKeyboard.instance;
|
|
final sendShortcut = keyboard.isControlPressed || keyboard.isMetaPressed;
|
|
// A plain Enter accepts the highlighted command instead of sending it. With
|
|
// no palette showing, a slash draft is still a command, never a prompt.
|
|
if (!sendShortcut && !keyboard.isShiftPressed) {
|
|
if (commands.isNotEmpty) {
|
|
if (event is! KeyDownEvent) return KeyEventResult.handled;
|
|
_completeCommand(commands[_selectedCommand % commands.length]);
|
|
return KeyEventResult.handled;
|
|
}
|
|
if (slashDraft) {
|
|
if (event is! KeyDownEvent) return KeyEventResult.handled;
|
|
_runSlashDraft();
|
|
return KeyEventResult.handled;
|
|
}
|
|
}
|
|
if (!sendShortcut) return KeyEventResult.ignored;
|
|
// A held key must not post a second prompt.
|
|
if (event is! KeyDownEvent) return KeyEventResult.handled;
|
|
// Ctrl/Cmd+Enter is the same submit: a visible palette completes, and a
|
|
// slash draft reports locally. Only plain text reaches the prompt path.
|
|
if (commands.isNotEmpty) {
|
|
_completeCommand(commands[_selectedCommand % commands.length]);
|
|
return KeyEventResult.handled;
|
|
}
|
|
if (slashDraft) {
|
|
_runSlashDraft();
|
|
return KeyEventResult.handled;
|
|
}
|
|
unawaited(_send());
|
|
return KeyEventResult.handled;
|
|
}
|
|
|
|
/// Routes a slash draft locally or through the existing Stop controller path.
|
|
void _runSlashDraft() {
|
|
final draft = widget.composer.draft;
|
|
final word = chatCommandWord(draft);
|
|
if (word == null) return;
|
|
final command = chatCommandNamed(draft);
|
|
final actions = widget.commands;
|
|
if (command != null) {
|
|
final argument = chatCommandArgument(draft);
|
|
if (!command.takesArgument && argument.isNotEmpty) {
|
|
_consumeCommandDraft();
|
|
_showCommandNotice(
|
|
'${command.usage} does not take an argument.',
|
|
failed: true,
|
|
);
|
|
} else if (actions != null && ChatCommandActions.runs(command)) {
|
|
_consumeCommandDraft();
|
|
setState(_dismissCommandReport);
|
|
unawaited(actions.run(command, argument));
|
|
} else if (command.name == chatCommandStop) {
|
|
_consumeCommandDraft();
|
|
if (widget.running) {
|
|
unawaited(_stopFromCommand());
|
|
} else {
|
|
_showCommandNotice('No turn is running in this chat.', failed: true);
|
|
}
|
|
} else if (command.name == chatCommandHelp) {
|
|
_consumeCommandDraft();
|
|
_showCommandNotice(chatCommandHelpText());
|
|
} else {
|
|
_consumeCommandDraft();
|
|
_showCommandNotice(chatCommandUnavailableReport('/${command.name}'));
|
|
}
|
|
return;
|
|
}
|
|
final offer = draft.trim();
|
|
setState(() {
|
|
_commandFailed = true;
|
|
_commandOffer = offer;
|
|
_commandNotice = chatUnknownCommandReport(word);
|
|
});
|
|
_text.clear();
|
|
unawaited(widget.composer.setDraft(''));
|
|
_focus.requestFocus();
|
|
}
|
|
|
|
/// `/stop`'s accepted interrupt reports the web's line; a refusal is the
|
|
/// composer's own error.
|
|
Future<void> _stopFromCommand() async {
|
|
await widget.composer.stop();
|
|
if (!mounted || widget.composer.error != null) return;
|
|
_showCommandNotice(chatStopCommandNotice);
|
|
}
|
|
|
|
void _consumeCommandDraft() {
|
|
_text.clear();
|
|
unawaited(widget.composer.setDraft(''));
|
|
_focus.requestFocus();
|
|
}
|
|
|
|
void _showCommandNotice(String text, {bool failed = false}) {
|
|
setState(() {
|
|
_commandFailed = failed;
|
|
_commandOffer = null;
|
|
_commandNotice = text;
|
|
});
|
|
}
|
|
|
|
/// Closes whatever local command report is showing. Callers wrap this in
|
|
/// [setState]; it owns no rebuild of its own.
|
|
void _dismissCommandReport() {
|
|
_commandNotice = null;
|
|
_commandOffer = null;
|
|
_commandFailed = false;
|
|
}
|
|
|
|
/// The offer's one explicit route to the agent: take the reported draft back
|
|
/// and send it as an ordinary message. The notice is dropped first, so a
|
|
/// stale second tap sends nothing.
|
|
Future<void> _sendOffered() async {
|
|
final offer = _commandOffer;
|
|
if (offer == null) return;
|
|
setState(_dismissCommandReport);
|
|
if (offer != widget.composer.draft) {
|
|
_text.value = TextEditingValue(
|
|
text: offer,
|
|
selection: TextSelection.collapsed(offset: offer.length),
|
|
);
|
|
await widget.composer.setDraft(offer);
|
|
if (!mounted) return;
|
|
}
|
|
await _send();
|
|
}
|
|
|
|
/// Puts the chosen recorded command in the composer and closes the palette.
|
|
/// Nothing is sent to the agent: selecting a command is completion, not an
|
|
/// execution path (this slice adds the palette, not the command actions).
|
|
void _completeCommand(ChatCommand command) {
|
|
final text = '/${command.name}';
|
|
setState(() {
|
|
_paletteClosedFor = text;
|
|
_selectedCommand = 0;
|
|
_dismissCommandReport();
|
|
});
|
|
_text.value = TextEditingValue(
|
|
text: text,
|
|
selection: TextSelection.collapsed(offset: text.length),
|
|
);
|
|
unawaited(widget.composer.setDraft(text));
|
|
_focus.requestFocus();
|
|
}
|
|
|
|
/// Builds the chips' exact wire parts and hands them to the composer with the
|
|
/// draft's text and operation id. The chips stay while the prompt is in
|
|
/// flight so a refusal leaves the draft and its files together; only an
|
|
/// accepted prompt clears them.
|
|
Future<void> _send() async {
|
|
final composer = widget.composer;
|
|
if (_uploading || composer.sending || composer.draft.trim().isEmpty) {
|
|
return;
|
|
}
|
|
List<JsonMap> parts;
|
|
final endpoint = configuredGatewayEndpoint(composer.gateway);
|
|
try {
|
|
if (endpoint.isEmpty || _attachments.isEmpty) {
|
|
parts = chatAttachmentParts(_attachments, read: _readAttachment);
|
|
} else {
|
|
// Each file goes to the server as its own request first; the prompt
|
|
// then names the stored files.
|
|
setState(() {
|
|
_uploading = true;
|
|
_attachmentError = null;
|
|
});
|
|
parts = await chatAttachmentUploadParts(
|
|
_attachments,
|
|
read: _readAttachment,
|
|
upload: (attachment, bytes) async => _uploaded[attachment] ??=
|
|
await uploadChatAttachment(endpoint, attachment, bytes),
|
|
);
|
|
}
|
|
} on ChatAttachmentWireException catch (error) {
|
|
if (mounted) {
|
|
setState(() {
|
|
_uploading = false;
|
|
_attachmentError = error.message;
|
|
});
|
|
}
|
|
return;
|
|
}
|
|
if (!mounted) return;
|
|
if (_uploading) setState(() => _uploading = false);
|
|
// Keep the caret in the field while the prompt is in flight, as before.
|
|
_focus.requestFocus();
|
|
final accepted = await composer.send(attachments: parts);
|
|
if (!mounted) return;
|
|
if (accepted) {
|
|
setState(() {
|
|
_replaceAttachments(const [], const []);
|
|
_attachmentError = null;
|
|
});
|
|
}
|
|
}
|
|
|
|
/// Adds the operator's explicit selection through the host seam. A dismissed
|
|
/// picker changes nothing; a bounded draft refusal is shown in its own words
|
|
/// while every attachment already in the draft stays.
|
|
Future<void> _pickAttachments() async {
|
|
if (widget.composer.sending || !_picker.isSupported) return;
|
|
List<ChatPickedFile>? files;
|
|
try {
|
|
files = await _picker.pick();
|
|
} catch (error) {
|
|
if (!mounted) return;
|
|
setState(() => _attachmentError = '$error');
|
|
return;
|
|
}
|
|
if (!mounted || files == null) return;
|
|
_addFiles(files);
|
|
}
|
|
|
|
/// Adds each file through the landed attachment draft. A refusal keeps every
|
|
/// attachment already in the draft and shows the draft's own words; the
|
|
/// refused file's bytes are never retained. Picking and pasting share this
|
|
/// path so both apply the same name and size decisions.
|
|
void _addFiles(List<ChatPickedFile> files) {
|
|
if (!mounted) return;
|
|
setState(() {
|
|
_attachmentError = null;
|
|
for (final file in files) {
|
|
final refusal = _attachments.add(file.attachment);
|
|
if (refusal != null) {
|
|
_attachmentError = refusal.message;
|
|
} else {
|
|
_bytes.add(file.bytes);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/// The picked bytes for the draft's own attachment instance. Identity is the
|
|
/// only reliable match when two picks share a name, type and size.
|
|
Uint8List? _readAttachment(ChatAttachment attachment) {
|
|
final attachments = _attachments.attachments;
|
|
for (var index = 0; index < attachments.length; index += 1) {
|
|
if (identical(attachments[index], attachment)) return _bytes[index];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
void _removeAttachmentAt(int index) {
|
|
setState(() {
|
|
final remaining = List<ChatAttachment>.from(_attachments.attachments)
|
|
..removeAt(index);
|
|
final remainingBytes = List<Uint8List>.from(_bytes)..removeAt(index);
|
|
_replaceAttachments(remaining, remainingBytes);
|
|
_attachmentError = null;
|
|
});
|
|
}
|
|
|
|
/// Rebuilds the draft and its aligned bytes in [attachments] order. The draft
|
|
/// owns the count and size bounds, and every kept attachment already passed
|
|
/// them, so re-adding never refuses.
|
|
void _replaceAttachments(
|
|
List<ChatAttachment> attachments,
|
|
List<Uint8List> bytes,
|
|
) {
|
|
for (final attachment in _attachments.attachments) {
|
|
_attachments.remove(attachment);
|
|
}
|
|
_bytes
|
|
..clear()
|
|
..addAll(bytes);
|
|
for (final attachment in attachments) {
|
|
_attachments.add(attachment);
|
|
}
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_stopListeningForPaste();
|
|
widget.composer.removeListener(_syncDraft);
|
|
_text.dispose();
|
|
_focus.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final cupertino =
|
|
chatControlsStyleOf(context) == ChatControlsStyle.cupertino;
|
|
return ListenableBuilder(
|
|
listenable: widget.composer,
|
|
builder: (context, _) {
|
|
final composer = widget.composer;
|
|
final error = composer.error ?? composer.draftError;
|
|
final commands = _paletteCommands();
|
|
final selected = commands.isEmpty
|
|
? 0
|
|
: _selectedCommand % commands.length;
|
|
return SafeArea(
|
|
top: false,
|
|
child: Padding(
|
|
key: const Key('chat-composer'),
|
|
padding: const EdgeInsetsDirectional.fromSTEB(16, 8, 16, 8),
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
if (commands.isNotEmpty)
|
|
Padding(
|
|
padding: const EdgeInsetsDirectional.only(bottom: 8),
|
|
child: ChatCommandPalette(
|
|
commands: commands,
|
|
selectedIndex: selected,
|
|
onSelected: _completeCommand,
|
|
),
|
|
),
|
|
if (!_attachments.isEmpty) _attachmentStrip(context, cupertino),
|
|
if (_uploading)
|
|
_notice(
|
|
context,
|
|
cupertino,
|
|
key: const Key('chat-composer-uploading'),
|
|
text: _attachments.attachments.length == 1
|
|
? 'Uploading 1 file…'
|
|
: 'Uploading ${_attachments.attachments.length} files…',
|
|
),
|
|
if (_attachmentError != null)
|
|
_notice(
|
|
context,
|
|
cupertino,
|
|
key: const Key('chat-composer-attachment-error'),
|
|
text: _attachmentError!,
|
|
failed: true,
|
|
),
|
|
if (_commandNotice != null) _commandReport(context, cupertino),
|
|
if (composer.queued)
|
|
_notice(
|
|
context,
|
|
cupertino,
|
|
key: const Key('chat-composer-queued'),
|
|
text: chatQueuedNotice,
|
|
),
|
|
if (error != null)
|
|
_notice(
|
|
context,
|
|
cupertino,
|
|
key: const Key('chat-composer-error'),
|
|
text: error,
|
|
failed: true,
|
|
),
|
|
Row(
|
|
crossAxisAlignment: CrossAxisAlignment.end,
|
|
children: [
|
|
_attach(context, cupertino),
|
|
const SizedBox(width: 8),
|
|
Expanded(
|
|
child: Focus(
|
|
canRequestFocus: false,
|
|
includeSemantics: false,
|
|
onKeyEvent: _onKey,
|
|
child: _field(cupertino),
|
|
),
|
|
),
|
|
const SizedBox(width: 8),
|
|
_primary(context, cupertino),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
},
|
|
);
|
|
}
|
|
|
|
/// The attach control: a host button that opens the picker, disabled when the
|
|
/// host has no picker or one prompt is already awaiting its reply.
|
|
Widget _attach(BuildContext context, bool cupertino) {
|
|
final enabled = _picker.isSupported && !widget.composer.sending;
|
|
final onPressed = enabled ? () => unawaited(_pickAttachments()) : null;
|
|
if (cupertino) {
|
|
return Semantics(
|
|
label: chatAttachLabel,
|
|
button: true,
|
|
enabled: enabled,
|
|
child: ExcludeSemantics(
|
|
child: CupertinoButton(
|
|
key: const Key('chat-composer-attach'),
|
|
padding: EdgeInsets.zero,
|
|
onPressed: onPressed,
|
|
child: const Icon(CupertinoIcons.paperclip),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
return IconButton(
|
|
key: const Key('chat-composer-attach'),
|
|
tooltip: chatAttachLabel,
|
|
onPressed: onPressed,
|
|
icon: const Icon(Icons.attach_file),
|
|
);
|
|
}
|
|
|
|
/// The files attached to the next message. Each chip carries only the
|
|
/// operator's recorded name and a native remove action.
|
|
Widget _attachmentStrip(BuildContext context, bool cupertino) {
|
|
final attachments = _attachments.attachments;
|
|
return Padding(
|
|
key: const Key('chat-composer-attachments'),
|
|
padding: const EdgeInsetsDirectional.only(bottom: 8),
|
|
child: Wrap(
|
|
spacing: 8,
|
|
runSpacing: 4,
|
|
children: [
|
|
for (var index = 0; index < attachments.length; index += 1)
|
|
if (_imageBytes(index) case final bytes?)
|
|
_imageThumbnail(context, attachments[index], bytes, index)
|
|
else if (cupertino)
|
|
_cupertinoChip(context, attachments[index], index)
|
|
else
|
|
_materialChip(attachments[index], index),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
/// The pasted or picked bytes of an image attachment, or null for any other
|
|
/// file.
|
|
Uint8List? _imageBytes(int index) {
|
|
final attachment = _attachments.attachments[index];
|
|
if (!attachment.mime.toLowerCase().startsWith('image/')) return null;
|
|
if (index >= _bytes.length || _bytes[index].isEmpty) return null;
|
|
return _bytes[index];
|
|
}
|
|
|
|
/// An image attachment as a small thumbnail with its remove control in the
|
|
/// corner; its name is the accessible label.
|
|
Widget _imageThumbnail(
|
|
BuildContext context,
|
|
ChatAttachment attachment,
|
|
Uint8List bytes,
|
|
int index,
|
|
) {
|
|
final cupertino =
|
|
chatControlsStyleOf(context) == ChatControlsStyle.cupertino;
|
|
return Semantics(
|
|
key: ValueKey<String>('chat-composer-attachment-$index'),
|
|
container: true,
|
|
explicitChildNodes: true,
|
|
label: attachment.name,
|
|
image: true,
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
SizedBox.square(
|
|
dimension: 72,
|
|
child: Stack(
|
|
clipBehavior: Clip.none,
|
|
children: [
|
|
Positioned.fill(
|
|
child: ClipRRect(
|
|
borderRadius: BorderRadius.circular(10),
|
|
child: Image.memory(
|
|
bytes,
|
|
key: ValueKey<String>('chat-composer-thumbnail-$index'),
|
|
fit: BoxFit.cover,
|
|
errorBuilder: (_, _, _) => Center(
|
|
child: Icon(
|
|
cupertino
|
|
? CupertinoIcons.photo
|
|
: Icons.image_outlined,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
Positioned(
|
|
top: -6,
|
|
right: -6,
|
|
child: Semantics(
|
|
button: true,
|
|
label: 'Remove ${attachment.name}',
|
|
onTap: () => _removeAttachmentAt(index),
|
|
child: ExcludeSemantics(
|
|
child: GestureDetector(
|
|
key: ValueKey<String>(
|
|
'chat-composer-attachment-remove-$index',
|
|
),
|
|
onTap: () => _removeAttachmentAt(index),
|
|
child: Container(
|
|
decoration: const BoxDecoration(
|
|
color: Color(0xCC000000),
|
|
shape: BoxShape.circle,
|
|
),
|
|
padding: const EdgeInsets.all(2),
|
|
child: Icon(
|
|
cupertino ? CupertinoIcons.xmark : Icons.close,
|
|
size: 14,
|
|
color: const Color(0xFFFFFFFF),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
// The name under the picture, one line.
|
|
SizedBox(
|
|
width: 72,
|
|
child: Text(
|
|
attachment.name,
|
|
maxLines: 1,
|
|
overflow: TextOverflow.ellipsis,
|
|
textAlign: TextAlign.center,
|
|
style: const TextStyle(fontSize: 11),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _materialChip(ChatAttachment attachment, int index) => Chip(
|
|
key: ValueKey<String>('chat-composer-attachment-$index'),
|
|
label: Text(attachment.name),
|
|
onDeleted: () => _removeAttachmentAt(index),
|
|
deleteButtonTooltipMessage: 'Remove ${attachment.name}',
|
|
);
|
|
|
|
/// Cupertino has no chip control, so the host's capsule fill and its own
|
|
/// button carry the same name and remove action.
|
|
Widget _cupertinoChip(
|
|
BuildContext context,
|
|
ChatAttachment attachment,
|
|
int index,
|
|
) {
|
|
return Semantics(
|
|
container: true,
|
|
explicitChildNodes: true,
|
|
child: DefaultTextStyle.merge(
|
|
style: CupertinoTheme.of(context).textTheme.textStyle,
|
|
child: DecoratedBox(
|
|
key: ValueKey<String>('chat-composer-attachment-$index'),
|
|
decoration: ShapeDecoration(
|
|
shape: const StadiumBorder(),
|
|
color: CupertinoColors.secondarySystemFill.resolveFrom(context),
|
|
),
|
|
child: Padding(
|
|
padding: const EdgeInsetsDirectional.fromSTEB(12, 4, 4, 4),
|
|
child: Row(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
Flexible(
|
|
child: Text(attachment.name, overflow: TextOverflow.ellipsis),
|
|
),
|
|
const SizedBox(width: 4),
|
|
Semantics(
|
|
container: true,
|
|
button: true,
|
|
label: 'Remove ${attachment.name}',
|
|
onTap: () => _removeAttachmentAt(index),
|
|
child: ExcludeSemantics(
|
|
child: CupertinoButton(
|
|
key: ValueKey<String>(
|
|
'chat-composer-attachment-remove-$index',
|
|
),
|
|
padding: EdgeInsets.zero,
|
|
onPressed: () => _removeAttachmentAt(index),
|
|
child: Icon(
|
|
CupertinoIcons.xmark_circle_fill,
|
|
color: CupertinoColors.secondaryLabel.resolveFrom(
|
|
context,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
/// The lines the composer placeholder needs at [width] (the field's
|
|
/// default 7px side padding excluded), capped at 3.
|
|
int _placeholderLines(BuildContext context, double width) {
|
|
if (!width.isFinite) return 1;
|
|
final painter = TextPainter(
|
|
text: TextSpan(
|
|
text: chatComposerPlaceholder,
|
|
style: CupertinoTheme.of(context).textTheme.textStyle,
|
|
),
|
|
textDirection: Directionality.of(context),
|
|
textScaler: MediaQuery.textScalerOf(context),
|
|
maxLines: 3,
|
|
)..layout(maxWidth: math.max(0, width - 14));
|
|
final lines = painter.computeLineMetrics().length;
|
|
painter.dispose();
|
|
return lines.clamp(1, 3);
|
|
}
|
|
|
|
Widget _field(bool cupertino) {
|
|
if (cupertino) {
|
|
// CupertinoTextField lays its placeholder out with up to maxLines lines
|
|
// but sizes an empty field by minLines, so a wrapped placeholder was
|
|
// clipped on a narrow pane. While empty the field is exactly as tall as
|
|
// its placeholder (at most 3 lines, then ellipsised); typing restores
|
|
// the normal 1-6 lines.
|
|
return LayoutBuilder(
|
|
builder: (context, constraints) {
|
|
final empty = _text.text.isEmpty;
|
|
final lines = empty
|
|
? _placeholderLines(context, constraints.maxWidth)
|
|
: 1;
|
|
return CupertinoTextField(
|
|
key: const Key('chat-composer-field'),
|
|
controller: _text,
|
|
focusNode: _focus,
|
|
placeholder: chatComposerPlaceholder,
|
|
placeholderStyle: const TextStyle(
|
|
color: CupertinoColors.placeholderText,
|
|
overflow: TextOverflow.ellipsis,
|
|
),
|
|
minLines: lines,
|
|
maxLines: empty ? lines : 6,
|
|
keyboardType: TextInputType.multiline,
|
|
textInputAction: TextInputAction.newline,
|
|
onChanged: _onDraftEdited,
|
|
);
|
|
},
|
|
);
|
|
}
|
|
return TextField(
|
|
key: const Key('chat-composer-field'),
|
|
controller: _text,
|
|
focusNode: _focus,
|
|
minLines: 1,
|
|
maxLines: 6,
|
|
keyboardType: TextInputType.multiline,
|
|
textInputAction: TextInputAction.newline,
|
|
onChanged: _onDraftEdited,
|
|
decoration: const InputDecoration(
|
|
hintText: chatComposerPlaceholder,
|
|
// Let the complete, web-matched hint wrap when the attachment and
|
|
// primary controls leave little horizontal room.
|
|
hintMaxLines: 2,
|
|
border: OutlineInputBorder(),
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _primary(BuildContext context, bool cupertino) {
|
|
final composer = widget.composer;
|
|
final stop = widget.running;
|
|
final enabled = stop
|
|
? !composer.stopping
|
|
: !_uploading && !composer.sending && composer.draft.trim().isNotEmpty;
|
|
void press() {
|
|
if (stop) {
|
|
unawaited(composer.stop());
|
|
return;
|
|
}
|
|
final commands = _paletteCommands();
|
|
if (commands.isNotEmpty) {
|
|
_completeCommand(commands[_selectedCommand % commands.length]);
|
|
} else if (chatCommandWord(composer.draft) != null) {
|
|
_runSlashDraft();
|
|
} else {
|
|
unawaited(_send());
|
|
}
|
|
}
|
|
|
|
// One icon control, named Send or Stop for assistive technology: a send
|
|
// arrow, or a stop square in the error colour while a turn runs.
|
|
final label = stop ? chatStopLabel : chatSendLabel;
|
|
if (cupertino) {
|
|
return Semantics(
|
|
button: true,
|
|
label: label,
|
|
excludeSemantics: true,
|
|
child: CupertinoButton.filled(
|
|
key: const Key('chat-composer-primary'),
|
|
sizeStyle: CupertinoButtonSize.small,
|
|
color: stop ? CupertinoColors.systemRed.resolveFrom(context) : null,
|
|
onPressed: enabled ? press : null,
|
|
child: Icon(
|
|
stop ? CupertinoIcons.stop_fill : CupertinoIcons.arrow_up,
|
|
size: 18,
|
|
),
|
|
),
|
|
);
|
|
}
|
|
final scheme = Theme.of(context).colorScheme;
|
|
return IconButton.filled(
|
|
key: const Key('chat-composer-primary'),
|
|
tooltip: label,
|
|
style: stop
|
|
? IconButton.styleFrom(
|
|
backgroundColor: scheme.error,
|
|
foregroundColor: scheme.onError,
|
|
)
|
|
: null,
|
|
onPressed: enabled ? press : null,
|
|
icon: Icon(stop ? Icons.stop : Icons.send),
|
|
);
|
|
}
|
|
|
|
/// The local command report: a failed line in the composer's own notice
|
|
/// shape, plus the offer's two host controls when an unknown command can be
|
|
/// sent as a message. Neither action is a prompt until the operator chooses
|
|
/// "Send as message".
|
|
Widget _commandReport(BuildContext context, bool cupertino) {
|
|
final offer = _commandOffer;
|
|
return Column(
|
|
key: const Key('chat-composer-command-notice'),
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: Text(
|
|
_commandFailed
|
|
? chatCommandFailedLabel
|
|
: chatCommandNoticeLabel,
|
|
style: TextStyle(
|
|
color: _commandFailed
|
|
? (cupertino
|
|
? CupertinoColors.systemRed.resolveFrom(context)
|
|
: Theme.of(context).colorScheme.error)
|
|
: null,
|
|
),
|
|
),
|
|
),
|
|
if (cupertino)
|
|
Semantics(
|
|
button: true,
|
|
label: chatCommandDismissLabel,
|
|
child: CupertinoButton(
|
|
key: const Key('chat-command-dismiss'),
|
|
padding: EdgeInsets.zero,
|
|
onPressed: () => setState(_dismissCommandReport),
|
|
child: const Text('Dismiss'),
|
|
),
|
|
)
|
|
else
|
|
IconButton(
|
|
key: const Key('chat-command-dismiss'),
|
|
tooltip: chatCommandDismissLabel,
|
|
onPressed: () => setState(_dismissCommandReport),
|
|
icon: const Icon(Icons.close),
|
|
),
|
|
],
|
|
),
|
|
_notice(
|
|
context,
|
|
cupertino,
|
|
key: const Key('chat-composer-command-text'),
|
|
text: _commandNotice!,
|
|
failed: _commandFailed,
|
|
),
|
|
if (offer != null)
|
|
Padding(
|
|
padding: const EdgeInsetsDirectional.only(bottom: 8),
|
|
child: Wrap(
|
|
alignment: WrapAlignment.end,
|
|
spacing: 8,
|
|
runSpacing: 4,
|
|
children: [
|
|
_commandAction(
|
|
cupertino,
|
|
key: const Key('chat-command-send-as-message'),
|
|
label: chatCommandSendAsMessageLabel,
|
|
onPressed: () => unawaited(_sendOffered()),
|
|
),
|
|
_commandAction(
|
|
cupertino,
|
|
key: const Key('chat-command-cancel'),
|
|
label: chatCommandCancelLabel,
|
|
onPressed: () => setState(_dismissCommandReport),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
Widget _commandAction(
|
|
bool cupertino, {
|
|
required Key key,
|
|
required String label,
|
|
required VoidCallback onPressed,
|
|
}) {
|
|
if (cupertino) {
|
|
return CupertinoButton(
|
|
key: key,
|
|
padding: EdgeInsets.zero,
|
|
onPressed: onPressed,
|
|
child: Text(label),
|
|
);
|
|
}
|
|
return TextButton(key: key, onPressed: onPressed, child: Text(label));
|
|
}
|
|
|
|
/// A polite, secondary line for queued/refused state. The error uses the
|
|
/// host's own semantic error tint, never a bespoke palette.
|
|
Widget _notice(
|
|
BuildContext context,
|
|
bool cupertino, {
|
|
required Key key,
|
|
required String text,
|
|
bool failed = false,
|
|
}) {
|
|
final theme = Theme.of(context);
|
|
final color = failed
|
|
? (cupertino
|
|
? CupertinoColors.systemRed.resolveFrom(context)
|
|
: theme.colorScheme.error)
|
|
: (cupertino
|
|
? CupertinoColors.secondaryLabel.resolveFrom(context)
|
|
: theme.colorScheme.onSurfaceVariant);
|
|
final style =
|
|
(cupertino
|
|
? CupertinoTheme.of(context).textTheme.textStyle
|
|
: theme.textTheme.bodyMedium)
|
|
?.copyWith(color: color);
|
|
return Semantics(
|
|
liveRegion: true,
|
|
child: Padding(
|
|
key: key,
|
|
padding: const EdgeInsets.only(bottom: 8),
|
|
child: Text(text, style: style),
|
|
),
|
|
);
|
|
}
|
|
}
|