Merge pull request #37 from hecrj/feature/text-input

Text input widget

7 files changed, 164 insertions, 11 deletions

diff --git a/native/src/element.rs b/native/src/element.rs
index c638c713..be64a981 100644
--- a/native/src/element.rs
+++ b/native/src/element.rs
@@ -217,7 +217,7 @@ where
     /// ```
     pub fn map<F, B>(self, f: F) -> Element<'a, B, Renderer>
     where
-        Message: 'static + Copy,
+        Message: 'static + Clone,
         Renderer: 'a,
         B: 'static,
         F: 'static + Fn(Message) -> B,
@@ -286,7 +286,7 @@ impl<'a, A, B, Renderer> Map<'a, A, B, Renderer> {
 
 impl<'a, A, B, Renderer> Widget<B, Renderer> for Map<'a, A, B, Renderer>
 where
-    A: Copy,
+    A: Clone,
     Renderer: crate::Renderer,
 {
     fn node(&self, renderer: &Renderer) -> Node {
diff --git a/native/src/lib.rs b/native/src/lib.rs
index fa72a553..56399e57 100644
--- a/native/src/lib.rs
+++ b/native/src/lib.rs
@@ -211,10 +211,8 @@ mod node;
 mod style;
 mod user_interface;
 
-pub(crate) use iced_core::Vector;
-
 pub use iced_core::{
-    Align, Background, Color, Justify, Length, Point, Rectangle,
+    Align, Background, Color, Justify, Length, Point, Rectangle, Vector,
 };
 
 #[doc(no_inline)]
diff --git a/native/src/mouse_cursor.rs b/native/src/mouse_cursor.rs
index 291e57a6..a4740a27 100644
--- a/native/src/mouse_cursor.rs
+++ b/native/src/mouse_cursor.rs
@@ -18,4 +18,7 @@ pub enum MouseCursor {
 
     /// The cursor is grabbing a widget.
     Grabbing,
+
+    /// The cursor is over a text widget.
+    Text,
 }
diff --git a/native/src/widget.rs b/native/src/widget.rs
index c04f3377..01f5c92e 100644
--- a/native/src/widget.rs
+++ b/native/src/widget.rs
@@ -29,6 +29,7 @@ pub mod row;
 pub mod scrollable;
 pub mod slider;
 pub mod text;
+pub mod text_input;
 
 #[doc(no_inline)]
 pub use button::Button;
@@ -48,6 +49,8 @@ pub use scrollable::Scrollable;
 pub use slider::Slider;
 #[doc(no_inline)]
 pub use text::Text;
+#[doc(no_inline)]
+pub use text_input::TextInput;
 
 use crate::{Event, Hasher, Layout, Node, Point};
 
diff --git a/native/src/widget/button.rs b/native/src/widget/button.rs
index cf5dba93..31dd6fcc 100644
--- a/native/src/widget/button.rs
+++ b/native/src/widget/button.rs
@@ -19,7 +19,7 @@ impl<'a, Message, Renderer> Widget<Message, Renderer>
     for Button<'a, Message, Renderer>
 where
     Renderer: self::Renderer,
-    Message: Copy + std::fmt::Debug,
+    Message: Clone + std::fmt::Debug,
 {
     fn node(&self, renderer: &Renderer) -> Node {
         renderer.node(&self)
@@ -38,7 +38,7 @@ where
                 button: mouse::Button::Left,
                 state,
             }) => {
-                if let Some(on_press) = self.on_press {
+                if let Some(on_press) = self.on_press.clone() {
                     let bounds = layout.bounds();
 
                     match state {
@@ -108,7 +108,7 @@ impl<'a, Message, Renderer> From<Button<'a, Message, Renderer>>
     for Element<'a, Message, Renderer>
 where
     Renderer: 'static + self::Renderer,
-    Message: 'static + Copy + std::fmt::Debug,
+    Message: 'static + Clone + std::fmt::Debug,
 {
     fn from(
         button: Button<'a, Message, Renderer>,
diff --git a/native/src/widget/radio.rs b/native/src/widget/radio.rs
index 93ec4a36..626e6ffc 100644
--- a/native/src/widget/radio.rs
+++ b/native/src/widget/radio.rs
@@ -9,7 +9,7 @@ pub use iced_core::Radio;
 impl<Message, Renderer> Widget<Message, Renderer> for Radio<Message>
 where
     Renderer: self::Renderer,
-    Message: Copy + std::fmt::Debug,
+    Message: Clone + std::fmt::Debug,
 {
     fn node(&self, renderer: &Renderer) -> Node {
         renderer.node(&self)
@@ -29,7 +29,7 @@ where
                 state: ButtonState::Pressed,
             }) => {
                 if layout.bounds().contains(cursor_position) {
-                    messages.push(self.on_click);
+                    messages.push(self.on_click.clone());
                 }
             }
             _ => {}
@@ -85,7 +85,7 @@ impl<'a, Message, Renderer> From<Radio<Message>>
     for Element<'a, Message, Renderer>
 where
     Renderer: self::Renderer,
-    Message: 'static + Copy + std::fmt::Debug,
+    Message: 'static + Clone + std::fmt::Debug,
 {
     fn from(checkbox: Radio<Message>) -> Element<'a, Message, Renderer> {
         Element::new(checkbox)
diff --git a/native/src/widget/text_input.rs b/native/src/widget/text_input.rs
new file mode 100644
index 00000000..d9837b61
--- /dev/null
+++ b/native/src/widget/text_input.rs
@@ -0,0 +1,149 @@
+use crate::{
+    input::{keyboard, mouse, ButtonState},
+    Element, Event, Hasher, Layout, Length, Node, Point, Rectangle, Style,
+    Widget,
+};
+
+pub use iced_core::{text_input::State, TextInput};
+
+impl<'a, Message, Renderer> Widget<Message, Renderer> for TextInput<'a, Message>
+where
+    Renderer: self::Renderer,
+    Message: Clone + std::fmt::Debug,
+{
+    fn node(&self, renderer: &Renderer) -> Node {
+        let text_bounds =
+            Node::new(Style::default().width(Length::Fill).height(
+                Length::Units(self.size.unwrap_or(renderer.default_size())),
+            ));
+
+        Node::with_children(
+            Style::default()
+                .width(self.width)
+                .max_width(self.width)
+                .padding(self.padding),
+            vec![text_bounds],
+        )
+    }
+
+    fn on_event(
+        &mut self,
+        event: Event,
+        layout: Layout<'_>,
+        cursor_position: Point,
+        messages: &mut Vec<Message>,
+        _renderer: &Renderer,
+    ) {
+        match event {
+            Event::Mouse(mouse::Event::Input {
+                button: mouse::Button::Left,
+                state: ButtonState::Pressed,
+            }) => {
+                self.state.is_focused =
+                    layout.bounds().contains(cursor_position);
+            }
+            Event::Keyboard(keyboard::Event::CharacterReceived(c))
+                if self.state.is_focused && !c.is_control() =>
+            {
+                let cursor_position = self.state.cursor_position(&self.value);
+
+                self.value.insert(cursor_position, c);
+                self.state.move_cursor_right(&self.value);
+
+                let message = (self.on_change)(self.value.to_string());
+                messages.push(message);
+            }
+            Event::Keyboard(keyboard::Event::Input {
+                key_code,
+                state: ButtonState::Pressed,
+            }) if self.state.is_focused => match key_code {
+                keyboard::KeyCode::Enter => {
+                    if let Some(on_submit) = self.on_submit.clone() {
+                        messages.push(on_submit);
+                    }
+                }
+                keyboard::KeyCode::Backspace => {
+                    let cursor_position =
+                        self.state.cursor_position(&self.value);
+
+                    if cursor_position > 0 {
+                        self.state.move_cursor_left(&self.value);
+
+                        let _ = self.value.remove(cursor_position - 1);
+
+                        let message = (self.on_change)(self.value.to_string());
+                        messages.push(message);
+                    }
+                }
+                keyboard::KeyCode::Delete => {
+                    let cursor_position =
+                        self.state.cursor_position(&self.value);
+
+                    if cursor_position < self.value.len() {
+                        let _ = self.value.remove(cursor_position);
+
+                        let message = (self.on_change)(self.value.to_string());
+                        messages.push(message);
+                    }
+                }
+                keyboard::KeyCode::Left => {
+                    self.state.move_cursor_left(&self.value);
+                }
+                keyboard::KeyCode::Right => {
+                    self.state.move_cursor_right(&self.value);
+                }
+                _ => {}
+            },
+            _ => {}
+        }
+    }
+
+    fn draw(
+        &self,
+        renderer: &mut Renderer,
+        layout: Layout<'_>,
+        cursor_position: Point,
+    ) -> Renderer::Output {
+        let bounds = layout.bounds();
+        let text_bounds = layout.children().next().unwrap().bounds();
+
+        renderer.draw(&self, bounds, text_bounds, cursor_position)
+    }
+
+    fn hash_layout(&self, state: &mut Hasher) {
+        use std::any::TypeId;
+        use std::hash::Hash;
+
+        TypeId::of::<TextInput<'static, ()>>().hash(state);
+
+        self.width.hash(state);
+        self.max_width.hash(state);
+        self.padding.hash(state);
+        self.size.hash(state);
+    }
+}
+
+pub trait Renderer: crate::Renderer + Sized {
+    fn default_size(&self) -> u16;
+
+    fn draw<Message>(
+        &mut self,
+        text_input: &TextInput<'_, Message>,
+        bounds: Rectangle,
+        text_bounds: Rectangle,
+        cursor_position: Point,
+    ) -> Self::Output;
+}
+
+impl<'a, Message, Renderer> From<TextInput<'a, Message>>
+    for Element<'a, Message, Renderer>
+where
+    Renderer: 'static + self::Renderer,
+    Message: 'static + Clone + std::fmt::Debug,
+{
+    fn from(
+        text_input: TextInput<'a, Message>,
+    ) -> Element<'a, Message, Renderer> {
+        Element::new(text_input)
+    }
+}