Files
pipelines/app/lib/features/chat/conversation/chat_composer_bar.dart
T

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),
),
);
}
}