diff options
| -rw-r--r-- | native/CHANGELOG.md | 9 | ||||
| -rw-r--r-- | native/Cargo.toml | 1 | ||||
| -rw-r--r-- | native/src/input/keyboard.rs | 2 | ||||
| -rw-r--r-- | native/src/input/keyboard/event.rs | 7 | ||||
| -rw-r--r-- | native/src/input/keyboard/modifiers_state.rs | 15 | ||||
| -rw-r--r-- | native/src/renderer/null.rs | 4 | ||||
| -rw-r--r-- | native/src/widget/text_input.rs | 210 | ||||
| -rw-r--r-- | wgpu/src/renderer/widget/text_input.rs | 37 | ||||
| -rw-r--r-- | winit/src/application.rs | 2 | ||||
| -rw-r--r-- | winit/src/conversion.rs | 20 |
10 files changed, 265 insertions, 42 deletions
diff --git a/native/CHANGELOG.md b/native/CHANGELOG.md index cf5b79dd..463b2dbe 100644 --- a/native/CHANGELOG.md +++ b/native/CHANGELOG.md @@ -8,15 +8,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added - `image::Handle` type with `from_path` and `from_memory` methods. [#90] - `image::Data` enum representing different kinds of image data. [#90] +- `text_input::Renderer::measure_value` required method to measure the width of a `TextInput` value. [#108] +- Click-based cursor positioning for `TextInput`. [#108] +- `Home` and `End` keys support for `TextInput`. [#108] +- `Ctrl+Left` and `Ctrl+Right` cursor word jump for `TextInput`. [#108] +- `keyboard::ModifiersState` struct which contains the state of the keyboard modifiers. [#108] ### Changed - `Image::new` takes an `Into<image::Handle>` now instead of an `Into<String>`. [#90] - `Button::background` takes an `Into<Background>` now instead of a `Background`. +- `keyboard::Event::Input` now contains key modifiers state. [#108] ### Fixed - `Image` widget not keeping aspect ratio consistently. [#90] +- `TextInput` not taking grapheme clusters into account. [#108] [#90]: https://github.com/hecrj/iced/pull/90 +[#108]: https://github.com/hecrj/iced/pull/108 + ## [0.1.0] - 2019-11-25 ### Added diff --git a/native/Cargo.toml b/native/Cargo.toml index 7993676e..6ece36e4 100644 --- a/native/Cargo.toml +++ b/native/Cargo.toml @@ -11,3 +11,4 @@ repository = "https://github.com/hecrj/iced" iced_core = { version = "0.1.0", path = "../core", features = ["command"] } twox-hash = "1.5" raw-window-handle = "0.3" +unicode-segmentation = "1.6" diff --git a/native/src/input/keyboard.rs b/native/src/input/keyboard.rs index 57c24484..432e75ba 100644 --- a/native/src/input/keyboard.rs +++ b/native/src/input/keyboard.rs @@ -1,6 +1,8 @@ //! Build keyboard events. mod event; mod key_code; +mod modifiers_state; pub use event::Event; pub use key_code::KeyCode; +pub use modifiers_state::ModifiersState; diff --git a/native/src/input/keyboard/event.rs b/native/src/input/keyboard/event.rs index 8118f112..862f30c4 100644 --- a/native/src/input/keyboard/event.rs +++ b/native/src/input/keyboard/event.rs @@ -1,13 +1,13 @@ -use super::KeyCode; +use super::{KeyCode, ModifiersState}; use crate::input::ButtonState; -#[derive(Debug, Clone, Copy, PartialEq)] /// A keyboard event. /// /// _**Note:** This type is largely incomplete! If you need to track /// additional events, feel free to [open an issue] and share your use case!_ /// /// [open an issue]: https://github.com/hecrj/iced/issues +#[derive(Debug, Clone, Copy, PartialEq)] pub enum Event { /// A keyboard key was pressed or released. Input { @@ -16,6 +16,9 @@ pub enum Event { /// The key identifier key_code: KeyCode, + + /// The state of the modifier keys + modifiers: ModifiersState, }, /// A unicode character was received. diff --git a/native/src/input/keyboard/modifiers_state.rs b/native/src/input/keyboard/modifiers_state.rs new file mode 100644 index 00000000..4e3794b3 --- /dev/null +++ b/native/src/input/keyboard/modifiers_state.rs @@ -0,0 +1,15 @@ +/// The current state of the keyboard modifiers. +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct ModifiersState { + /// Whether a shift key is pressed + pub shift: bool, + + /// Whether a control key is pressed + pub control: bool, + + /// Whether an alt key is pressed + pub alt: bool, + + /// Whether a logo key is pressed (e.g. windows key, command key...) + pub logo: bool, +} diff --git a/native/src/renderer/null.rs b/native/src/renderer/null.rs index da0e5159..02f033a5 100644 --- a/native/src/renderer/null.rs +++ b/native/src/renderer/null.rs @@ -89,6 +89,10 @@ impl text_input::Renderer for Null { 20 } + fn measure_value(&self, _value: &str, _size: u16) -> f32 { + 0.0 + } + fn draw( &mut self, _bounds: Rectangle, diff --git a/native/src/widget/text_input.rs b/native/src/widget/text_input.rs index f97ed424..c57b80aa 100644 --- a/native/src/widget/text_input.rs +++ b/native/src/widget/text_input.rs @@ -9,6 +9,7 @@ use crate::{ layout, Element, Event, Hasher, Layout, Length, Point, Rectangle, Size, Widget, }; +use unicode_segmentation::UnicodeSegmentation; /// A field that can be filled with text. /// @@ -160,7 +161,7 @@ where layout: Layout<'_>, cursor_position: Point, messages: &mut Vec<Message>, - _renderer: &Renderer, + renderer: &Renderer, ) { match event { Event::Mouse(mouse::Event::Input { @@ -170,8 +171,22 @@ where self.state.is_focused = layout.bounds().contains(cursor_position); - if self.state.cursor_position(&self.value) == 0 { - self.state.move_cursor_to_end(&self.value); + if self.state.is_focused { + let text_layout = layout.children().next().unwrap(); + let target = cursor_position.x - text_layout.bounds().x; + + if target < 0.0 { + self.state.cursor_position = 0; + } else { + self.state.cursor_position = find_cursor_position( + renderer, + target, + &self.value, + self.size.unwrap_or(renderer.default_size()), + 0, + self.value.len(), + ); + } } } Event::Keyboard(keyboard::Event::CharacterReceived(c)) @@ -188,6 +203,7 @@ where Event::Keyboard(keyboard::Event::Input { key_code, state: ButtonState::Pressed, + modifiers, }) if self.state.is_focused => match key_code { keyboard::KeyCode::Enter => { if let Some(on_submit) = self.on_submit.clone() { @@ -219,10 +235,24 @@ where } } keyboard::KeyCode::Left => { - self.state.move_cursor_left(&self.value); + if modifiers.control { + self.state.move_cursor_left_by_words(&self.value); + } else { + self.state.move_cursor_left(&self.value); + } } keyboard::KeyCode::Right => { - self.state.move_cursor_right(&self.value); + if modifiers.control { + self.state.move_cursor_right_by_words(&self.value); + } else { + self.state.move_cursor_right(&self.value); + } + } + keyboard::KeyCode::Home => { + self.state.cursor_position = 0; + } + keyboard::KeyCode::End => { + self.state.move_cursor_to_end(&self.value); } _ => {} }, @@ -275,6 +305,11 @@ pub trait Renderer: crate::Renderer + Sized { /// [`TextInput`]: struct.TextInput.html fn default_size(&self) -> u16; + /// Returns the width of the value of the [`TextInput`]. + /// + /// [`TextInput`]: struct.TextInput.html + fn measure_value(&self, value: &str, size: u16) -> f32; + /// Draws a [`TextInput`]. /// /// It receives: @@ -356,6 +391,17 @@ impl State { self.cursor_position.min(value.len()) } + /// Moves the cursor of a [`TextInput`] to the left. + /// + /// [`TextInput`]: struct.TextInput.html + pub(crate) fn move_cursor_left(&mut self, value: &Value) { + let current = self.cursor_position(value); + + if current > 0 { + self.cursor_position = current - 1; + } + } + /// Moves the cursor of a [`TextInput`] to the right. /// /// [`TextInput`]: struct.TextInput.html @@ -367,15 +413,22 @@ impl State { } } - /// Moves the cursor of a [`TextInput`] to the left. + /// Moves the cursor of a [`TextInput`] to the previous start of a word. /// /// [`TextInput`]: struct.TextInput.html - pub(crate) fn move_cursor_left(&mut self, value: &Value) { + pub(crate) fn move_cursor_left_by_words(&mut self, value: &Value) { let current = self.cursor_position(value); - if current > 0 { - self.cursor_position = current - 1; - } + self.cursor_position = value.previous_start_of_word(current); + } + + /// Moves the cursor of a [`TextInput`] to the next end of a word. + /// + /// [`TextInput`]: struct.TextInput.html + pub(crate) fn move_cursor_right_by_words(&mut self, value: &Value) { + let current = self.cursor_position(value); + + self.cursor_position = value.next_end_of_word(current); } /// Moves the cursor of a [`TextInput`] to the end. @@ -389,51 +442,162 @@ impl State { /// The value of a [`TextInput`]. /// /// [`TextInput`]: struct.TextInput.html -// TODO: Use `unicode-segmentation` +// TODO: Reduce allocations, cache results (?) #[derive(Debug)] -pub struct Value(Vec<char>); +pub struct Value { + graphemes: Vec<String>, +} impl Value { /// Creates a new [`Value`] from a string slice. /// /// [`Value`]: struct.Value.html pub fn new(string: &str) -> Self { - Self(string.chars().collect()) + let graphemes = UnicodeSegmentation::graphemes(string, true) + .map(String::from) + .collect(); + + Self { graphemes } } - /// Returns the total amount of `char` in the [`Value`]. + /// Returns the total amount of graphemes in the [`Value`]. /// /// [`Value`]: struct.Value.html pub fn len(&self) -> usize { - self.0.len() + self.graphemes.len() } - /// Returns a new [`Value`] containing the `char` until the given `index`. + /// Returns the position of the previous start of a word from the given + /// grapheme `index`. + /// + /// [`Value`]: struct.Value.html + pub fn previous_start_of_word(&self, index: usize) -> usize { + let previous_string = + &self.graphemes[..index.min(self.graphemes.len())].concat(); + + UnicodeSegmentation::split_word_bound_indices(&previous_string as &str) + .filter(|(_, word)| !word.trim_start().is_empty()) + .next_back() + .map(|(i, previous_word)| { + index + - UnicodeSegmentation::graphemes(previous_word, true) + .count() + - UnicodeSegmentation::graphemes( + &previous_string[i + previous_word.len()..] as &str, + true, + ) + .count() + }) + .unwrap_or(0) + } + + /// Returns the position of the next end of a word from the given grapheme + /// `index`. + /// + /// [`Value`]: struct.Value.html + pub fn next_end_of_word(&self, index: usize) -> usize { + let next_string = &self.graphemes[index..].concat(); + + UnicodeSegmentation::split_word_bound_indices(&next_string as &str) + .filter(|(_, word)| !word.trim_start().is_empty()) + .next() + .map(|(i, next_word)| { + index + + UnicodeSegmentation::graphemes(next_word, true).count() + + UnicodeSegmentation::graphemes( + &next_string[..i] as &str, + true, + ) + .count() + }) + .unwrap_or(self.len()) + } + + /// Returns a new [`Value`] containing the graphemes until the given `index`. /// /// [`Value`]: struct.Value.html pub fn until(&self, index: usize) -> Self { - Self(self.0[..index.min(self.len())].to_vec()) + let graphemes = self.graphemes[..index.min(self.len())].to_vec(); + + Self { graphemes } } /// Converts the [`Value`] into a `String`. /// /// [`Value`]: struct.Value.html pub fn to_string(&self) -> String { - use std::iter::FromIterator; - String::from_iter(self.0.iter()) + self.graphemes.concat() } - /// Inserts a new `char` at the given `index`. + /// Inserts a new `char` at the given grapheme `index`. /// /// [`Value`]: struct.Value.html pub fn insert(&mut self, index: usize, c: char) { - self.0.insert(index, c); + self.graphemes.insert(index, c.to_string()); + + self.graphemes = + UnicodeSegmentation::graphemes(&self.to_string() as &str, true) + .map(String::from) + .collect(); } - /// Removes the `char` at the given `index`. + /// Removes the grapheme at the given `index`. /// /// [`Value`]: struct.Value.html pub fn remove(&mut self, index: usize) { - let _ = self.0.remove(index); + let _ = self.graphemes.remove(index); + } +} + +// TODO: Reduce allocations +fn find_cursor_position<Renderer: self::Renderer>( + renderer: &Renderer, + target: f32, + value: &Value, + size: u16, + start: usize, + end: usize, +) -> usize { + if start >= end { + if start == 0 { + return 0; + } + + let prev = value.until(start - 1); + let next = value.until(start); + + let prev_width = renderer.measure_value(&prev.to_string(), size); + let next_width = renderer.measure_value(&next.to_string(), size); + + if next_width - target > target - prev_width { + return start - 1; + } else { + return start; + } + } + + let index = (end - start) / 2; + let subvalue = value.until(start + index); + + let width = renderer.measure_value(&subvalue.to_string(), size); + + if width > target { + find_cursor_position( + renderer, + target, + value, + size, + start, + start + index, + ) + } else { + find_cursor_position( + renderer, + target, + value, + size, + start + index + 1, + end, + ) } } diff --git a/wgpu/src/renderer/widget/text_input.rs b/wgpu/src/renderer/widget/text_input.rs index d64fca6d..c6c64b88 100644 --- a/wgpu/src/renderer/widget/text_input.rs +++ b/wgpu/src/renderer/widget/text_input.rs @@ -12,6 +12,24 @@ impl text_input::Renderer for Renderer { 20 } + fn measure_value(&self, value: &str, size: u16) -> f32 { + let (mut width, _) = self.text_pipeline.measure( + value, + f32::from(size), + Font::Default, + Size::INFINITY, + ); + + let spaces_at_the_end = value.len() - value.trim_end().len(); + + if spaces_at_the_end > 0 { + let space_width = self.text_pipeline.space_width(size as f32); + width += spaces_at_the_end as f32 * space_width; + } + + width + } + fn draw( &mut self, bounds: Rectangle, @@ -48,7 +66,6 @@ impl text_input::Renderer for Renderer { border_radius: 4, }; - let size = f32::from(size); let text = value.to_string(); let text_value = Primitive::Text { @@ -68,7 +85,7 @@ impl text_input::Renderer for Renderer { width: f32::INFINITY, ..text_bounds }, - size, + size: f32::from(size), horizontal_alignment: HorizontalAlignment::Left, vertical_alignment: VerticalAlignment::Center, }; @@ -77,20 +94,8 @@ impl text_input::Renderer for Renderer { let text_before_cursor = value.until(state.cursor_position(value)).to_string(); - let (mut text_value_width, _) = self.text_pipeline.measure( - &text_before_cursor, - size, - Font::Default, - Size::new(f32::INFINITY, text_bounds.height), - ); - - let spaces_at_the_end = - text_before_cursor.len() - text_before_cursor.trim_end().len(); - - if spaces_at_the_end > 0 { - let space_width = self.text_pipeline.space_width(size); - text_value_width += spaces_at_the_end as f32 * space_width; - } + let text_value_width = + self.measure_value(&text_before_cursor, size); let cursor = Primitive::Quad { bounds: Rectangle { diff --git a/winit/src/application.rs b/winit/src/application.rs index 3772a667..85d06d9b 100644 --- a/winit/src/application.rs +++ b/winit/src/application.rs @@ -319,6 +319,7 @@ pub trait Application: Sized { winit::event::KeyboardInput { virtual_keycode: Some(virtual_keycode), state, + modifiers, .. }, .. @@ -334,6 +335,7 @@ pub trait Application: Sized { events.push(Event::Keyboard(keyboard::Event::Input { key_code: conversion::key_code(virtual_keycode), state: conversion::button_state(state), + modifiers: conversion::modifiers_state(modifiers), })); } WindowEvent::CloseRequested => { diff --git a/winit/src/conversion.rs b/winit/src/conversion.rs index 03d583fb..0537d853 100644 --- a/winit/src/conversion.rs +++ b/winit/src/conversion.rs @@ -3,7 +3,10 @@ //! [`winit`]: https://github.com/rust-windowing/winit //! [`iced_native`]: https://github.com/hecrj/iced/tree/master/native use crate::{ - input::{keyboard::KeyCode, mouse, ButtonState}, + input::{ + keyboard::{KeyCode, ModifiersState}, + mouse, ButtonState, + }, MouseCursor, }; @@ -47,6 +50,21 @@ pub fn button_state(element_state: winit::event::ElementState) -> ButtonState { } } +/// Convert some `ModifiersState` from [`winit`] to an [`iced_native`] modifiers state. +/// +/// [`winit`]: https://github.com/rust-windowing/winit +/// [`iced_native`]: https://github.com/hecrj/iced/tree/master/native +pub fn modifiers_state( + modifiers: winit::event::ModifiersState, +) -> ModifiersState { + ModifiersState { + shift: modifiers.shift, + control: modifiers.ctrl, + alt: modifiers.alt, + logo: modifiers.logo, + } +} + /// Convert a `VirtualKeyCode` from [`winit`] to an [`iced_native`] key code. /// /// [`winit`]: https://github.com/rust-windowing/winit |