Convert mouse::State into mouse::Click

native/src/input/mouse.rs

@@ -2,68 +2,8 @@
 mod button;
 mod event;
 
-use crate::Point;
+pub mod click;
+
 pub use button::Button;
+pub use click::Click;
 pub use event::{Event, ScrollDelta};
-use std::time::{Duration, SystemTime};
-
-/// enum to track the type of the last click
-#[derive(Debug, Copy, Clone)]
-pub enum Interaction {
-    /// Last Click was a single click
-    Click(Point),
-    /// Last Click was a double click
-    DoubleClick(Point),
-    /// Last Click was a triple click
-    TripleClick(Point),
-}
-
-/// Compiler bully
-#[derive(Debug, Copy, Clone)]
-pub struct State {
-    last_click: Option<Interaction>,
-    last_click_timestamp: Option<SystemTime>,
-}
-
-impl Default for State {
-    fn default() -> Self {
-        State {
-            last_click: None,
-            last_click_timestamp: None,
-        }
-    }
-}
-
-impl State {
-    /// processes left click to check for double/triple clicks
-    /// return amount of repetitive mouse clicks as enum
-    pub fn update(&mut self, position: Point) -> Interaction {
-        self.last_click = match self.last_click {
-            None => Some(Interaction::Click(position)),
-            Some(x) => match x {
-                Interaction::Click(p) if self.process_click(p, position) => {
-                    Some(Interaction::DoubleClick(position))
-                }
-                Interaction::DoubleClick(p)
-                    if self.process_click(p, position) =>
-                {
-                    Some(Interaction::TripleClick(position))
-                }
-                _ => Some(Interaction::Click(position)),
-            },
-        };
-        self.last_click_timestamp = Some(SystemTime::now());
-        self.last_click.unwrap_or(Interaction::Click(position))
-    }
-
-    fn process_click(&self, old_position: Point, new_position: Point) -> bool {
-        old_position == new_position
-            && SystemTime::now()
-                .duration_since(
-                    self.last_click_timestamp.unwrap_or(SystemTime::UNIX_EPOCH),
-                )
-                .unwrap_or(Duration::from_secs(1))
-                .as_millis()
-                <= 500
-    }
-}

native/src/input/mouse/click.rs

@@ -0,0 +1,73 @@
+//! Track mouse clicks.
+use crate::Point;
+use std::time::Instant;
+
+/// A mouse click.
+#[derive(Debug, Clone, Copy)]
+pub struct Click {
+    kind: Kind,
+    position: Point,
+    time: Instant,
+}
+
+/// The kind of mouse click.
+#[derive(Debug, Clone, Copy)]
+pub enum Kind {
+    /// A single click
+    Single,
+
+    /// A double click
+    Double,
+
+    /// A triple click
+    Triple,
+}
+
+impl Kind {
+    fn next(&self) -> Kind {
+        match self {
+            Kind::Single => Kind::Double,
+            Kind::Double => Kind::Triple,
+            Kind::Triple => Kind::Double,
+        }
+    }
+}
+
+impl Click {
+    /// Creates a new [`Click`] with the given position and previous last
+    /// [`Click`].
+    ///
+    /// [`Click`]: struct.Click.html
+    pub fn new(position: Point, previous: Option<Click>) -> Click {
+        let time = Instant::now();
+
+        let kind = if let Some(previous) = previous {
+            if previous.is_consecutive(position, time) {
+                previous.kind.next()
+            } else {
+                Kind::Single
+            }
+        } else {
+            Kind::Single
+        };
+
+        Click {
+            kind,
+            position,
+            time,
+        }
+    }
+
+    /// Returns the [`Kind`] of [`Click`].
+    ///
+    /// [`Kind`]: enum.Kind.html
+    /// [`Click`]: struct.Click.html
+    pub fn kind(&self) -> Kind {
+        self.kind
+    }
+
+    fn is_consecutive(&self, new_position: Point, time: Instant) -> bool {
+        self.position == new_position
+            && time.duration_since(self.time).as_millis() <= 300
+    }
+}

native/src/widget/text_input.rs

@@ -6,7 +6,11 @@
 //! [`State`]: struct.State.html
 mod cursor;
 use crate::{
-    input::{keyboard, mouse, mouse::Interaction, ButtonState},
+    input::{
+        keyboard,
+        mouse::{self, click},
+        ButtonState,
+    },
     layout,
     widget::text_input::cursor::Cursor,
     Clipboard, Element, Event, Font, Hasher, Layout, Length, Point, Rectangle,
@@ -212,22 +216,13 @@ where
                     let text_layout = layout.children().next().unwrap();
                     let target = cursor_position.x - text_layout.bounds().x;
 
-                    match self.state.mouse.update(cursor_position) {
+                    let click = mouse::Click::new(
-                        Interaction::DoubleClick(_) => {
+                        cursor_position,
-                            if self.is_secure {
+                        self.state.last_click,
-                                self.state.cursor.select_all(&self.value);
+                    );
-                            } else {
+
-                                let end = self.state.cursor.end();
+                    match click.kind() {
-                                self.state.cursor.select_range(
+                        click::Kind::Single => {
-                                    self.value.previous_start_of_word(end),
-                                    self.value.next_end_of_word(end),
-                                );
-                            }
-                        }
-                        Interaction::TripleClick(_) => {
-                            self.state.cursor.select_all(&self.value);
-                        }
-                        Interaction::Click(_) => {
                             if target > 0.0 {
                                 let value = if self.is_secure {
                                     self.value.secure()
@@ -262,7 +257,23 @@ where
                                 self.state.cursor.move_to(0);
                             }
                         }
+                        click::Kind::Double => {
+                            if self.is_secure {
+                                self.state.cursor.select_all(&self.value);
+                            } else {
+                                let end = self.state.cursor.end();
+                                self.state.cursor.select_range(
+                                    self.value.previous_start_of_word(end),
+                                    self.value.next_end_of_word(end),
+                                );
+                            }
+                        }
+                        click::Kind::Triple => {
+                            self.state.cursor.select_all(&self.value);
+                        }
                     }
+
+                    self.state.last_click = Some(click);
                 }
 
                 self.state.is_pressed = is_clicked;
@@ -324,7 +335,8 @@ where
                     }
                     _ => (),
                 }
-                self.value.insert(self.state.cursor.end().min(self.value.len()), c);
+                self.value
+                    .insert(self.state.cursor.end().min(self.value.len()), c);
                 self.state.cursor.move_right(&self.value);
 
                 let message = (self.on_change)(self.value.to_string());
@@ -347,7 +359,9 @@ where
                             self.state.cursor.move_left();
                         }
                         None => {
-                            if self.state.cursor.start().min(self.value.len()) > 0 {
+                            if self.state.cursor.start().min(self.value.len())
+                                > 0
+                            {
                                 self.state.cursor.move_left();
                                 let _ = self
                                     .value
@@ -634,8 +648,8 @@ pub struct State {
     is_focused: bool,
     is_pressed: bool,
     is_pasting: Option<Value>,
+    last_click: Option<mouse::Click>,
     cursor: Cursor,
-    mouse: crate::input::mouse::State,
     // TODO: Add stateful horizontal scrolling offset
 }
 
@@ -655,8 +669,8 @@ impl State {
             is_focused: true,
             is_pressed: false,
             is_pasting: None,
+            last_click: None,
             cursor: Cursor::default(),
-            mouse: crate::input::mouse::State::default(),
         }
     }