reivilibre/iced-mobile
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Convert mouse::State into mouse::Click

Browse Source
This commit is contained in:
Héctor Ramón Jiménez 2020-03-24 19:03:17 +01:00
parent b632dce0da
commit 7cb1452d29
3 changed files with 111 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
native/src/input/mouse.rs
View File

@ -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
}
}

73
native/src/input/mouse/click.rs Normal file
View File

@ -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
}
}

56
native/src/widget/text_input.rs
View File

@ -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) {
Interaction::DoubleClick(_) => {
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),
);
}
}
Interaction::TripleClick(_) => {
self.state.cursor.select_all(&self.value);
}
Interaction::Click(_) => {
let click = mouse::Click::new(
cursor_position,
self.state.last_click,
);
match click.kind() {
click::Kind::Single => {
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(),
}
}