Split `Input` mouse event by `ButtonState`

7 files changed, 139 insertions, 156 deletions

diff --git a/native/src/widget/button.rs b/native/src/widget/button.rs
index 3cf4f780..5d414023 100644
--- a/native/src/widget/button.rs
+++ b/native/src/widget/button.rs
@@ -5,9 +5,8 @@
 //! [`Button`]: struct.Button.html
 //! [`State`]: struct.State.html
 use crate::{
-    input::{mouse, ButtonState},
-    layout, Clipboard, Element, Event, Hasher, Layout, Length, Point,
-    Rectangle, Widget,
+    input::mouse, layout, Clipboard, Element, Event, Hasher, Layout, Length,
+    Point, Rectangle, Widget,
 };
 use std::hash::Hash;
 
@@ -185,28 +184,24 @@ where
         _clipboard: Option<&dyn Clipboard>,
     ) {
         match event {
-            Event::Mouse(mouse::Event::Input {
-                button: mouse::Button::Left,
-                state,
-            }) => {
+            Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)) => {
+                if self.on_press.is_some() {
+                    let bounds = layout.bounds();
+
+                    self.state.is_pressed = bounds.contains(cursor_position);
+                }
+            }
+            Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left)) => {
                 if let Some(on_press) = self.on_press.clone() {
                     let bounds = layout.bounds();
 
-                    match state {
-                        ButtonState::Pressed => {
-                            self.state.is_pressed =
-                                bounds.contains(cursor_position);
-                        }
-                        ButtonState::Released => {
-                            let is_clicked = self.state.is_pressed
-                                && bounds.contains(cursor_position);
+                    let is_clicked = self.state.is_pressed
+                        && bounds.contains(cursor_position);
 
-                            self.state.is_pressed = false;
+                    self.state.is_pressed = false;
 
-                            if is_clicked {
-                                messages.push(on_press);
-                            }
-                        }
+                    if is_clicked {
+                        messages.push(on_press);
                     }
                 }
             }
diff --git a/native/src/widget/checkbox.rs b/native/src/widget/checkbox.rs
index 4d167df7..c49ac707 100644
--- a/native/src/widget/checkbox.rs
+++ b/native/src/widget/checkbox.rs
@@ -2,8 +2,7 @@
 use std::hash::Hash;
 
 use crate::{
-    input::{mouse, ButtonState},
-    layout, row, text, Align, Clipboard, Element, Event, Hasher,
+    input::mouse, layout, row, text, Align, Clipboard, Element, Event, Hasher,
     HorizontalAlignment, Layout, Length, Point, Rectangle, Row, Text,
     VerticalAlignment, Widget,
 };
@@ -152,10 +151,7 @@ where
         _clipboard: Option<&dyn Clipboard>,
     ) {
         match event {
-            Event::Mouse(mouse::Event::Input {
-                button: mouse::Button::Left,
-                state: ButtonState::Pressed,
-            }) => {
+            Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)) => {
                 let mouse_over = layout.bounds().contains(cursor_position);
 
                 if mouse_over {
diff --git a/native/src/widget/pane_grid.rs b/native/src/widget/pane_grid.rs
index 0b735ad3..fe2bbe07 100644
--- a/native/src/widget/pane_grid.rs
+++ b/native/src/widget/pane_grid.rs
@@ -22,7 +22,7 @@ pub use split::Split;
 pub use state::{Focus, State};
 
 use crate::{
-    input::{keyboard, mouse, ButtonState},
+    input::{keyboard, mouse},
     layout, Clipboard, Element, Event, Hasher, Layout, Length, Point, Size,
     Widget,
 };
@@ -405,11 +405,8 @@ where
         clipboard: Option<&dyn Clipboard>,
     ) {
         match event {
-            Event::Mouse(mouse::Event::Input {
-                button: mouse::Button::Left,
-                state,
-            }) => match state {
-                ButtonState::Pressed => {
+            Event::Mouse(mouse_event) => match mouse_event {
+                mouse::Event::ButtonPressed(mouse::Button::Left) => {
                     let mut clicked_region =
                         self.elements.iter().zip(layout.children()).filter(
                             |(_, layout)| {
@@ -438,7 +435,7 @@ where
                         self.state.unfocus();
                     }
                 }
-                ButtonState::Released => {
+                mouse::Event::ButtonReleased(mouse::Button::Left) => {
                     if let Some(pane) = self.state.picked_pane() {
                         self.state.focus(&pane);
 
@@ -465,97 +462,110 @@ where
                         }
                     }
                 }
-            },
-            Event::Mouse(mouse::Event::Input {
-                button: mouse::Button::Right,
-                state: ButtonState::Pressed,
-            }) if self.on_resize.is_some()
-                && self.state.picked_pane().is_none()
-                && self.pressed_modifiers.matches(self.modifier_keys) =>
-            {
-                let bounds = layout.bounds();
+                mouse::Event::ButtonPressed(mouse::Button::Right)
+                    if self.on_resize.is_some()
+                        && self.state.picked_pane().is_none()
+                        && self
+                            .pressed_modifiers
+                            .matches(self.modifier_keys) =>
+                {
+                    let bounds = layout.bounds();
+
+                    if bounds.contains(cursor_position) {
+                        let relative_cursor = Point::new(
+                            cursor_position.x - bounds.x,
+                            cursor_position.y - bounds.y,
+                        );
 
-                if bounds.contains(cursor_position) {
-                    let relative_cursor = Point::new(
-                        cursor_position.x - bounds.x,
-                        cursor_position.y - bounds.y,
-                    );
-
-                    let splits = self.state.splits(
-                        f32::from(self.spacing),
-                        Size::new(bounds.width, bounds.height),
-                    );
-
-                    let mut sorted_splits: Vec<_> = splits
-                        .iter()
-                        .filter(|(_, (axis, rectangle, _))| match axis {
-                            Axis::Horizontal => {
-                                relative_cursor.x > rectangle.x
-                                    && relative_cursor.x
-                                        < rectangle.x + rectangle.width
-                            }
-                            Axis::Vertical => {
-                                relative_cursor.y > rectangle.y
-                                    && relative_cursor.y
-                                        < rectangle.y + rectangle.height
-                            }
-                        })
-                        .collect();
-
-                    sorted_splits.sort_by_key(
-                        |(_, (axis, rectangle, ratio))| {
-                            let distance = match axis {
-                                Axis::Horizontal => (relative_cursor.y
-                                    - (rectangle.y + rectangle.height * ratio))
-                                    .abs(),
-                                Axis::Vertical => (relative_cursor.x
-                                    - (rectangle.x + rectangle.width * ratio))
-                                    .abs(),
-                            };
+                        let splits = self.state.splits(
+                            f32::from(self.spacing),
+                            Size::new(bounds.width, bounds.height),
+                        );
 
-                            distance.round() as u32
-                        },
-                    );
+                        let mut sorted_splits: Vec<_> = splits
+                            .iter()
+                            .filter(|(_, (axis, rectangle, _))| match axis {
+                                Axis::Horizontal => {
+                                    relative_cursor.x > rectangle.x
+                                        && relative_cursor.x
+                                            < rectangle.x + rectangle.width
+                                }
+                                Axis::Vertical => {
+                                    relative_cursor.y > rectangle.y
+                                        && relative_cursor.y
+                                            < rectangle.y + rectangle.height
+                                }
+                            })
+                            .collect();
+
+                        sorted_splits.sort_by_key(
+                            |(_, (axis, rectangle, ratio))| {
+                                let distance = match axis {
+                                    Axis::Horizontal => (relative_cursor.y
+                                        - (rectangle.y
+                                            + rectangle.height * ratio))
+                                        .abs(),
+                                    Axis::Vertical => (relative_cursor.x
+                                        - (rectangle.x
+                                            + rectangle.width * ratio))
+                                        .abs(),
+                                };
+
+                                distance.round() as u32
+                            },
+                        );
 
-                    if let Some((split, (axis, _, _))) = sorted_splits.first() {
-                        self.state.pick_split(split, *axis);
-                        self.trigger_resize(layout, cursor_position, messages);
+                        if let Some((split, (axis, _, _))) =
+                            sorted_splits.first()
+                        {
+                            self.state.pick_split(split, *axis);
+                            self.trigger_resize(
+                                layout,
+                                cursor_position,
+                                messages,
+                            );
+                        }
                     }
                 }
-            }
-            Event::Mouse(mouse::Event::Input {
-                button: mouse::Button::Right,
-                state: ButtonState::Released,
-            }) if self.state.picked_split().is_some() => {
-                self.state.drop_split();
-            }
-            Event::Mouse(mouse::Event::CursorMoved { .. }) => {
-                self.trigger_resize(layout, cursor_position, messages);
-            }
-            Event::Keyboard(keyboard::Event::KeyPressed {
-                modifiers,
-                key_code,
-            }) => {
-                if let Some(on_key_press) = &self.on_key_press {
-                    // TODO: Discard when event is captured
-                    if let Some(_) = self.state.active_pane() {
-                        if modifiers.matches(self.modifier_keys) {
-                            if let Some(message) = on_key_press(KeyPressEvent {
-                                key_code,
-                                modifiers,
-                            }) {
-                                messages.push(message);
+                mouse::Event::ButtonPressed(mouse::Button::Right)
+                    if self.state.picked_split().is_some() =>
+                {
+                    self.state.drop_split();
+                }
+                mouse::Event::CursorMoved { .. } => {
+                    self.trigger_resize(layout, cursor_position, messages);
+                }
+                _ => {}
+            },
+            Event::Keyboard(keyboard_event) => {
+                match keyboard_event {
+                    keyboard::Event::KeyPressed {
+                        modifiers,
+                        key_code,
+                    } => {
+                        if let Some(on_key_press) = &self.on_key_press {
+                            // TODO: Discard when event is captured
+                            if let Some(_) = self.state.active_pane() {
+                                if modifiers.matches(self.modifier_keys) {
+                                    if let Some(message) =
+                                        on_key_press(KeyPressEvent {
+                                            key_code,
+                                            modifiers,
+                                        })
+                                    {
+                                        messages.push(message);
+                                    }
+                                }
                             }
                         }
+
+                        *self.pressed_modifiers = modifiers;
                     }
+                    keyboard::Event::KeyReleased { modifiers, .. } => {
+                        *self.pressed_modifiers = modifiers;
+                    }
+                    _ => {}
                 }
-
-                *self.pressed_modifiers = modifiers;
-            }
-            Event::Keyboard(keyboard::Event::KeyReleased {
-                modifiers, ..
-            }) => {
-                *self.pressed_modifiers = modifiers;
             }
             _ => {}
         }
diff --git a/native/src/widget/radio.rs b/native/src/widget/radio.rs
index a13d86a0..deea7034 100644
--- a/native/src/widget/radio.rs
+++ b/native/src/widget/radio.rs
@@ -1,7 +1,6 @@
 //! Create choices using radio buttons.
 use crate::{
-    input::{mouse, ButtonState},
-    layout, row, text, Align, Clipboard, Element, Event, Hasher,
+    input::mouse, layout, row, text, Align, Clipboard, Element, Event, Hasher,
     HorizontalAlignment, Layout, Length, Point, Rectangle, Row, Text,
     VerticalAlignment, Widget,
 };
@@ -123,10 +122,7 @@ where
         _clipboard: Option<&dyn Clipboard>,
     ) {
         match event {
-            Event::Mouse(mouse::Event::Input {
-                button: mouse::Button::Left,
-                state: ButtonState::Pressed,
-            }) => {
+            Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)) => {
                 if layout.bounds().contains(cursor_position) {
                     messages.push(self.on_click.clone());
                 }
diff --git a/native/src/widget/scrollable.rs b/native/src/widget/scrollable.rs
index 393095a4..da11c50c 100644
--- a/native/src/widget/scrollable.rs
+++ b/native/src/widget/scrollable.rs
@@ -1,9 +1,7 @@
 //! Navigate an endless amount of content with a scrollbar.
 use crate::{
-    column,
-    input::{mouse, ButtonState},
-    layout, Align, Clipboard, Column, Element, Event, Hasher, Layout, Length,
-    Point, Rectangle, Size, Widget,
+    column, input::mouse, layout, Align, Clipboard, Column, Element, Event,
+    Hasher, Layout, Length, Point, Rectangle, Size, Widget,
 };
 
 use std::{f32, hash::Hash, u32};
@@ -188,10 +186,9 @@ where
 
         if self.state.is_scroller_grabbed() {
             match event {
-                Event::Mouse(mouse::Event::Input {
-                    button: mouse::Button::Left,
-                    state: ButtonState::Released,
-                }) => {
+                Event::Mouse(mouse::Event::ButtonReleased(
+                    mouse::Button::Left,
+                )) => {
                     self.state.scroller_grabbed_at = None;
                 }
                 Event::Mouse(mouse::Event::CursorMoved { .. }) => {
@@ -212,10 +209,9 @@ where
             }
         } else if is_mouse_over_scrollbar {
             match event {
-                Event::Mouse(mouse::Event::Input {
-                    button: mouse::Button::Left,
-                    state: ButtonState::Pressed,
-                }) => {
+                Event::Mouse(mouse::Event::ButtonPressed(
+                    mouse::Button::Left,
+                )) => {
                     if let Some(scrollbar) = scrollbar {
                         if let Some(scroller_grabbed_at) =
                             scrollbar.grab_scroller(cursor_position)
diff --git a/native/src/widget/slider.rs b/native/src/widget/slider.rs
index 1feb7825..a00d7c8d 100644
--- a/native/src/widget/slider.rs
+++ b/native/src/widget/slider.rs
@@ -5,9 +5,8 @@
 //! [`Slider`]: struct.Slider.html
 //! [`State`]: struct.State.html
 use crate::{
-    input::{mouse, ButtonState},
-    layout, Clipboard, Element, Event, Hasher, Layout, Length, Point,
-    Rectangle, Size, Widget,
+    input::mouse, layout, Clipboard, Element, Event, Hasher, Layout, Length,
+    Point, Rectangle, Size, Widget,
 };
 
 use std::{hash::Hash, ops::RangeInclusive};
@@ -164,25 +163,23 @@ where
         };
 
         match event {
-            Event::Mouse(mouse::Event::Input {
-                button: mouse::Button::Left,
-                state,
-            }) => match state {
-                ButtonState::Pressed => {
+            Event::Mouse(mouse_event) => match mouse_event {
+                mouse::Event::ButtonPressed(mouse::Button::Left) => {
                     if layout.bounds().contains(cursor_position) {
                         change();
                         self.state.is_dragging = true;
                     }
                 }
-                ButtonState::Released => {
+                mouse::Event::ButtonReleased(mouse::Button::Left) => {
                     self.state.is_dragging = false;
                 }
-            },
-            Event::Mouse(mouse::Event::CursorMoved { .. }) => {
-                if self.state.is_dragging {
-                    change();
+                mouse::Event::CursorMoved { .. } => {
+                    if self.state.is_dragging {
+                        change();
+                    }
                 }
-            }
+                _ => {}
+            },
             _ => {}
         }
     }
diff --git a/native/src/widget/text_input.rs b/native/src/widget/text_input.rs
index ea6921b5..b11269db 100644
--- a/native/src/widget/text_input.rs
+++ b/native/src/widget/text_input.rs
@@ -18,7 +18,6 @@ use crate::{
     input::{
         keyboard,
         mouse::{self, click},
-        ButtonState,
     },
     layout, Clipboard, Element, Event, Font, Hasher, Layout, Length, Point,
     Rectangle, Size, Widget,
@@ -212,10 +211,7 @@ where
         clipboard: Option<&dyn Clipboard>,
     ) {
         match event {
-            Event::Mouse(mouse::Event::Input {
-                button: mouse::Button::Left,
-                state: ButtonState::Pressed,
-            }) => {
+            Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)) => {
                 let is_clicked = layout.bounds().contains(cursor_position);
 
                 if is_clicked {
@@ -280,10 +276,7 @@ where
                 self.state.is_dragging = is_clicked;
                 self.state.is_focused = is_clicked;
             }
-            Event::Mouse(mouse::Event::Input {
-                button: mouse::Button::Left,
-                state: ButtonState::Released,
-            }) => {
+            Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left)) => {
                 self.state.is_dragging = false;
             }
             Event::Mouse(mouse::Event::CursorMoved { x, .. }) => {