Merge pull request #698 from mitchmindtree/events_tweaks

Tweaks to events API following #684

Author: mitchmindtree

src/events/global_input.rs

@@ -25,8 +25,10 @@ pub struct GlobalInput {
 /// of the window.
 pub type GlobalInputEventIterator<'a> = ::std::slice::Iter<'a, UiEvent>;
 
-impl <'a> InputProvider<'a, GlobalInputEventIterator<'a>> for GlobalInput {
-    fn all_events(&'a self) -> GlobalInputEventIterator {
+impl<'a> InputProvider<'a> for GlobalInput {
+    type Events = GlobalInputEventIterator<'a>;
+
+    fn all_events(&'a self) -> Self::Events {
         self.events.iter()
     }
 

src/events/input_provider.rs

@@ -5,15 +5,20 @@ use input::{Input, Button};
 use input::keyboard::Key;
 use input::mouse::MouseButton;
 use position::Point;
+use std::marker::PhantomData;
 
 
 /// Trait for something that provides events to be consumed by a widget.
+///
 /// Provides a bunch of convenience methods for filtering out specific types of events.
-pub trait InputProvider<'a, T: Iterator<Item=&'a UiEvent>> {
+pub trait InputProvider<'a> {
+    /// An iterator yielding references to the `InputProvider`'s `UiEvent`s.
+    type Events: Iterator<Item=&'a UiEvent>;
+
     /// This is the only method that needs to be implemented.
     /// Just provided a reference to a `Vec<UiEvent>` that contains
     /// all the events for this update cycle.
-    fn all_events(&'a self) -> T;
+    fn all_events(&'a self) -> Self::Events;
 
     /// Returns the current input state. The returned state is assumed to be up to
     /// date with all of the events so far.
@@ -27,54 +32,43 @@ pub trait InputProvider<'a, T: Iterator<Item=&'a UiEvent>> {
     // Methods that just check the stream of events //
     //////////////////////////////////////////////////
 
-    /// Returns a `String` containing _all_ the text that was entered since
-    /// the last update cycle.
-    fn text_just_entered(&'a self) -> Option<String> {
-        let all_text: String = self.all_events().filter_map(|evt| {
-            match *evt {
-                UiEvent::Raw(Input::Text(ref text)) => Some(text),
-                _ => None
-            }
-        }).fold(String::new(), |acc, item| {
-            acc + item
-        });
-
-        if all_text.is_empty() {
-            None
-        } else {
-            Some(all_text)
+    /// Returns a reference to each slice of `Text` that was entered since the last update.
+    fn text_just_entered(&'a self) -> TextJustEntered<'a, Self::Events> {
+        TextJustEntered {
+            events: self.all_events(),
+            lifetime: PhantomData,
         }
     }
 
     /// Returns all of the `Key`s that were released since the last update.
-    fn keys_just_released(&'a self) -> KeysJustReleased<'a, T> {
+    fn keys_just_released(&'a self) -> KeysJustReleased<'a, Self::Events> {
         KeysJustReleased{
             event_iter: self.all_events(),
-            lifetime: ::std::marker::PhantomData
+            lifetime: PhantomData
         }
     }
 
     /// Returns all of the keyboard `Key`s that were pressed since the last update.
-    fn keys_just_pressed(&'a self) -> KeysJustPressed<'a, T> {
+    fn keys_just_pressed(&'a self) -> KeysJustPressed<'a, Self::Events> {
         KeysJustPressed {
             event_iter: self.all_events(),
-            lifetime: ::std::marker::PhantomData
+            lifetime: PhantomData
         }
     }
 
     /// Returns all of the `MouseButton`s that were pressed since the last update.
-    fn mouse_buttons_just_pressed(&'a self) -> MouseButtonsJustPressed<'a, T> {
+    fn mouse_buttons_just_pressed(&'a self) -> MouseButtonsJustPressed<'a, Self::Events> {
         MouseButtonsJustPressed {
             event_iter: self.all_events(),
-            lifetime: ::std::marker::PhantomData
+            lifetime: PhantomData
         }
     }
 
     /// Returns all of the `MouseButton`s that were released since the last update.
-    fn mouse_buttons_just_released(&'a self) -> MouseButtonsJustReleased<'a, T> {
+    fn mouse_buttons_just_released(&'a self) -> MouseButtonsJustReleased<'a, Self::Events> {
         MouseButtonsJustReleased {
             event_iter: self.all_events(),
-            lifetime: ::std::marker::PhantomData
+            lifetime: PhantomData
         }
     }
 
@@ -173,11 +167,34 @@ pub trait InputProvider<'a, T: Iterator<Item=&'a UiEvent>> {
 
 }
 
+/// An iterator yielding the `&str` of each `Text` event's `String` that was just entered.
+#[derive(Clone, Debug)]
+pub struct TextJustEntered<'a, I>
+    where I: Iterator<Item=&'a UiEvent>,
+{
+    events: I,
+    lifetime: PhantomData<&'a ()>,
+}
+
+impl<'a, I> Iterator for TextJustEntered<'a, I>
+    where I: Iterator<Item=&'a UiEvent>,
+{
+    type Item=&'a str;
+    fn next(&mut self) -> Option<Self::Item> {
+        while let Some(event) = self.events.next() {
+            if let UiEvent::Raw(Input::Text(ref text)) = *event {
+                return Some(text);
+            }
+        }
+        None
+    }
+}
+
 /// An Iterator over `input::keyboard::Key`s that were just released.
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct KeysJustReleased<'a, T: Iterator<Item=&'a UiEvent> + Sized> {
     event_iter: T,
-    lifetime: ::std::marker::PhantomData<&'a ()>
+    lifetime: PhantomData<&'a ()>
 }
 
 impl<'a, T> Iterator for KeysJustReleased<'a, T> where T: Iterator<Item=&'a UiEvent> + Sized {
@@ -194,10 +211,10 @@ impl<'a, T> Iterator for KeysJustReleased<'a, T> where T: Iterator<Item=&'a UiEv
 }
 
 /// An Iterator over `input::keyboard::Key`s that were just pressed.
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct KeysJustPressed<'a, T: Iterator<Item=&'a UiEvent> + Sized> {
     event_iter: T,
-    lifetime: ::std::marker::PhantomData<&'a ()>
+    lifetime: PhantomData<&'a ()>
 }
 
 impl<'a, T> Iterator for KeysJustPressed<'a, T> where T: Iterator<Item=&'a UiEvent> + Sized {
@@ -214,10 +231,10 @@ impl<'a, T> Iterator for KeysJustPressed<'a, T> where T: Iterator<Item=&'a UiEve
 }
 
 /// An Iterator over `input::mouse::MouseButton`s that were just pressed.
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct MouseButtonsJustPressed<'a, T: Iterator<Item=&'a UiEvent> + Sized> {
     event_iter: T,
-    lifetime: ::std::marker::PhantomData<&'a ()>
+    lifetime: PhantomData<&'a ()>
 }
 
 impl<'a, T> Iterator for MouseButtonsJustPressed<'a, T> where T: Iterator<Item=&'a UiEvent> + Sized {
@@ -234,10 +251,10 @@ impl<'a, T> Iterator for MouseButtonsJustPressed<'a, T> where T: Iterator<Item=&
 }
 
 /// An Iterator over `input::mouse::MouseButton`s that were just released.
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct MouseButtonsJustReleased<'a, T: Iterator<Item=&'a UiEvent> + Sized> {
     event_iter: T,
-    lifetime: ::std::marker::PhantomData<&'a ()>
+    lifetime: PhantomData<&'a ()>
 }
 
 impl<'a, T> Iterator for MouseButtonsJustReleased<'a, T> where T: Iterator<Item=&'a UiEvent> + Sized {

src/events/mod.rs

@@ -1,6 +1,6 @@
 //! This module contains all the logic for handling input events and providing them to widgets.
 //! All user input is provided to the `Ui` in the form of `input::Input` events, which are continuously
-//! polled from the backend window implementation. These raw input events tent to be fairly low level.
+//! polled from the backend window implementation. These raw input events tend to be fairly low level.
 //! The `Ui` passes each of these events off to it's `GlobalInput`, which keeps track of the state of
 //! affairs for the entire `Ui`. `GlobalInput` will also aggregate the low level events into higher
 //! level ones. For instance, two events indicating that a mouse button was pressed then released

src/events/widget_input.rs

@@ -87,13 +87,13 @@ impl<'a> Iterator for WidgetInputEventIterator<'a> {
             }
         })
     }
-
 }
 
 
-impl<'a> InputProvider<'a, WidgetInputEventIterator<'a>> for WidgetInput<'a> {
+impl<'a> InputProvider<'a> for WidgetInput<'a> {
+    type Events = WidgetInputEventIterator<'a>;
 
-    fn all_events(&'a self) -> WidgetInputEventIterator<'a> {
+    fn all_events(&'a self) -> Self::Events {
         WidgetInputEventIterator{
             global_event_iter: self.global_input.all_events(),
             current_state: self.global_input.start_state.relative_to(self.widget_area.xy()),

src/tests/global_input.rs

@@ -109,7 +109,7 @@ fn entered_text_should_be_aggregated_from_multiple_events() {
     input.push_event(UiEvent::Raw(Input::Text("is a".to_string())));
     input.push_event(UiEvent::Raw(Input::Text("wesome".to_string())));
 
-    let actual_text = input.text_just_entered().expect("expected to get a String, got None");
+    let actual_text: String = input.text_just_entered().collect();
     assert_eq!("Phil is awesome".to_string(), actual_text);
 }
 

src/tests/input_provider.rs

@@ -185,8 +185,10 @@ impl ProviderImpl {
 pub type TestInputEventIterator<'a> = ::std::slice::Iter<'a, UiEvent>;
 
 
-impl<'a> InputProvider<'a, TestInputEventIterator<'a>> for ProviderImpl {
-    fn all_events(&'a self) -> TestInputEventIterator<'a> {
+impl<'a> InputProvider<'a> for ProviderImpl {
+    type Events = TestInputEventIterator<'a>;
+
+    fn all_events(&'a self) -> Self::Events {
         self.events.iter()
     }
 

src/tests/widget_input.rs

@@ -156,13 +156,14 @@ fn widget_input_should_only_provide_keyboard_input_to_widget_that_has_focus() {
     global_input.push_event(UiEvent::Raw(Input::Text("some text".to_string())));
 
     let widget_4_input = WidgetInput::for_widget(widget_4, some_rect, &global_input);
-    let widget_4_text = widget_4_input.text_just_entered();
-    assert_eq!(Some("some text".to_string()), widget_4_text);
+    let widget_4_text: String = widget_4_input.text_just_entered().collect();
+    assert_eq!("some text".to_string(), widget_4_text);
 
     let another_widget_input = WidgetInput::for_widget(Index::Public(Id(7)),
             some_rect,
             &global_input);
-    assert!(another_widget_input.text_just_entered().is_none());
+    let another_widget_text: String = another_widget_input.text_just_entered().collect();
+    assert_eq!("".to_string(), another_widget_text);
 }
 
 #[test]