268 lines
8.2 KiB
Dart
268 lines
8.2 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:flutter/cupertino.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter/services.dart';
|
|
|
|
import '../ui/sessions/chat_adaptive.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';
|
|
|
|
/// 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. Attachments and the slash palette are not part of
|
|
/// this slice.
|
|
class ChatComposerBar extends StatefulWidget {
|
|
const ChatComposerBar({
|
|
super.key,
|
|
required this.composer,
|
|
required this.running,
|
|
});
|
|
|
|
final ChatComposerController composer;
|
|
|
|
/// The thread controller's running bit; it alone decides Send versus Stop.
|
|
final bool running;
|
|
|
|
@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');
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
widget.composer.addListener(_syncDraft);
|
|
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();
|
|
}
|
|
}
|
|
|
|
/// 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),
|
|
);
|
|
}
|
|
|
|
KeyEventResult _onKey(FocusNode node, KeyEvent event) {
|
|
if (event.logicalKey != LogicalKeyboardKey.enter &&
|
|
event.logicalKey != LogicalKeyboardKey.numpadEnter) {
|
|
return KeyEventResult.ignored;
|
|
}
|
|
final keyboard = HardwareKeyboard.instance;
|
|
if (!keyboard.isControlPressed && !keyboard.isMetaPressed) {
|
|
return KeyEventResult.ignored;
|
|
}
|
|
// A held key must not post a second prompt.
|
|
if (event is! KeyDownEvent) return KeyEventResult.handled;
|
|
_send();
|
|
return KeyEventResult.handled;
|
|
}
|
|
|
|
void _send() {
|
|
final composer = widget.composer;
|
|
if (composer.sending || composer.draft.trim().isEmpty) return;
|
|
unawaited(composer.send());
|
|
_focus.requestFocus();
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
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;
|
|
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 (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: [
|
|
Expanded(
|
|
child: Focus(
|
|
canRequestFocus: false,
|
|
includeSemantics: false,
|
|
onKeyEvent: _onKey,
|
|
child: _field(cupertino),
|
|
),
|
|
),
|
|
const SizedBox(width: 8),
|
|
_primary(context, cupertino),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
},
|
|
);
|
|
}
|
|
|
|
Widget _field(bool cupertino) {
|
|
final composer = widget.composer;
|
|
void changed(String value) => unawaited(composer.setDraft(value));
|
|
if (cupertino) {
|
|
return CupertinoTextField(
|
|
key: const Key('chat-composer-field'),
|
|
controller: _text,
|
|
focusNode: _focus,
|
|
placeholder: chatComposerPlaceholder,
|
|
minLines: 1,
|
|
maxLines: 6,
|
|
keyboardType: TextInputType.multiline,
|
|
textInputAction: TextInputAction.newline,
|
|
onChanged: changed,
|
|
);
|
|
}
|
|
return TextField(
|
|
key: const Key('chat-composer-field'),
|
|
controller: _text,
|
|
focusNode: _focus,
|
|
minLines: 1,
|
|
maxLines: 6,
|
|
keyboardType: TextInputType.multiline,
|
|
textInputAction: TextInputAction.newline,
|
|
onChanged: changed,
|
|
decoration: const InputDecoration(
|
|
hintText: chatComposerPlaceholder,
|
|
border: OutlineInputBorder(),
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _primary(BuildContext context, bool cupertino) {
|
|
final composer = widget.composer;
|
|
final stop = widget.running;
|
|
final enabled = stop
|
|
? !composer.stopping
|
|
: !composer.sending && composer.draft.trim().isNotEmpty;
|
|
void press() {
|
|
if (stop) {
|
|
unawaited(composer.stop());
|
|
} else {
|
|
_send();
|
|
}
|
|
}
|
|
|
|
final label = Text(stop ? chatStopLabel : chatSendLabel);
|
|
if (cupertino) {
|
|
return CupertinoButton(
|
|
key: const Key('chat-composer-primary'),
|
|
color: stop ? CupertinoColors.systemRed.resolveFrom(context) : null,
|
|
onPressed: enabled ? press : null,
|
|
child: label,
|
|
);
|
|
}
|
|
final scheme = Theme.of(context).colorScheme;
|
|
return FilledButton(
|
|
key: const Key('chat-composer-primary'),
|
|
style: stop
|
|
? FilledButton.styleFrom(
|
|
backgroundColor: scheme.error,
|
|
foregroundColor: scheme.onError,
|
|
)
|
|
: null,
|
|
onPressed: enabled ? press : null,
|
|
child: 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),
|
|
),
|
|
);
|
|
}
|
|
}
|