Introduce event::Status to Subscription

examples/pane_grid/src/main.rs

@@ -3,7 +3,7 @@ use iced::{
     Button, Column, Command, Container, Element, HorizontalAlignment, Length,
     PaneGrid, Scrollable, Settings, Subscription, Text,
 };
-use iced_native::{subscription, Event};
+use iced_native::{event, subscription, Event};
 
 pub fn main() -> iced::Result {
     Example::run(Settings::default())
@@ -119,12 +119,18 @@ impl Application for Example {
     }
 
     fn subscription(&self) -> Subscription<Message> {
-        subscription::events_with(|event| match event {
+        subscription::events_with(|event, status| {
-            Event::Keyboard(keyboard::Event::KeyPressed {
+            if let event::Status::Captured = status {
-                modifiers,
+                return None;
-                key_code,
+            }
-            }) if modifiers.is_command_pressed() => handle_hotkey(key_code),
+
-            _ => None,
+            match event {
+                Event::Keyboard(keyboard::Event::KeyPressed {
+                    modifiers,
+                    key_code,
+                }) if modifiers.is_command_pressed() => handle_hotkey(key_code),
+                _ => None,
+            }
         })
     }
 

glutin/src/application.rs

@@ -277,7 +277,7 @@ async fn run_instance<A, E, C>(
                     state.scale_factor(),
                     state.modifiers(),
                 ) {
-                    let _ = user_interface.update(
+                    let event_status = user_interface.update(
                         event.clone(),
                         state.cursor_position(),
                         clipboard.as_ref().map(|c| c as _),
@@ -285,7 +285,7 @@ async fn run_instance<A, E, C>(
                         &mut messages,
                     );
 
-                    runtime.broadcast(event);
+                    runtime.broadcast((event, event_status));
 
                     is_clean = false;
                 }

native/src/runtime.rs

@@ -1,5 +1,6 @@
 //! Run commands and subscriptions.
-use crate::{Event, Hasher};
+use crate::event::{self, Event};
+use crate::Hasher;
 
 /// A native runtime with a generic executor and receiver of results.
 ///
@@ -8,5 +9,10 @@ use crate::{Event, Hasher};
 ///
 /// [`Command`]: ../struct.Command.html
 /// [`Subscription`]: ../struct.Subscription.html
-pub type Runtime<Executor, Receiver, Message> =
+pub type Runtime<Executor, Receiver, Message> = iced_futures::Runtime<
-    iced_futures::Runtime<Hasher, Event, Executor, Receiver, Message>;
+    Hasher,
+    (Event, event::Status),
+    Executor,
+    Receiver,
+    Message,
+>;

native/src/subscription.rs

@@ -1,5 +1,6 @@
 //! Listen to external events in your application.
-use crate::{Event, Hasher};
+use crate::event::{self, Event};
+use crate::Hasher;
 use iced_futures::futures::stream::BoxStream;
 
 /// A request to listen to external events.
@@ -15,19 +16,21 @@ use iced_futures::futures::stream::BoxStream;
 ///
 /// [`Command`]: ../struct.Command.html
 /// [`Subscription`]: struct.Subscription.html
-pub type Subscription<T> = iced_futures::Subscription<Hasher, Event, T>;
+pub type Subscription<T> =
+    iced_futures::Subscription<Hasher, (Event, event::Status), T>;
 
 /// A stream of runtime events.
 ///
 /// It is the input of a [`Subscription`] in the native runtime.
 ///
 /// [`Subscription`]: type.Subscription.html
-pub type EventStream = BoxStream<'static, Event>;
+pub type EventStream = BoxStream<'static, (Event, event::Status)>;
 
 /// A native [`Subscription`] tracker.
 ///
 /// [`Subscription`]: type.Subscription.html
-pub type Tracker = iced_futures::subscription::Tracker<Hasher, Event>;
+pub type Tracker =
+    iced_futures::subscription::Tracker<Hasher, (Event, event::Status)>;
 
 pub use iced_futures::subscription::Recipe;
 
@@ -37,13 +40,18 @@ use events::Events;
 
 /// Returns a [`Subscription`] to all the runtime events.
 ///
-/// This subscription will notify your application of any [`Event`] handled by
+/// This subscription will notify your application of any [`Event`] that was
-/// the runtime.
+/// not captured by any widget.
 ///
 /// [`Subscription`]: type.Subscription.html
 /// [`Event`]: ../enum.Event.html
 pub fn events() -> Subscription<Event> {
-    Subscription::from_recipe(Events { f: Some })
+    Subscription::from_recipe(Events {
+        f: |event, status| match status {
+            event::Status::Ignored => Some(event),
+            event::Status::Captured => None,
+        },
+    })
 }
 
 /// Returns a [`Subscription`] that filters all the runtime events with the
@@ -58,7 +66,7 @@ pub fn events() -> Subscription<Event> {
 /// [`Subscription`]: type.Subscription.html
 /// [`Event`]: ../enum.Event.html
 pub fn events_with<Message>(
-    f: fn(Event) -> Option<Message>,
+    f: fn(Event, event::Status) -> Option<Message>,
 ) -> Subscription<Message>
 where
     Message: 'static + Send,

native/src/subscription/events.rs

@@ -1,16 +1,15 @@
-use crate::{
+use crate::event::{self, Event};
-    subscription::{EventStream, Recipe},
+use crate::subscription::{EventStream, Recipe};
-    Event, Hasher,
+use crate::Hasher;
-};
 use iced_futures::futures::future;
 use iced_futures::futures::StreamExt;
 use iced_futures::BoxStream;
 
 pub struct Events<Message> {
-    pub(super) f: fn(Event) -> Option<Message>,
+    pub(super) f: fn(Event, event::Status) -> Option<Message>,
 }
 
-impl<Message> Recipe<Hasher, Event> for Events<Message>
+impl<Message> Recipe<Hasher, (Event, event::Status)> for Events<Message>
 where
     Message: 'static + Send,
 {
@@ -29,7 +28,9 @@ where
         event_stream: EventStream,
     ) -> BoxStream<Self::Output> {
         event_stream
-            .filter_map(move |event| future::ready((self.f)(event)))
+            .filter_map(move |(event, status)| {
+                future::ready((self.f)(event, status))
+            })
             .boxed()
     }
 }

winit/src/application.rs

@@ -359,7 +359,7 @@ async fn run_instance<A, E, C>(
                     state.scale_factor(),
                     state.modifiers(),
                 ) {
-                    let _ = user_interface.update(
+                    let event_status = user_interface.update(
                         event.clone(),
                         state.cursor_position(),
                         clipboard.as_ref().map(|c| c as _),
@@ -367,7 +367,7 @@ async fn run_instance<A, E, C>(
                         &mut messages,
                     );
 
-                    runtime.broadcast(event);
+                    runtime.broadcast((event, event_status));
 
                     is_clean = false;
                 }