mirror of
https://github.com/openai/codex.git
synced 2026-10-28 18:58:46 +00:00
Charlie Marsh
a0bed4be21
## Why Configuration and app-server initialization can take time before the main TUI is ready, leaving users unable to begin drafting a prompt. ## What changed - Show a provisional composer while startup work runs and carry its text, cursor position, paste state, and attachments into the initialized chat. - Limit the provisional composer to safe editing and cancellation, and quarantine input around session pickers, approvals, and other actionable startup screens. - Preserve configuration validation before terminal checks and recover terminal state cleanly from startup failures and caught panics. ## Testing - Cover startup editing, multiline and large pastes, keymaps, cancellation, session-picker handoff, approval boundaries, and draft restoration. - Verify non-interactive launches report configuration errors before terminal errors. GitOrigin-RevId: fe04a85cfbbcff21ff87fa81fd17474827858575
579 lines
24 KiB
Rust
579 lines
24 KiB
Rust
//! Input queue restore and thread-input snapshot behavior for `ChatWidget`.
|
|
|
|
use std::collections::HashSet;
|
|
use std::collections::VecDeque;
|
|
|
|
use crate::bottom_pane::ComposerDraftSnapshot;
|
|
|
|
use super::user_messages::remap_colliding_paste_placeholders;
|
|
use super::*;
|
|
|
|
impl ChatWidget {
|
|
/// Restore the exact draft entered before the fully initialized composer became available.
|
|
pub(crate) fn restore_startup_draft(&mut self, draft: ComposerDraftSnapshot) {
|
|
let existing_draft = self.bottom_pane.composer_draft_snapshot();
|
|
let existing_cursor = existing_draft.cursor;
|
|
let existing_message = UserMessage {
|
|
text: existing_draft.text,
|
|
text_elements: existing_draft.text_elements,
|
|
local_images: existing_draft.local_images,
|
|
remote_image_urls: existing_draft.remote_image_urls,
|
|
mention_bindings: existing_draft.mention_bindings,
|
|
};
|
|
let existing_has_content =
|
|
!self.bottom_pane.composer_is_empty() || !existing_draft.pending_pastes.is_empty();
|
|
|
|
let startup_message = UserMessage {
|
|
text: draft.text,
|
|
text_elements: draft.text_elements,
|
|
local_images: draft.local_images,
|
|
remote_image_urls: draft.remote_image_urls,
|
|
mention_bindings: draft.mention_bindings,
|
|
};
|
|
let startup_has_content = !startup_message.text.is_empty()
|
|
|| !startup_message.local_images.is_empty()
|
|
|| !startup_message.remote_image_urls.is_empty()
|
|
|| !draft.pending_pastes.is_empty();
|
|
|
|
let cursor = if existing_has_content && startup_has_content {
|
|
let mut used_paste_placeholders = HashSet::new();
|
|
let (existing_message, mut pending_pastes) = remap_colliding_paste_placeholders(
|
|
existing_message,
|
|
existing_draft.pending_pastes,
|
|
&mut used_paste_placeholders,
|
|
);
|
|
let startup_offset = existing_message.text.len().saturating_add(1);
|
|
let preceding_text_element = startup_message
|
|
.text_elements
|
|
.iter()
|
|
.enumerate()
|
|
.take_while(|(_, element)| element.byte_range.end <= draft.cursor)
|
|
.last()
|
|
.map(|(index, element)| (index, element.byte_range.end));
|
|
let (startup_message, startup_pending_pastes) = remap_colliding_paste_placeholders(
|
|
startup_message,
|
|
draft.pending_pastes,
|
|
&mut used_paste_placeholders,
|
|
);
|
|
let cursor_adjustment = preceding_text_element.map_or(0, |(index, original_end)| {
|
|
startup_message.text_elements[index]
|
|
.byte_range
|
|
.end
|
|
.saturating_sub(original_end)
|
|
});
|
|
pending_pastes.extend(startup_pending_pastes);
|
|
self.restore_composer_state(Self::composer_state_from_user_message(
|
|
merge_user_messages(vec![existing_message, startup_message]),
|
|
pending_pastes,
|
|
));
|
|
startup_offset
|
|
.saturating_add(draft.cursor)
|
|
.saturating_add(cursor_adjustment)
|
|
} else if existing_has_content {
|
|
existing_cursor
|
|
} else {
|
|
self.restore_composer_state(Self::composer_state_from_user_message(
|
|
startup_message,
|
|
draft.pending_pastes,
|
|
));
|
|
draft.cursor
|
|
};
|
|
self.bottom_pane.set_composer_cursor(cursor);
|
|
self.bottom_pane.restore_startup_composer_state(
|
|
draft.last_composer_activity_at,
|
|
draft.startup_local_history,
|
|
);
|
|
if startup_has_content && self.config.tui_vim_mode_default {
|
|
self.bottom_pane.enable_vim_in_insert_mode();
|
|
}
|
|
}
|
|
|
|
/// Includes protected prompts deferred by streaming or the approval idle timer.
|
|
pub(crate) fn has_pending_protected_request(&self) -> bool {
|
|
self.bottom_pane.has_pending_approval() || self.interrupts.has_pending_prompt()
|
|
}
|
|
|
|
/// Transfer startup input only after protected views and required sandbox setup finish.
|
|
pub(crate) fn restore_startup_draft_when_ready(
|
|
&mut self,
|
|
pending_draft: &mut Option<ComposerDraftSnapshot>,
|
|
) {
|
|
if self.has_active_view()
|
|
|| self.has_pending_protected_request()
|
|
|| !self.bottom_pane.composer_input_enabled()
|
|
{
|
|
return;
|
|
}
|
|
#[cfg(any(target_os = "windows", test))]
|
|
if self.elevated_windows_sandbox_setup_required() {
|
|
return;
|
|
}
|
|
if let Some(draft) = pending_draft.take() {
|
|
self.restore_startup_draft(draft);
|
|
}
|
|
}
|
|
|
|
pub(crate) fn set_initial_user_message_submit_suppressed(&mut self, suppressed: bool) {
|
|
self.suppress_initial_user_message_submit = suppressed;
|
|
}
|
|
|
|
pub(crate) fn submit_initial_user_message_if_pending(&mut self) {
|
|
if self.suppress_initial_user_message_submit {
|
|
return;
|
|
}
|
|
#[cfg(any(target_os = "windows", test))]
|
|
if self.elevated_windows_sandbox_setup_required() {
|
|
return;
|
|
}
|
|
if self.blocks_direct_input {
|
|
if let Some(user_message) = self.initial_user_message.take() {
|
|
self.restore_user_message_to_composer(user_message);
|
|
}
|
|
return;
|
|
}
|
|
if let Some(user_message) = self.initial_user_message.take() {
|
|
self.submit_user_message(user_message);
|
|
}
|
|
}
|
|
|
|
pub(super) fn pop_next_queued_user_message(
|
|
&mut self,
|
|
) -> Option<(QueuedUserMessage, UserMessageHistoryRecord)> {
|
|
if self.input_queue.rejected_steers_queue.is_empty() {
|
|
self.input_queue
|
|
.queued_user_messages
|
|
.pop_front()
|
|
.map(|user_message| {
|
|
let history_record = self
|
|
.input_queue
|
|
.queued_user_message_history_records
|
|
.pop_front()
|
|
.unwrap_or(UserMessageHistoryRecord::UserMessageText);
|
|
(user_message, history_record)
|
|
})
|
|
} else {
|
|
let rejected_messages = self
|
|
.input_queue
|
|
.rejected_steers_queue
|
|
.drain(..)
|
|
.collect::<Vec<_>>();
|
|
let mut history_records = self
|
|
.input_queue
|
|
.rejected_steer_history_records
|
|
.drain(..)
|
|
.collect::<Vec<_>>();
|
|
history_records.resize(
|
|
rejected_messages.len(),
|
|
UserMessageHistoryRecord::UserMessageText,
|
|
);
|
|
let (message, history_record) = merge_user_messages_with_history_record(
|
|
rejected_messages
|
|
.into_iter()
|
|
.zip(history_records)
|
|
.collect::<Vec<_>>(),
|
|
);
|
|
Some((QueuedUserMessage::from(message), history_record))
|
|
}
|
|
}
|
|
|
|
pub(super) fn pop_latest_queued_composer_state(&mut self) -> Option<ThreadComposerState> {
|
|
if let Some(user_message) = self.input_queue.queued_user_messages.pop_back() {
|
|
let history_record = self
|
|
.input_queue
|
|
.queued_user_message_history_records
|
|
.pop_back()
|
|
.unwrap_or(UserMessageHistoryRecord::UserMessageText);
|
|
let QueuedUserMessage {
|
|
user_message,
|
|
pending_pastes,
|
|
..
|
|
} = user_message;
|
|
Some(Self::composer_state_from_user_message(
|
|
user_message_for_restore(user_message, &history_record),
|
|
pending_pastes,
|
|
))
|
|
} else {
|
|
let user_message = self.input_queue.rejected_steers_queue.pop_back()?;
|
|
let history_record = self
|
|
.input_queue
|
|
.rejected_steer_history_records
|
|
.pop_back()
|
|
.unwrap_or(UserMessageHistoryRecord::UserMessageText);
|
|
Some(Self::composer_state_from_user_message(
|
|
user_message_for_restore(user_message, &history_record),
|
|
Vec::new(),
|
|
))
|
|
}
|
|
}
|
|
|
|
pub(crate) fn enqueue_rejected_steer(&mut self) -> bool {
|
|
let Some(pending_steer) = self.input_queue.pending_steers.pop_front() else {
|
|
tracing::warn!(
|
|
"received active-turn-not-steerable error without a matching pending steer"
|
|
);
|
|
return false;
|
|
};
|
|
self.input_queue
|
|
.rejected_steers_queue
|
|
.push_back(pending_steer.user_message);
|
|
self.input_queue
|
|
.rejected_steer_history_records
|
|
.push_back(pending_steer.history_record);
|
|
self.refresh_pending_input_preview();
|
|
true
|
|
}
|
|
|
|
/// Handle a turn aborted due to user interrupt (Esc), budget exhaustion,
|
|
/// or review completion.
|
|
/// When there are queued user messages, restore them into the composer
|
|
/// separated by newlines rather than auto-submitting the next one.
|
|
pub(super) fn on_interrupted_turn(&mut self, reason: TurnAbortReason) {
|
|
// Finalize, log a gentle prompt, and clear running state.
|
|
self.finalize_turn();
|
|
let send_pending_steers_immediately =
|
|
self.input_queue.submit_pending_steers_after_interrupt;
|
|
self.input_queue.submit_pending_steers_after_interrupt = false;
|
|
if self.interrupted_turn_notice_mode != InterruptedTurnNoticeMode::Suppress {
|
|
if send_pending_steers_immediately {
|
|
self.add_to_history(history_cell::new_info_event(
|
|
"Model interrupted to submit steer instructions.".to_owned(),
|
|
/*hint*/ None,
|
|
));
|
|
} else {
|
|
self.add_to_history(history_cell::new_error_event(
|
|
self.interrupted_turn_message(reason),
|
|
));
|
|
}
|
|
}
|
|
|
|
// The server has already discarded pending input by the time the
|
|
// interrupted turn reaches the UI, so any unacknowledged steers still
|
|
// tracked here must be restored locally instead of waiting for a later commit.
|
|
if send_pending_steers_immediately {
|
|
let pending_steers = self
|
|
.input_queue
|
|
.pending_steers
|
|
.drain(..)
|
|
.map(|pending| (pending.user_message, pending.history_record))
|
|
.collect::<Vec<_>>();
|
|
if !pending_steers.is_empty() {
|
|
let (user_message, history_record) =
|
|
merge_user_messages_with_history_record(pending_steers);
|
|
self.submit_user_message_with_history_record(user_message, history_record);
|
|
} else if let Some(combined) = self.drain_pending_messages_for_restore() {
|
|
self.restore_composer_state(combined);
|
|
}
|
|
} else if let Some(combined) = self.drain_pending_messages_for_restore() {
|
|
self.restore_composer_state(combined);
|
|
}
|
|
self.refresh_pending_input_preview();
|
|
self.request_redraw();
|
|
}
|
|
|
|
/// Merge pending steers, queued drafts, and the current composer state into a single message.
|
|
///
|
|
/// Each pending message numbers attachments from `[Image #1]` relative to its own remote
|
|
/// images. When we concatenate multiple messages after interrupt, we must renumber local-image
|
|
/// placeholders in a stable order and rebase text element byte ranges so the restored composer
|
|
/// state stays aligned with the merged attachment list. Returns `None` when there is nothing to
|
|
/// restore.
|
|
fn drain_pending_messages_for_restore(&mut self) -> Option<ThreadComposerState> {
|
|
if self.input_queue.pending_steers.is_empty() && !self.has_queued_follow_up_messages() {
|
|
return None;
|
|
}
|
|
|
|
let composer = self.bottom_pane.composer_draft_snapshot();
|
|
let composer_pending_pastes = composer.pending_pastes;
|
|
let existing_message = UserMessage {
|
|
text: composer.text,
|
|
text_elements: composer.text_elements,
|
|
local_images: composer.local_images,
|
|
remote_image_urls: composer.remote_image_urls,
|
|
mention_bindings: composer.mention_bindings,
|
|
};
|
|
|
|
let rejected_messages = self
|
|
.input_queue
|
|
.rejected_steers_queue
|
|
.drain(..)
|
|
.collect::<Vec<_>>();
|
|
let mut rejected_history_records = self
|
|
.input_queue
|
|
.rejected_steer_history_records
|
|
.drain(..)
|
|
.collect::<Vec<_>>();
|
|
rejected_history_records.resize(
|
|
rejected_messages.len(),
|
|
UserMessageHistoryRecord::UserMessageText,
|
|
);
|
|
let mut to_merge: Vec<UserMessage> = rejected_messages
|
|
.into_iter()
|
|
.zip(rejected_history_records.iter())
|
|
.map(|(message, history_record)| user_message_for_restore(message, history_record))
|
|
.collect();
|
|
to_merge.extend(
|
|
self.input_queue
|
|
.pending_steers
|
|
.drain(..)
|
|
.map(|steer| user_message_for_restore(steer.user_message, &steer.history_record)),
|
|
);
|
|
let queued_messages = self
|
|
.input_queue
|
|
.queued_user_messages
|
|
.drain(..)
|
|
.collect::<Vec<_>>();
|
|
let mut queued_history_records = self
|
|
.input_queue
|
|
.queued_user_message_history_records
|
|
.drain(..)
|
|
.collect::<Vec<_>>();
|
|
queued_history_records.resize(
|
|
queued_messages.len(),
|
|
UserMessageHistoryRecord::UserMessageText,
|
|
);
|
|
let mut pending_pastes = Vec::new();
|
|
let mut used_paste_placeholders = HashSet::new();
|
|
for (message, history_record) in queued_messages
|
|
.into_iter()
|
|
.zip(queued_history_records.iter())
|
|
{
|
|
let (message, message_pastes) = remap_colliding_paste_placeholders(
|
|
user_message_for_restore(message.user_message, history_record),
|
|
message.pending_pastes,
|
|
&mut used_paste_placeholders,
|
|
);
|
|
pending_pastes.extend(message_pastes);
|
|
to_merge.push(message);
|
|
}
|
|
let has_existing_message = !existing_message.text.is_empty()
|
|
|| !existing_message.local_images.is_empty()
|
|
|| !existing_message.remote_image_urls.is_empty();
|
|
if has_existing_message {
|
|
let (existing_message, composer_pending_pastes) = remap_colliding_paste_placeholders(
|
|
existing_message,
|
|
composer_pending_pastes,
|
|
&mut used_paste_placeholders,
|
|
);
|
|
to_merge.push(existing_message);
|
|
pending_pastes.extend(composer_pending_pastes);
|
|
}
|
|
|
|
Some(Self::composer_state_from_user_message(
|
|
merge_user_messages(to_merge),
|
|
pending_pastes,
|
|
))
|
|
}
|
|
|
|
pub(crate) fn restore_user_message_to_composer(&mut self, user_message: UserMessage) {
|
|
let draft = self.bottom_pane.composer_draft_snapshot();
|
|
let pending_pastes = draft.pending_pastes;
|
|
let draft_message = UserMessage {
|
|
text: draft.text,
|
|
text_elements: draft.text_elements,
|
|
local_images: draft.local_images,
|
|
remote_image_urls: draft.remote_image_urls,
|
|
mention_bindings: draft.mention_bindings,
|
|
};
|
|
let mut messages = vec![user_message];
|
|
if !draft_message.text.is_empty()
|
|
|| !draft_message.local_images.is_empty()
|
|
|| !draft_message.remote_image_urls.is_empty()
|
|
{
|
|
messages.push(draft_message);
|
|
}
|
|
self.restore_composer_state(Self::composer_state_from_user_message(
|
|
merge_user_messages(messages),
|
|
pending_pastes,
|
|
));
|
|
}
|
|
|
|
pub(super) fn restore_composer_state(&mut self, composer: ThreadComposerState) {
|
|
let ThreadComposerState {
|
|
text,
|
|
local_images,
|
|
remote_image_urls,
|
|
text_elements,
|
|
mention_bindings,
|
|
pending_pastes,
|
|
} = composer;
|
|
let local_image_paths = local_images.into_iter().map(|img| img.path).collect();
|
|
self.set_remote_image_urls(remote_image_urls);
|
|
self.bottom_pane.set_composer_text_with_mention_bindings(
|
|
text,
|
|
text_elements,
|
|
local_image_paths,
|
|
mention_bindings,
|
|
);
|
|
self.bottom_pane.set_composer_pending_pastes(pending_pastes);
|
|
}
|
|
|
|
fn composer_state_from_user_message(
|
|
user_message: UserMessage,
|
|
pending_pastes: Vec<(String, String)>,
|
|
) -> ThreadComposerState {
|
|
let UserMessage {
|
|
text,
|
|
local_images,
|
|
remote_image_urls,
|
|
text_elements,
|
|
mention_bindings,
|
|
} = user_message;
|
|
ThreadComposerState {
|
|
text,
|
|
local_images,
|
|
remote_image_urls,
|
|
text_elements,
|
|
mention_bindings,
|
|
pending_pastes,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn capture_thread_input_state(&self) -> Option<ThreadInputState> {
|
|
let draft = self.bottom_pane.composer_draft_snapshot();
|
|
let composer = ThreadComposerState {
|
|
text: draft.text,
|
|
text_elements: draft.text_elements,
|
|
local_images: draft.local_images,
|
|
remote_image_urls: draft.remote_image_urls,
|
|
mention_bindings: draft.mention_bindings,
|
|
pending_pastes: draft.pending_pastes,
|
|
};
|
|
Some(ThreadInputState {
|
|
composer: composer.has_content().then_some(composer),
|
|
safety_buffering_prompt: self.safety_buffering_prompt.clone(),
|
|
pending_steers: self
|
|
.input_queue
|
|
.pending_steers
|
|
.iter()
|
|
.map(|pending| pending.user_message.clone())
|
|
.collect(),
|
|
pending_steer_history_records: self
|
|
.input_queue
|
|
.pending_steers
|
|
.iter()
|
|
.map(|pending| pending.history_record.clone())
|
|
.collect(),
|
|
pending_steer_compare_keys: self
|
|
.input_queue
|
|
.pending_steers
|
|
.iter()
|
|
.map(|pending| pending.compare_key.clone())
|
|
.collect(),
|
|
rejected_steers_queue: self.input_queue.rejected_steers_queue.clone(),
|
|
rejected_steer_history_records: self.input_queue.rejected_steer_history_records.clone(),
|
|
queued_user_messages: self.input_queue.queued_user_messages.clone(),
|
|
queued_user_message_history_records: self
|
|
.input_queue
|
|
.queued_user_message_history_records
|
|
.clone(),
|
|
user_turn_pending_start: self.input_queue.user_turn_pending_start,
|
|
submit_pending_steers_after_interrupt: self
|
|
.input_queue
|
|
.submit_pending_steers_after_interrupt,
|
|
current_collaboration_mode: self.current_collaboration_mode.clone(),
|
|
active_collaboration_mask: self.active_collaboration_mask.clone(),
|
|
task_running: self.bottom_pane.is_task_running(),
|
|
agent_turn_running: self.turn_lifecycle.agent_turn_running,
|
|
})
|
|
}
|
|
|
|
pub(crate) fn restore_thread_input_state(
|
|
&mut self,
|
|
input_state: Option<ThreadInputState>,
|
|
restore_mode: ThreadInputStateRestoreMode,
|
|
) {
|
|
let preserve_in_flight_turn = restore_mode.preserve_in_flight_turn;
|
|
let restored_task_running =
|
|
preserve_in_flight_turn && input_state.as_ref().is_some_and(|state| state.task_running);
|
|
if let Some(input_state) = input_state {
|
|
self.current_collaboration_mode = input_state.current_collaboration_mode;
|
|
self.active_collaboration_mask = input_state.active_collaboration_mask;
|
|
self.safety_buffering_prompt = input_state.safety_buffering_prompt;
|
|
self.turn_lifecycle.restore_running(
|
|
preserve_in_flight_turn && input_state.agent_turn_running,
|
|
Instant::now(),
|
|
);
|
|
self.input_queue.user_turn_pending_start =
|
|
preserve_in_flight_turn && input_state.user_turn_pending_start;
|
|
self.input_queue.submit_pending_steers_after_interrupt =
|
|
preserve_in_flight_turn && input_state.submit_pending_steers_after_interrupt;
|
|
self.update_collaboration_mode_indicator();
|
|
self.refresh_model_dependent_surfaces();
|
|
self.restore_composer_state(input_state.composer.unwrap_or_default());
|
|
let mut pending_steer_history_records = input_state.pending_steer_history_records;
|
|
pending_steer_history_records.resize(
|
|
input_state.pending_steers.len(),
|
|
UserMessageHistoryRecord::UserMessageText,
|
|
);
|
|
let mut pending_steer_compare_keys = input_state.pending_steer_compare_keys;
|
|
let pending_steers = input_state.pending_steers;
|
|
let mut queued_user_messages = input_state.queued_user_messages;
|
|
let mut queued_user_message_history_records =
|
|
input_state.queued_user_message_history_records;
|
|
if preserve_in_flight_turn {
|
|
self.input_queue.pending_steers = pending_steers
|
|
.into_iter()
|
|
.zip(pending_steer_history_records)
|
|
.map(|(user_message, history_record)| PendingSteer {
|
|
compare_key: pending_steer_compare_keys.pop_front().unwrap_or_else(|| {
|
|
PendingSteerCompareKey {
|
|
message: user_message.text.clone(),
|
|
image_count: user_message.local_images.len()
|
|
+ user_message.remote_image_urls.len(),
|
|
}
|
|
}),
|
|
history_record,
|
|
user_message,
|
|
})
|
|
.collect();
|
|
} else {
|
|
self.input_queue.pending_steers.clear();
|
|
let mut safety_retry_follow_ups = pending_steers
|
|
.into_iter()
|
|
.map(QueuedUserMessage::from)
|
|
.collect::<VecDeque<_>>();
|
|
safety_retry_follow_ups.append(&mut queued_user_messages);
|
|
queued_user_messages = safety_retry_follow_ups;
|
|
pending_steer_history_records.append(&mut queued_user_message_history_records);
|
|
queued_user_message_history_records = pending_steer_history_records;
|
|
}
|
|
self.input_queue.rejected_steers_queue = input_state.rejected_steers_queue;
|
|
self.input_queue.rejected_steer_history_records =
|
|
input_state.rejected_steer_history_records;
|
|
self.input_queue.rejected_steer_history_records.resize(
|
|
self.input_queue.rejected_steers_queue.len(),
|
|
UserMessageHistoryRecord::UserMessageText,
|
|
);
|
|
self.input_queue.queued_user_messages = queued_user_messages;
|
|
self.input_queue.queued_user_message_history_records =
|
|
queued_user_message_history_records;
|
|
self.input_queue.queued_user_message_history_records.resize(
|
|
self.input_queue.queued_user_messages.len(),
|
|
UserMessageHistoryRecord::UserMessageText,
|
|
);
|
|
} else {
|
|
self.turn_lifecycle
|
|
.restore_running(/*running*/ false, Instant::now());
|
|
self.safety_buffering_prompt = None;
|
|
self.input_queue.clear();
|
|
self.restore_composer_state(Default::default());
|
|
}
|
|
let effort = self.effective_reasoning_effort();
|
|
self.bottom_pane
|
|
.set_active_reasoning_effort_baseline(effort.as_ref());
|
|
self.turn_lifecycle
|
|
.restore_running(self.turn_lifecycle.agent_turn_running, Instant::now());
|
|
self.update_task_running_state();
|
|
if restored_task_running && !self.bottom_pane.is_task_running() {
|
|
self.bottom_pane.set_task_running(/*running*/ true);
|
|
self.refresh_status_surfaces();
|
|
}
|
|
self.refresh_pending_input_preview();
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn set_queue_autosend_suppressed(&mut self, suppressed: bool) {
|
|
self.input_queue.suppress_queue_autosend = suppressed;
|
|
}
|
|
}
|