Restore hotkeys in pane_grid example

- Implement `subscription::events_with`
- Remove `pane_grid::KeyPressEvent`
- Return closest sibling in `pane_grid::State::close`

native/src/subscription.rs

@@ -43,5 +43,25 @@ use events::Events;
 /// [`Subscription`]: type.Subscription.html
 /// [`Event`]: ../enum.Event.html
 pub fn events() -> Subscription<Event> {
-    Subscription::from_recipe(Events)
+    Subscription::from_recipe(Events { f: Some })
+}
+
+/// Returns a [`Subscription`] that filters all the runtime events with the
+/// provided function, producing messages accordingly.
+///
+/// This subscription will call the provided function for every [`Event`]
+/// handled by the runtime. If the function:
+///
+/// - Returns `None`, the [`Event`] will be discarded.
+/// - Returns `Some` message, the `Message` will be produced.
+///
+/// [`Subscription`]: type.Subscription.html
+/// [`Event`]: ../enum.Event.html
+pub fn events_with<Message>(
+    f: fn(Event) -> Option<Message>,
+) -> Subscription<Message>
+where
+    Message: 'static + Send,
+{
+    Subscription::from_recipe(Events { f })
 }

native/src/subscription/events.rs

@@ -2,17 +2,26 @@ use crate::{
     subscription::{EventStream, Recipe},
     Event, Hasher,
 };
+use iced_futures::futures::future;
+use iced_futures::futures::StreamExt;
 use iced_futures::BoxStream;
 
-pub struct Events;
+pub struct Events<Message> {
+    pub(super) f: fn(Event) -> Option<Message>,
+}
 
-impl Recipe<Hasher, Event> for Events {
-    type Output = Event;
+impl<Message> Recipe<Hasher, Event> for Events<Message>
+where
+    Message: 'static + Send,
+{
+    type Output = Message;
 
     fn hash(&self, state: &mut Hasher) {
         use std::hash::Hash;
 
-        std::any::TypeId::of::<Self>().hash(state);
+        struct Marker;
+        std::any::TypeId::of::<Marker>().hash(state);
+        self.f.hash(state);
     }
 
     fn stream(
@@ -20,5 +29,7 @@ impl Recipe<Hasher, Event> for Events {
         event_stream: EventStream,
     ) -> BoxStream<Self::Output> {
         event_stream
+            .filter_map(move |event| future::ready((self.f)(event)))
+            .boxed()
     }
 }

native/src/widget/pane_grid.rs

@@ -29,8 +29,8 @@ pub use state::{Focus, State};
 pub use title_bar::TitleBar;
 
 use crate::{
-    container, keyboard, layout, mouse, overlay, row, text, Clipboard, Element,
-    Event, Hasher, Layout, Length, Point, Rectangle, Size, Vector, Widget,
+    container, layout, mouse, overlay, row, text, Clipboard, Element, Event,
+    Hasher, Layout, Length, Point, Rectangle, Size, Vector, Widget,
 };
 
 /// A collection of panes distributed using either vertical or horizontal splits
@@ -336,18 +336,6 @@ pub struct ResizeEvent {
     pub ratio: f32,
 }
 
-/// An event produced during a key press interaction of a [`PaneGrid`].
-///
-/// [`PaneGrid`]: struct.PaneGrid.html
-#[derive(Debug, Clone, Copy)]
-pub struct KeyPressEvent {
-    /// The key that was pressed.
-    pub key_code: keyboard::KeyCode,
-
-    /// The state of the modifier keys when the key was pressed.
-    pub modifiers: keyboard::ModifiersState,
-}
-
 impl<'a, Message, Renderer> Widget<Message, Renderer>
     for PaneGrid<'a, Message, Renderer>
 where

native/src/widget/pane_grid/state.rs

@@ -227,12 +227,13 @@ impl<T> State<T> {
         let _ = self.internal.layout.resize(split, ratio);
     }
 
-    /// Closes the given [`Pane`] and returns its internal state, if it exists.
+    /// Closes the given [`Pane`] and returns its internal state and its closest
+    /// sibling, if it exists.
     ///
     /// [`Pane`]: struct.Pane.html
-    pub fn close(&mut self, pane: &Pane) -> Option<T> {
-        if let Some(_) = self.internal.layout.remove(pane) {
-            self.panes.remove(pane)
+    pub fn close(&mut self, pane: &Pane) -> Option<(T, Pane)> {
+        if let Some(sibling) = self.internal.layout.remove(pane) {
+            self.panes.remove(pane).map(|state| (state, sibling))
         } else {
             None
         }