Mouse input refactoring

examples/custom_widget.rs

@@ -120,19 +120,22 @@ mod circular_button {
     /// over the button and the previous interaction state.
     fn get_new_interaction(is_over: bool, prev: Interaction, mouse: Mouse) -> Interaction {
         use conrod::MouseButtonPosition::{Down, Up};
+        use conrod::MouseButton;
         use self::Interaction::{Normal, Highlighted, Clicked};
-        match (is_over, prev, mouse.left.position) {
+
+        let lmb_position = mouse.buttons.get(MouseButton::Left).position;
+        match (is_over, prev, lmb_position) {
             // LMB is down over the button. But the button wasn't Highlighted last
             // update. This means the user clicked somewhere outside the button and
             // moved over the button holding LMB down. We do nothing in this case.
-            (true,  Normal,  Down) => Normal,
+            (true,  Normal,  Down(_)) => Normal,
 
             // LMB is down over the button. The button was either Highlighted or Clicked
             // last update. If it was highlighted before, that means the user clicked
             // just now, and we transition to the Clicked state. If it was clicked
             // before, that means the user is still holding LMB down from a previous
             // click, in which case the state remains Clicked.
-            (true,  _,       Down) => Clicked,
+            (true,  _,       Down(_)) => Clicked,
 
             // LMB is up. The mouse is hovering over the button. Regardless of what the
             // state was last update, the state should definitely be Highlighted now.
@@ -141,7 +144,7 @@ mod circular_button {
             // LMB is down, the mouse is not over the button, but the previous state was
             // Clicked. That means the user clicked the button and then moved the mouse
             // outside the button while holding LMB down. The button stays Clicked.
-            (false, Clicked, Down) => Clicked,
+            (false, Clicked, Down(_)) => Clicked,
 
             // If none of the above applies, then nothing interesting is happening with
             // this button.

src/lib.rs

@@ -65,10 +65,13 @@ pub use frame::{Framing, Frameable};
 pub use glyph_cache::{GlyphCache, LineBreak};
 pub use graph::NodeIndex;
 pub use label::{FontSize, Labelable};
-pub use mouse::Mouse;
+
+pub use mouse::{Mouse, MouseButton, NUM_MOUSE_BUTTONS};
+pub use mouse::ButtonMap as MouseButtonMap;
 pub use mouse::ButtonState as MouseButtonState;
 pub use mouse::ButtonPosition as MouseButtonPosition;
-pub use mouse::Scroll as MouseScroll;
+pub use mouse::events::Scroll as MouseScroll;
+pub use mouse::events as simple_mouse_events;
 pub use position::{Align, Corner, Depth, Direction, Dimension, Dimensions, Edge, Margin, Padding,
                    Place, Point, Position, Positionable, Range, Rect, Scalar, Sizeable};
 pub use position::Matrix as PositionMatrix;
@@ -108,10 +111,10 @@ mod widget;
 /// This is the recommended way of generating `WidgetId`s as it greatly lessens the chances of
 /// making errors when adding or removing widget ids.
 ///
-/// Each Widget must have its own unique identifier so that the `Ui` can keep track of its state 
+/// Each Widget must have its own unique identifier so that the `Ui` can keep track of its state
 /// between updates.
 ///
-/// To make this easier, we provide the `widget_ids` macro, which generates a unique `WidgetId` for 
+/// To make this easier, we provide the `widget_ids` macro, which generates a unique `WidgetId` for
 /// each identifier given in the list.
 ///
 /// The `with n` syntax reserves `n` number of `WidgetId`s for that identifier rather than just one.

src/mouse/button_map.rs

@@ -0,0 +1,158 @@
+use super::MouseButton;
+use super::ButtonState;
+use std::slice::{IterMut, Iter};
+use position::Point;
+
+/// The max total number of buttons on a mouse.
+pub const NUM_MOUSE_BUTTONS: usize = 9;
+
+/// A map of `conrod::MouseButton` to `conrod::MouseButtonState`.
+/// Used by the `conrod::Mouse` to hold the state of all mouse buttons.
+#[derive(Copy, Clone, Debug)]
+pub struct ButtonMap {
+    button_states: [ButtonState; NUM_MOUSE_BUTTONS]
+}
+
+impl ButtonMap {
+    /// Returns a new button map with all states set to defaults.
+    pub fn new() -> ButtonMap {
+        ButtonMap{
+            button_states: [ButtonState::new(); NUM_MOUSE_BUTTONS]
+        }
+    }
+
+    /// Returns an immutable reference to the button State
+    /// for the given button.
+    ///
+    /// # Example
+    /// ```
+    /// use conrod::{MouseButton, MouseButtonMap};
+    ///
+    /// let map = MouseButtonMap::new();
+    /// let left_button_state = map.get(MouseButton::Left);
+    /// assert!(left_button_state.is_up());
+    /// ```
+    pub fn get(&self, button: MouseButton) -> &ButtonState {
+        &self.button_states[Self::button_idx(button)]
+    }
+
+    /// Returns a mutable reference to the button state for the given button.
+    ///
+    /// # Example
+    /// ```
+    /// use conrod::{MouseButton, MouseButtonMap};
+    ///
+    /// let mut map = MouseButtonMap::new();
+    /// {
+    ///     let right_button_state = map.get_mut(MouseButton::Right);
+    ///     right_button_state.was_just_pressed = true;
+    /// }
+    /// assert!(map.get(MouseButton::Right).was_just_pressed);
+    /// ```
+    pub fn get_mut(&mut self, button: MouseButton) -> &mut ButtonState {
+        &mut self.button_states[Self::button_idx(button)]
+    }
+
+    /// Simple way to update the ButtonState for a given MouseButton using a closure.
+    ///
+    /// # Example
+    /// ```
+    /// use conrod::{MouseButton, MouseButtonState, MouseButtonMap};
+    ///
+    /// let mut map = MouseButtonMap::new();
+    /// map.update(MouseButton::Right, |state| state.was_just_released = true);
+    /// assert!(map.get(MouseButton::Right).was_just_released);
+    /// ```
+    pub fn update<F: FnOnce(&mut ButtonState)>(&mut self, button: MouseButton, update_fn: F) {
+        let state = self.get_mut(button);
+        update_fn(state);
+    }
+
+    /// Returns a `Vec` containing all the button states in the map, combined
+    /// with their respective buttons.
+    ///
+    /// # Example
+    /// ```
+    /// use conrod::{MouseButton, NUM_MOUSE_BUTTONS, MouseButtonState, MouseButtonMap};
+    ///
+    /// let mut map = MouseButtonMap::new();
+    /// let button_states: Vec<(MouseButton, &MouseButtonState)> = map.all_buttons();
+    /// assert_eq!(NUM_MOUSE_BUTTONS, button_states.len());
+    /// ```
+    pub fn all_buttons(&self) -> Vec<(MouseButton, &ButtonState)> {
+        self.button_states.into_iter().enumerate()
+            .map(|idx_and_state| {
+                (MouseButton::from(idx_and_state.0 as u32), idx_and_state.1)
+            }).collect::<Vec<(MouseButton, &ButtonState)>>()
+    }
+
+    /// returns an iterator over mutable references to all the button states
+    pub fn iter_mut(&mut self) -> IterMut<ButtonState> {
+        self.button_states.iter_mut()
+    }
+
+    /// returns an iterator over immutable references to all the button states
+    pub fn iter(&self) -> Iter<ButtonState> {
+        self.button_states.iter()
+    }
+
+    /// Returns a new `ButtonMap` with all points relative to the
+    /// given `Point`.
+    pub fn relative_to(&self, xy: Point) -> ButtonMap {
+        let mut new_map = self.clone();
+        for mut state in new_map.button_states.iter_mut() {
+            state.event = state.event.map(|evt| evt.relative_to(xy));
+        }
+        new_map
+    }
+
+    fn button_idx(button: MouseButton) -> usize {
+        u32::from(button) as usize
+    }
+}
+
+#[test]
+fn relative_to_changes_all_mouse_events_to_relative_positions() {
+    use input::MouseButton::*;
+    use super::events::*;
+    use super::events::MouseEvent::{Click, Drag};
+    use time::SteadyTime;
+
+    let mut map_a = ButtonMap::new();
+    map_a.update(Left, |state| state.event = Some(Click(MouseClick{
+        mouse_button: Left,
+        position: [10.0, 50.5]
+    })));
+    map_a.update(Button6, |state| state.event = Some(Drag(MouseDragEvent{
+        mouse_button: Button6,
+        start: MouseButtonDown{
+            time: SteadyTime::now(),
+            position: [20.2, 30.0]
+        },
+        current: MouseButtonDown{
+            time: SteadyTime::now(),
+            position: [40.4, 60.0]
+        },
+        button_released: true
+    })));
+
+    let map_b = map_a.relative_to([10.0, 10.0]);
+
+    let left_state = map_b.get(Left);
+    if let Some(Click(click)) = left_state.event {
+        assert_float_eq(0.0, click.position[0]);
+        assert_float_eq(40.5, click.position[1]);
+    } else {
+        panic!("Expected click event, got: {:?}", left_state.event);
+    }
+
+    let state_6 = map_b.get(Button6);
+    if let Some(Drag(drag)) = state_6.event {
+        assert_float_eq(10.2, drag.start.position[0]);
+        assert_float_eq(20.0, drag.start.position[1]);
+        assert_float_eq(30.4, drag.current.position[0]);
+        assert_float_eq(50.0, drag.current.position[1]);
+    } else {
+        panic!("Expected a drag event, but got: {:?}", state_6.event);
+    }
+}