From 608507699c9553809d15d4d6dac5f970ecc208f0 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 16 Oct 2026 03:05:21 +0200 Subject: [PATCH] Classic world fields edit at a cursor: arrows, Home/End, Delete, clicks and drags The world list's search, Edit World's name and Create New World's name and seed kept only their String and appended to it. They now edit through an EditBox (ui::Caret keeps the focused field's cursor, selection and scroll between frames): EditBox.keyPressed's moves and deletions (Ctrl by word, Shift to select), Ctrl+A/C/V/X on the selection, onClick placing the cursor under the pointer (Shift extends, a double click within 250 ms selects the word) and onDrag selecting. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game.rs | 22 +- crates/horizon-client/src/game/clipboard.rs | 14 +- crates/horizon-client/src/title.rs | 207 +++++++++++------- .../horizon-client/src/title/create_world.rs | 34 +-- crates/horizon-client/src/title/tests.rs | 25 +++ crates/horizon-client/src/ui.rs | 171 ++++++++++++++- 6 files changed, 366 insertions(+), 107 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index b4787eb0b..bc1fb2603 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -9116,6 +9116,7 @@ impl ApplicationHandler for Game<'_> { && !horizon_client::ui_theme::horizon() { title.drag(self.cursor, (b.width, b.height)); + title.drag_field(&self.res.atlas, self.cursor.0); } if self.dragging && self.screen == Screen::Options { let _ = b; @@ -9202,6 +9203,7 @@ impl ApplicationHandler for Game<'_> { } if self.title.is_some() && self.screen != Screen::Options => { if let Some(title) = &mut self.title { title.release(); + title.release_field(); } } WindowEvent::MouseInput { @@ -9216,6 +9218,7 @@ impl ApplicationHandler for Game<'_> { .unwrap_or([1, 1]); let mut b = HudBatch::new(size); let atlas = &self.res.atlas; + let shift = self.has_shift_down(); let (action, sound) = self.title.as_mut().map_or((Action::None, false), |t| { if horizon_client::ui_theme::horizon() { ( @@ -9223,7 +9226,10 @@ impl ApplicationHandler for Game<'_> { false, ) } else { - t.click(self.cursor.0, self.cursor.1, (b.width, b.height)) + let clicked = + t.click(self.cursor.0, self.cursor.1, (b.width, b.height)); + t.press_field(atlas, self.cursor, (b.width, b.height), shift); + clicked } }); if sound { @@ -9434,6 +9440,20 @@ impl ApplicationHandler for Game<'_> { t.confirm_edit(); } } + PhysicalKey::Code( + key @ (KeyCode::Backspace + | KeyCode::Delete + | KeyCode::ArrowLeft + | KeyCode::ArrowRight + | KeyCode::Home + | KeyCode::End), + ) if self.title.as_mut().is_some_and(|t| t.has_caret_field()) => { + let (ctrl, shift) = + (self.has_control_down(), self.has_shift_down()); + if let Some(t) = self.title.as_mut() { + t.field_key(key, ctrl, shift); + } + } PhysicalKey::Code(KeyCode::Backspace) => self.title_edit(None, true), PhysicalKey::Code(KeyCode::Tab) => { if let Some(t) = self.title.as_mut() { diff --git a/crates/horizon-client/src/game/clipboard.rs b/crates/horizon-client/src/game/clipboard.rs index 17a634c9a..b9558ddfd 100644 --- a/crates/horizon-client/src/game/clipboard.rs +++ b/crates/horizon-client/src/game/clipboard.rs @@ -46,6 +46,9 @@ impl Game<'_> { let Some(title) = self.title.as_mut() else { return; }; + if title.has_caret_field() { + return title.field_shortcut(shortcut, &mut self.clipboard); + } if let Some((id, value, max)) = title.focused_field() { let changed = Self::append_shortcut( &mut self.text_selection, @@ -60,15 +63,16 @@ impl Game<'_> { } } } - /// Typing or a backspace in an append-only field of the title screens: - /// Select All's selection is replaced first. + /// Typing or a backspace in a field of the title screens: in the server + /// screens' append-only fields Select All's selection is replaced first. pub(super) fn title_edit(&mut self, typed: Option<&str>, backspace: bool) { let Some(title) = self.title.as_mut() else { return; }; - let cleared = title - .focused_field() - .is_some_and(|(id, value, _)| self.text_selection.take(id, value)); + let cleared = !title.has_caret_field() + && title + .focused_field() + .is_some_and(|(id, value, _)| self.text_selection.take(id, value)); if cleared { title.search_changed(); } diff --git a/crates/horizon-client/src/title.rs b/crates/horizon-client/src/title.rs index aa78981f5..bd1f57a05 100644 --- a/crates/horizon-client/src/title.rs +++ b/crates/horizon-client/src/title.rs @@ -129,6 +129,8 @@ pub struct Title { pub started: std::time::Instant, search: String, search_focused: bool, + /// The focused text field's cursor, selection and scroll. + caret: RefCell, scroll: Cell, create_return_to_main: bool, message_lines: Cell, @@ -233,6 +235,7 @@ impl Title { started: now, search: String::new(), search_focused: false, + caret: RefCell::default(), scroll: Cell::default(), create_return_to_main: false, message_lines: Cell::new(1), @@ -788,14 +791,13 @@ impl Title { Mode::Select { worlds, selected } => { crate::ui::menu_background(batch, atlas, 0.0, 0.0, w, h, false); centered(atlas, batch, "Select World", 8.0, u32::MAX); - text_field( - atlas, + self.caret.borrow_mut().draw( batch, - ((w / 2.0).floor() - 100.0, 21.0), - &self.search, + atlas, + (SEARCH, &self.search, 50), + [(w / 2.0).floor() - 100.0, 21.0, 200.0, 20.0], self.search_focused, - !self.search.is_empty() - && (self.started.elapsed().as_millis() / 300).is_multiple_of(2), + self.started, ); if self.search.is_empty() { batch.text( @@ -940,13 +942,13 @@ impl Title { rgba(160, 160, 160, 255), true, ); - text_field( - atlas, + self.caret.borrow_mut().draw( batch, - ((w / 2.0).floor() - 100.0, top + 39.0), - name, + atlas, + (EDIT_NAME, name, 32), + [(w / 2.0).floor() - 100.0, top + 39.0, 200.0, 20.0], *focused, - (self.started.elapsed().as_millis() / 300).is_multiple_of(2), + self.started, ); } Mode::Delete { world } => { @@ -1316,40 +1318,99 @@ impl Title { pub fn focused_field(&mut self) -> Option<(crate::clipboard::FieldId, &mut String, usize)> { match &mut self.mode { Mode::Multiplayer(screen) => screen.focused_text(), - Mode::Select { .. } if self.search_focused => { - Some((("world.search", 0), &mut self.search, 50)) - } - Mode::Edit { - name, - focused: true, - .. - } => Some((("world.edit-name", 0), name, 32)), - Mode::Create { - name, seed, focus, .. - } => match focus { - 0 => Some((("world.name", 0), name, 32)), - 1 => Some((("world.seed", 0), seed, 32)), - _ => None, - }, + mode => caret_field(mode, self.search_focused, &mut self.search), + } + } + /// Whether the focused field edits at its cursor (every field but the + /// server screens', which still append). + pub fn has_caret_field(&mut self) -> bool { + caret_field(&mut self.mode, self.search_focused, &mut self.search).is_some() + } + /// Edit the focused field through its `EditBox`; false when there is none. + fn edit_field(&mut self, f: impl FnOnce(&mut crate::ui::EditBox)) -> bool { + let Some((id, value, max)) = + caret_field(&mut self.mode, self.search_focused, &mut self.search) + else { + return false; + }; + let before = value.clone(); + self.caret.get_mut().edit(id, value, max, f); + if *value != before { + self.search_changed(); + } + true + } + /// EditBox.charTyped / insertText at the cursor. + pub fn type_text(&mut self, text: &str) { + if let Mode::Multiplayer(screen) = &mut self.mode { + return screen.type_text(text); + } + self.edit_field(|edit| edit.insert_text(text)); + } + pub fn backspace(&mut self) { + if let Mode::Multiplayer(screen) = &mut self.mode { + return screen.backspace(); + } + self.field_key(winit::keyboard::KeyCode::Backspace, false, false); + } + /// EditBox.keyPressed: moving and deleting in the focused field. + pub fn field_key(&mut self, key: winit::keyboard::KeyCode, ctrl: bool, shift: bool) -> bool { + let mut handled = false; + self.edit_field(|edit| handled = edit.key(key, ctrl, shift)); + handled + } + /// Ctrl+A/C/V/X in the focused field. + pub fn field_shortcut( + &mut self, + shortcut: crate::clipboard::EditShortcut, + board: &mut dyn crate::clipboard::Clipboard, + ) { + self.edit_field(|edit| { + edit.shortcut(shortcut, board); + }); + } + /// The focused field's box on screen. + fn focused_rect(&self, (w, h): (f32, f32)) -> Option<[f32; 4]> { + let x = (w / 2.0).floor() - 100.0; + match &self.mode { + Mode::Select { .. } if self.search_focused => Some([x, 21.0, 200.0, 20.0]), + Mode::Edit { focused: true, .. } => Some([x, edit_top(h) + 39.0, 200.0, 20.0]), + Mode::Create { focus, options, .. } => create_world::field_rect(w, h, options.tab) + .filter(|(id, _)| id == focus) + .map(|(_, rect)| rect), _ => None, } } - pub fn type_text(&mut self, text: &str) { - if let Some((_, field, max)) = self.focused_field() { - for c in text.chars().filter(|c| !c.is_control()) { - if field.chars().count() < max { - field.push(c); - } - } - self.search_changed(); + /// A left press after `click` focused a field: the cursor goes under the + /// pointer (`EditBox.onClick`). + pub fn press_field( + &mut self, + atlas: &HudAtlas, + (x, y): (f32, f32), + size: (f32, f32), + shift: bool, + ) { + let (w, h) = (size.0.ceil(), size.1.ceil()); + let Some(rect @ [fx, fy, fw, fh]) = self.focused_rect((w, h)) else { + return; + }; + if !crate::ui::hovered((x, y), fx, fy, fw, fh) { + return; + } + if let Some(field) = caret_field(&mut self.mode, self.search_focused, &mut self.search) { + self.caret.get_mut().press(atlas, field, rect, x, shift); } } - pub fn backspace(&mut self) { - if let Some((_, field, _)) = self.focused_field() { - field.pop(); - self.search_changed(); + /// The pointer moved with the button held (`EditBox.onDrag`). + pub fn drag_field(&mut self, atlas: &HudAtlas, x: f32) { + if let Some(field) = caret_field(&mut self.mode, self.search_focused, &mut self.search) { + self.caret.get_mut().drag(atlas, field, x); } } + /// The button was released: drags stop selecting. + pub fn release_field(&mut self) { + self.caret.get_mut().release(); + } /// Clipboard replacements also invalidate a selection in the filtered list. pub fn search_changed(&mut self) { if self.search_focused @@ -1471,52 +1532,32 @@ fn wrapped(atlas: &HudAtlas, text: &str, width: f32) -> Vec { .map(|t| t.plain()) .collect() } -fn text_field( - atlas: &HudAtlas, - batch: &mut HudBatch, - pos: (f32, f32), - value: &str, - focused: bool, - blink: bool, -) { - let (x, y) = pos; - crate::widgets::target_as([x, y, 200.0, 20.0], crate::widgets::Kind::Field); - batch.fill( - atlas, - x, - y, - 200.0, - 20.0, - if focused { - u32::MAX - } else { - rgba(160, 160, 160, 255) +const SEARCH: crate::clipboard::FieldId = ("world.search", 0); +const EDIT_NAME: crate::clipboard::FieldId = ("world.edit-name", 0); +const WORLD_NAME: crate::clipboard::FieldId = ("world.name", 0); +const WORLD_SEED: crate::clipboard::FieldId = ("world.seed", 0); +/// The focused field of the world screens: the list's search, the world +/// name being edited, or Create New World's name or seed. +fn caret_field<'a>( + mode: &'a mut Mode, + search_focused: bool, + search: &'a mut String, +) -> Option<(crate::clipboard::FieldId, &'a mut String, usize)> { + match mode { + Mode::Select { .. } if search_focused => Some((SEARCH, search, 50)), + Mode::Edit { + name, + focused: true, + .. + } => Some((EDIT_NAME, name, 32)), + Mode::Create { + name, seed, focus, .. + } => match focus { + 0 => Some((WORLD_NAME, name, 32)), + 1 => Some((WORLD_SEED, seed, 32)), + _ => None, }, - ); - batch.fill(atlas, x + 1.0, y + 1.0, 198.0, 18.0, rgba(0, 0, 0, 255)); - let count = atlas.font.fit_reverse(value, 188.0); - let start = value - .char_indices() - .nth(value.chars().count().saturating_sub(count)) - .map_or(value.len(), |(i, _)| i); - let value = &value[start..]; - batch.text( - atlas, - value, - x + 4.0, - y + 6.0, - rgba(224, 224, 224, 255), - true, - ); - if focused && blink { - batch.text( - atlas, - "_", - x + 4.0 + HudBatch::text_width(atlas, value), - y + 6.0, - rgba(224, 224, 224, 255), - true, - ); + _ => None, } } /// `yyyy/MM/dd HH:mm` (UTC) for a modification time in Unix seconds. diff --git a/crates/horizon-client/src/title/create_world.rs b/crates/horizon-client/src/title/create_world.rs index 8fa11943d..a2fa6b8ce 100644 --- a/crates/horizon-client/src/title/create_world.rs +++ b/crates/horizon-client/src/title/create_world.rs @@ -145,15 +145,20 @@ fn grid(w: f32, h: f32, tab: usize) -> (f32, f32) { TAB_BAR + ((area - gh) * 0.166_666_67).trunc(), ) } -/// The text box under the pointer: 0 the name, 1 the seed. -pub(super) fn field_at(w: f32, h: f32, tab: usize, (x, y): (f32, f32)) -> Option { +/// The text box of `tab`: 0 the name (Game tab), 1 the seed (World tab). +pub(super) fn field_rect(w: f32, h: f32, tab: usize) -> Option<(u8, [f32; 4])> { let (gx, gy) = grid(w, h, tab); match tab { - 0 => ui::hovered((x, y), gx + 1.0, gy + 13.0, 208.0, 20.0).then_some(0), - 1 => ui::hovered((x, y), gx, gy + 41.0, 308.0, 20.0).then_some(1), + 0 => Some((0, [gx + 1.0, gy + 13.0, 208.0, 20.0])), + 1 => Some((1, [gx, gy + 41.0, 308.0, 20.0])), _ => None, } } +/// The text box under the pointer: 0 the name, 1 the seed. +pub(super) fn field_at(w: f32, h: f32, tab: usize, (x, y): (f32, f32)) -> Option { + let (id, [fx, fy, fw, fh]) = field_rect(w, h, tab)?; + ui::hovered((x, y), fx, fy, fw, fh).then_some(id) +} fn tr(key: &str) -> String { Text::translate(key, &[]).plain() @@ -390,7 +395,7 @@ impl Title { self.create_field( atlas, batch, - name, + (super::WORLD_NAME, name, 32), [gx + 1.0, gy + 13.0, 208.0], focus == 0, None, @@ -401,7 +406,7 @@ impl Title { self.create_field( atlas, batch, - seed, + (super::WORLD_SEED, seed, 32), [gx, gy + 41.0, 308.0], focus == 1, Some("selectWorld.seedInfo"), @@ -425,24 +430,21 @@ impl Title { u32::MAX, ); } - /// An EditBox with its cursor at the end; `hint` shows while it is empty - /// and unfocused. + /// An EditBox; `hint` shows while it is empty and unfocused. fn create_field( &self, atlas: &HudAtlas, batch: &mut HudBatch, - value: &str, + (id, value, max): (crate::clipboard::FieldId, &str, usize), [x, y, width]: [f32; 3], focused: bool, hint: Option<&str>, ) { - let mut field = ui::EditBox::new(x, y, width, 20.0); - field.value = value.to_owned(); - field.cursor = ui::char_len(value); - field.highlight = field.cursor; - field.focused = focused; - field.focused_since(self.started); - field.draw(batch, atlas, None); + let rect = [x, y, width, 20.0]; + self.caret + .borrow_mut() + .draw(batch, atlas, (id, value, max), rect, focused, self.started); + let field = ui::EditBox::new(x, y, width, 20.0); if let Some(hint) = hint && value.is_empty() && !focused diff --git a/crates/horizon-client/src/title/tests.rs b/crates/horizon-client/src/title/tests.rs index 9a671601a..cfa4c9545 100644 --- a/crates/horizon-client/src/title/tests.rs +++ b/crates/horizon-client/src/title/tests.rs @@ -680,3 +680,28 @@ fn new_world_generation_settings_round_trip() { Some("minecraft:flat") ); } + +#[test] +fn world_fields_edit_at_their_cursor() { + use winit::keyboard::KeyCode; + let mut f = Fixture::new(); + f.world("World", "World"); + f.title.enter_singleplayer(); + // The search box takes the focus. + f.title.click(240.0, 30.0, (480.0, 262.0)); + f.title.type_text("hello world"); + for _ in 0..5 { + assert!(f.title.field_key(KeyCode::ArrowLeft, false, false)); + } + f.title.type_text("X"); + assert_eq!(f.title.search, "hello Xworld"); + // Shift+Home selects back to the start; typing replaces the selection. + f.title.field_key(KeyCode::Home, false, true); + f.title.type_text("Y"); + assert_eq!(f.title.search, "Yworld"); + // Ctrl+Left jumps a word; Backspace deletes before the cursor. + f.title.field_key(KeyCode::ArrowLeft, true, false); + f.title.field_key(KeyCode::ArrowRight, false, false); + f.title.field_key(KeyCode::Backspace, false, false); + assert_eq!(f.title.search, "world"); +} diff --git a/crates/horizon-client/src/ui.rs b/crates/horizon-client/src/ui.rs index e9862e11c..eb1661802 100644 --- a/crates/horizon-client/src/ui.rs +++ b/crates/horizon-client/src/ui.rs @@ -598,6 +598,122 @@ pub struct EditBox { pub suggestion: Option, pub text_color: u32, } +/// The focused text field of a screen that keeps its values as `String`s +/// (the world list's search, world names, seeds): the `EditBox` state that +/// outlives a frame, its cursor, selection and scroll. +#[derive(Clone, Debug)] +pub struct Caret { + field: Option, + edit: EditBox, + /// The last click's time and field, for double clicks. + last_click: Option<(Instant, crate::clipboard::FieldId)>, + /// The button is held since a press on the field (`onDrag`). + held: bool, +} +impl Default for Caret { + fn default() -> Self { + Self { + field: None, + edit: EditBox::new(0.0, 0.0, 200.0, 20.0), + last_click: None, + held: false, + } + } +} +impl Caret { + /// The box for field `id` holding `value`. A field newly focused, or + /// whose value changed elsewhere, starts with its cursor at the end. + fn sync(&mut self, id: crate::clipboard::FieldId, value: &str, max: usize) -> &mut EditBox { + self.edit.max_length = max; + if self.field != Some(id) || self.edit.value != value { + self.edit.value = value.to_owned(); + self.edit.move_cursor_to_end(false); + if self.field != Some(id) { + self.edit.display = 0; + self.field = Some(id); + } + } + &mut self.edit + } + /// Edit field `id`'s `value` through its box; the value is written back. + pub fn edit( + &mut self, + id: crate::clipboard::FieldId, + value: &mut String, + max: usize, + f: impl FnOnce(&mut EditBox) -> R, + ) -> R { + let edit = self.sync(id, value, max); + let result = f(edit); + value.clone_from(&edit.value); + result + } + /// A press on field `id` at GUI `x` (`EditBox.onClick`): a second press + /// within 250 ms is a double click (`MouseHandler`). + pub fn press( + &mut self, + atlas: &HudAtlas, + (id, value, max): (crate::clipboard::FieldId, &mut String, usize), + rect: [f32; 4], + x: f32, + shift: bool, + ) { + let now = Instant::now(); + let double = self + .last_click + .is_some_and(|(at, field)| field == id && now.duration_since(at).as_millis() < 250); + self.last_click = Some((now, id)); + self.held = true; + self.edit(id, value, max, |edit| { + [edit.x, edit.y, edit.width, edit.height] = rect; + edit.click(atlas, x, shift, double); + }); + } + /// The pointer moved with the button held after a press on field `id`. + pub fn drag( + &mut self, + atlas: &HudAtlas, + (id, value, max): (crate::clipboard::FieldId, &mut String, usize), + x: f32, + ) { + if self.held && self.last_click.is_some_and(|(_, field)| field == id) { + self.edit(id, value, max, |edit| edit.drag_to(atlas, x)); + } + } + /// The button was released: drags no longer select. + pub fn release(&mut self) { + self.held = false; + } + /// Draw field `id` at `rect`: the focused one with its caret, the others + /// showing the end of their text. + #[allow(clippy::too_many_arguments)] + pub fn draw( + &mut self, + batch: &mut HudBatch, + atlas: &HudAtlas, + (id, value, max): (crate::clipboard::FieldId, &str, usize), + rect: [f32; 4], + focused: bool, + focused_at: Instant, + ) { + let mut idle; + let edit = if focused { + self.sync(id, value, max) + } else { + idle = EditBox::new(0.0, 0.0, 0.0, 0.0); + idle.max_length = max; + idle.set_value(value); + &mut idle + }; + [edit.x, edit.y, edit.width, edit.height] = rect; + edit.focused = focused; + if edit.focused_at < focused_at { + edit.focused_at = focused_at; + } + edit.draw(batch, atlas, None); + } +} + /// `EditBox.extractWidgetRenderState` for Horizon's append-only fields, /// unbordered and with the cursor at the end: the text from (x, y), the /// highlight when Select All covers the value (`invert_text` as @@ -740,10 +856,14 @@ impl EditBox { self.value.replace_range(ba..bb, ""); self.set_cursor(a, false); } - /// EditBox.getWordPosition. + /// EditBox.getWordPosition from the cursor. pub fn word_position(&self, dir: isize) -> usize { + self.word_position_from(dir, self.cursor) + } + /// EditBox.getWordPosition(dir, from). + fn word_position_from(&self, dir: isize, from: usize) -> usize { let chars: Vec = self.value.chars().collect(); - let mut pos = self.cursor; + let mut pos = from.min(chars.len()); if dir < 0 { while pos > 0 && chars[pos - 1] == ' ' { pos -= 1; @@ -773,6 +893,33 @@ impl EditBox { pub fn move_cursor_to_end(&mut self, select: bool) { self.set_cursor(char_len(&self.value), select); } + /// EditBox.findClickedPositionInText: the character boundary under GUI `x`. + pub fn position_at(&mut self, atlas: &HudAtlas, x: f32) -> usize { + self.layout(atlas); + let room = (x.floor() - self.text_x()).min(self.inner_width()); + let rest: String = self.value.chars().skip(self.display).collect(); + self.display + atlas.font.fit(&rest, room) + } + /// EditBox.onClick: the cursor to the pointer, extending the selection + /// with Shift; a double click selects the word under it (`selectWord`). + pub fn click(&mut self, atlas: &HudAtlas, x: f32, shift: bool, double: bool) { + let pos = self.position_at(atlas, x); + if double { + let (start, end) = ( + self.word_position_from(-1, pos), + self.word_position_from(1, pos), + ); + self.set_cursor(start, false); + self.set_cursor(end, true); + } else { + self.set_cursor(pos, shift); + } + } + /// EditBox.onDrag: the selection follows the pointer. + pub fn drag_to(&mut self, atlas: &HudAtlas, x: f32) { + let pos = self.position_at(atlas, x); + self.set_cursor(pos, true); + } fn scroll_to(&mut self, pos: usize) { // EditBox.scrollTo without font access is completed in `layout`. self.display = self.display.min(char_len(&self.value)); @@ -1086,6 +1233,26 @@ mod tests { assert_eq!(s.amount, 36.0); } #[test] + fn edit_box_clicks_place_the_cursor_and_select() { + let atlas = HudAtlas::build(Path::new("/nonexistent/horizon-test-assets")).unwrap(); + let mut e = EditBox::new(10.0, 0.0, 200.0, 20.0); + e.set_value("hello world"); + let at = |e: &EditBox, s: &str| e.text_x() + atlas.font.width(s); + // findClickedPositionInText: the characters left of the pointer. + e.click(&atlas, at(&e, "hello "), false, false); + assert_eq!((e.cursor, e.highlight), (6, 6)); + // Shift extends the selection from the anchor. + e.click(&atlas, at(&e, "hello wor"), true, false); + assert_eq!(e.selected_text(), "wor"); + // selectWord: the word and the spaces after it. + e.click(&atlas, at(&e, "he"), false, true); + assert_eq!(e.selected_text(), "hello "); + // onDrag from a click: left of the text is its start. + e.click(&atlas, at(&e, "hello "), false, false); + e.drag_to(&atlas, e.text_x() - 5.0); + assert_eq!((e.cursor, e.highlight), (0, 6)); + } + #[test] fn edit_box_editing() { let mut e = EditBox::new(0.0, 0.0, 100.0, 20.0); e.max_length = 10;