use super::*;
impl TextInputState {
pub(crate) fn insert(&self, text: &str, keyboard: &KeyboardEvent) -> bool {
if text.is_empty() {
return false;
}
self.replace_selection_text(text, keyboard);
true
}
pub(crate) fn replace_selection_text(&self, text: &str, keyboard: &KeyboardEvent) -> bool {
self.replace_selection_with(text, None, keyboard, false)
}
pub(crate) fn type_text(&self, text: &str, keyboard: &KeyboardEvent) -> bool {
if text.is_empty() {
return false;
}
self.replace_selection_with(text, None, keyboard, true);
true
}
#[cfg(feature = "markdown")]
pub(crate) fn replace_selection_styled(
&self,
inserted: &crate::components::StyledText,
keyboard: &KeyboardEvent,
) -> bool {
let insert = styled::InsertedText {
styled: inserted,
kinds: None,
objects: &[],
};
self.replace_selection_with(&inserted.text, Some(&insert), keyboard, false)
}
#[cfg(feature = "markdown")]
pub(super) fn replace_selection_inserting(
&self,
insert: &styled::InsertedText<'_>,
keyboard: &KeyboardEvent,
) -> bool {
self.replace_selection_with(&insert.styled.text, Some(insert), keyboard, false)
}
#[cfg(feature = "markdown")]
pub(crate) fn replace_selection_rich(
&self,
inserted: &crate::components::RichText,
keyboard: &KeyboardEvent,
) -> bool {
let text = inserted.styled();
let insert = styled::InsertedText {
styled: &text,
kinds: Some(&inserted.paragraphs),
objects: &inserted.objects,
};
self.replace_selection_with(&text.text, Some(&insert), keyboard, false)
}
fn replace_selection_with(
&self,
text: &str,
styled_insert: Option<&styled::InsertedText<'_>>,
keyboard: &KeyboardEvent,
typed: bool,
) -> bool {
if text.is_empty() && !self.has_selection() {
return false;
}
if !self.fire_input(keyboard, || {
let (mut value, caret) = self.value_without_selection();
let caret = clamp_to_char_boundary(&value, caret);
value.insert_str(caret, text);
value
}) {
return false;
}
if typed {
self.begin_typing(TypingKind::Insert, text);
} else {
self.push_undo_snapshot();
}
let styled = self.styled_before_edit();
let (start, end) = {
let value = self.value();
let inner = self.inner.lock();
selection_range_indices(&value, inner.selection_anchor, inner.caret).unwrap_or_else(|| {
let caret = clamp_to_char_boundary(&value, inner.caret);
(caret, caret)
})
};
self.value.update(|value| value.replace_range(start..end, text));
let caret = start + text.len();
let value = self.value();
let mut inner = self.inner.lock();
inner.last_value = value;
inner.token_affinity = None;
inner.caret = caret;
inner.selection_anchor = None;
drop(inner);
match styled_insert {
Some(inserted) => self.styled_after_insert(styled, start..end, inserted),
None => self.styled_after_edit(styled, start..end, text.len()),
}
if typed {
self.end_typing(TypingKind::Insert, text);
}
self.mark_layout_dirty();
true
}
pub(crate) fn insert_newline(&self, keyboard: &KeyboardEvent) -> bool {
if self.overflow() != TextInputOverflow::Multiline {
return false;
}
self.type_text("\n", keyboard)
}
pub(crate) fn backspace(&self, keyboard: &KeyboardEvent) -> bool {
if self.select_atomic_beside_caret(true) {
return true;
}
if self.has_selection() {
if !self.fire_input(keyboard, || self.value_without_selection().0) {
return true;
}
self.push_undo_snapshot();
self.delete_selection_if_present();
return true;
}
let mut caret = self.inner.lock().caret;
if caret == 0 {
return false;
}
if !self.fire_input(keyboard, || {
let mut value = self.value();
let caret = clamp_to_char_boundary(&value, caret);
if caret > 0 {
let previous = previous_delete_boundary(&value, caret);
value.replace_range(previous..caret, "");
}
value
}) {
return true;
}
self.begin_typing(TypingKind::Backspace, "");
let styled = self.styled_before_edit();
let mut removed = 0..0;
self.value.update(|value| {
caret = clamp_to_char_boundary(value, caret);
if caret > 0 {
let previous = previous_delete_boundary(value, caret);
value.replace_range(previous..caret, "");
removed = previous..caret;
caret = previous;
}
});
self.inner.lock().caret = caret;
self.styled_after_edit(styled, removed, 0);
self.end_typing(TypingKind::Backspace, "");
self.mark_layout_dirty();
true
}
pub(crate) fn delete(&self, keyboard: &KeyboardEvent) -> bool {
if self.select_atomic_beside_caret(false) {
return true;
}
if self.has_selection() {
if !self.fire_input(keyboard, || self.value_without_selection().0) {
return true;
}
self.push_undo_snapshot();
self.delete_selection_if_present();
return true;
}
let mut caret = self.inner.lock().caret;
let value = self.value();
caret = clamp_to_char_boundary(&value, caret);
if caret >= value.len() {
return false;
}
if !self.fire_input(keyboard, || {
let mut value = value.clone();
let next = next_delete_boundary(&value, caret);
value.replace_range(caret..next, "");
value
}) {
return true;
}
self.begin_typing(TypingKind::Delete, "");
let styled = self.styled_before_edit();
let mut removed = caret..caret;
self.value.update(|value| {
let next = next_delete_boundary(value, caret);
value.replace_range(caret..next, "");
removed = caret..next;
});
self.inner.lock().caret = caret;
self.styled_after_edit(styled, removed, 0);
self.end_typing(TypingKind::Delete, "");
self.mark_layout_dirty();
true
}
pub(crate) fn move_left(&self, selecting: bool) {
self.break_typing();
let value = self.value();
let mut inner = self.inner.lock();
if selecting {
if inner.selection_anchor.is_none() {
inner.selection_anchor = Some(inner.caret);
}
inner.caret = previous_char_boundary(&value, clamp_to_char_boundary(&value, inner.caret));
} else if let Some((start, _)) = selection_range_indices(&value, inner.selection_anchor, inner.caret) {
inner.caret = start;
inner.selection_anchor = None;
} else {
inner.caret = previous_char_boundary(&value, clamp_to_char_boundary(&value, inner.caret));
inner.selection_anchor = None;
}
drop(inner);
self.keep_out_of_tokens(tokens::Toward::Start);
self.mark_layout_dirty();
}
pub(crate) fn move_right(&self, selecting: bool) {
self.break_typing();
let value = self.value();
let mut inner = self.inner.lock();
if selecting {
if inner.selection_anchor.is_none() {
inner.selection_anchor = Some(inner.caret);
}
inner.caret = next_char_boundary(&value, clamp_to_char_boundary(&value, inner.caret));
} else if let Some((_, end)) = selection_range_indices(&value, inner.selection_anchor, inner.caret) {
inner.caret = end;
inner.selection_anchor = None;
} else {
inner.caret = next_char_boundary(&value, clamp_to_char_boundary(&value, inner.caret));
inner.selection_anchor = None;
}
drop(inner);
self.keep_out_of_tokens(tokens::Toward::End);
self.mark_layout_dirty();
}
pub(crate) fn move_up(&self, selecting: bool) {
self.break_typing();
self.move_vertical(false, selecting);
}
pub(crate) fn move_down(&self, selecting: bool) {
self.break_typing();
self.move_vertical(true, selecting);
}
fn move_vertical(&self, down: bool, selecting: bool) {
if self.move_token_vertical(down, selecting) {
self.keep_out_of_tokens(tokens::Toward::Nearest);
return;
}
let value = self.value();
let mut inner = self.inner.lock();
let caret = clamp_to_char_boundary(&value, inner.caret);
let (shown_x, y) = shown_caret_point(&inner, &value, caret);
let x = match inner.vertical_goal {
Some((goal_caret, goal_x)) if goal_caret == caret => goal_x,
_ => shown_x,
};
let target =
closest_caret_on_adjacent_row(&inner.caret_positions, y, x, down).unwrap_or(if down { value.len() } else { 0 });
move_inner_to(&mut inner, target, selecting);
drop(inner);
self.keep_out_of_tokens(tokens::Toward::Nearest);
let goal = Some((self.inner.lock().caret, x));
self.mark_layout_dirty();
self.inner.lock().vertical_goal = goal;
}
pub(crate) fn move_word_left(&self, selecting: bool) {
self.break_typing();
let value = self.value();
let mut inner = self.inner.lock();
let target = previous_word_boundary(&value, inner.caret);
move_inner_to(&mut inner, target, selecting);
drop(inner);
self.keep_out_of_tokens(tokens::Toward::Start);
self.mark_layout_dirty();
}
pub(crate) fn move_word_right(&self, selecting: bool) {
self.break_typing();
let value = self.value();
let mut inner = self.inner.lock();
let target = next_word_boundary(&value, inner.caret);
move_inner_to(&mut inner, target, selecting);
drop(inner);
self.keep_out_of_tokens(tokens::Toward::End);
self.mark_layout_dirty();
}
pub(crate) fn move_home(&self, selecting: bool) {
self.break_typing();
let mut inner = self.inner.lock();
if selecting && inner.selection_anchor.is_none() {
inner.selection_anchor = Some(inner.caret);
}
inner.caret = 0;
if !selecting {
inner.selection_anchor = None;
}
drop(inner);
self.mark_layout_dirty();
}
pub(crate) fn move_end(&self, selecting: bool) {
self.break_typing();
let len = self.value().len();
let mut inner = self.inner.lock();
if selecting && inner.selection_anchor.is_none() {
inner.selection_anchor = Some(inner.caret);
}
inner.caret = len;
if !selecting {
inner.selection_anchor = None;
}
drop(inner);
self.mark_layout_dirty();
}
pub(crate) fn select_all(&self) {
self.break_typing();
let len = self.value().len();
let mut inner = self.inner.lock();
inner.selection_anchor = Some(0);
inner.caret = len;
drop(inner);
self.mark_layout_dirty();
}
pub(crate) fn selected_text(&self) -> Option<String> {
let value = self.value();
let inner = self.inner.lock();
let (start, end) = selection_range_indices(&value, inner.selection_anchor, inner.caret)?;
Some(value[start..end].to_owned())
}
pub(crate) fn cut_selection(&self, keyboard: &KeyboardEvent) -> Option<String> {
let selected = self.selected_text()?;
if !self.fire_input(keyboard, || self.value_without_selection().0) {
return Some(selected);
}
self.push_undo_snapshot();
self.delete_selection_if_present();
Some(selected)
}
pub(crate) fn undo(&self, keyboard: &KeyboardEvent) -> bool {
let current = self.snapshot();
let Some(snapshot) = self.inner.lock().undo_stack.pop() else {
return false;
};
if !self.fire_input(keyboard, || snapshot.value.clone()) {
self.push_undo_snapshot_value(snapshot);
return true;
}
self.push_redo_snapshot(current);
self.restore_snapshot(snapshot);
self.mark_layout_dirty();
true
}
pub(crate) fn redo(&self, keyboard: &KeyboardEvent) -> bool {
let current = self.snapshot();
let Some(snapshot) = self.inner.lock().redo_stack.pop() else {
return false;
};
if !self.fire_input(keyboard, || snapshot.value.clone()) {
self.push_redo_snapshot(snapshot);
return true;
}
self.push_undo_snapshot_value(current);
self.restore_snapshot(snapshot);
self.mark_layout_dirty();
true
}
pub(crate) fn begin_selection_at_point(&self, x: f32, y: f32) {
self.break_typing();
if self.begin_object_resize(x, y) {
return;
}
if !self.on_removing_icon(x, y) && self.select_atomic_at_point(x, y) {
return;
}
let caret = self.closest_caret_to_point(x, y);
let mut inner = self.inner.lock();
inner.caret = caret;
inner.selection_anchor = Some(caret);
drop(inner);
self.mark_layout_dirty();
}
pub(crate) fn update_selection_to_point(&self, x: f32, y: f32) {
self.break_typing();
if self.drag_object_resize(x) {
return;
}
let caret = self.closest_caret_to_point(x, y);
self.inner.lock().caret = caret;
self.keep_out_of_tokens(tokens::Toward::AwayFromAnchor);
self.mark_layout_dirty();
}
pub(crate) fn set_caret_from_point(&self, x: f32, y: f32) {
self.break_typing();
if self.remove_token_at_point(x, y) || self.select_atomic_at_point(x, y) {
return;
}
let caret = self.closest_caret_to_point(x, y);
let mut inner = self.inner.lock();
inner.caret = caret;
inner.selection_anchor = None;
drop(inner);
self.keep_out_of_tokens(tokens::Toward::Nearest);
self.mark_layout_dirty();
}
pub(crate) fn select_word_at_point(&self, x: f32, y: f32) {
self.break_typing();
if self.select_atomic_at_point(x, y) {
return;
}
let caret = self.closest_caret_to_point(x, y);
let value = self.value();
let (start, end) = word_selection_bounds(&value, caret);
let mut inner = self.inner.lock();
inner.selection_anchor = Some(start);
inner.caret = end;
drop(inner);
self.keep_out_of_tokens(tokens::Toward::End);
self.mark_layout_dirty();
}
pub(crate) fn select_line_at_point(&self, x: f32, y: f32) {
self.break_typing();
let caret = self.closest_caret_to_point(x, y);
let value = self.value();
let (start, end) = line_bounds(&value, caret);
let mut inner = self.inner.lock();
inner.selection_anchor = Some(start);
inner.caret = end;
drop(inner);
self.mark_layout_dirty();
}
}
fn shown_caret_point(inner: &TextInputInner, value: &str, caret: usize) -> (f32, f32) {
if inner.overflow == TextInputOverflow::Multiline && caret == value.len() && trailing_break_len(value) > 0 {
return (
0.0,
trailing_break_row_y(&inner.caret_positions, value, inner.caret_height),
);
}
let x = caret_x_for_index(&inner.caret_positions, caret);
let y = caret_y_for_index(&inner.caret_positions, caret).unwrap_or(inner.caret_y);
(x, y)
}