Rename Panes widget to PaneGrid

examples/pane_grid/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "pane_grid"
+version = "0.1.0"
+authors = ["Héctor Ramón Jiménez <hector0193@gmail.com>"]
+edition = "2018"
+publish = false
+
+[dependencies]
+iced = { path = "../..", features = ["async-std"] }
+iced_native = { path = "../../native" }
+clock = { path = "../clock" }
+stopwatch = { path = "../stopwatch" }

examples/pane_grid/README.md

@@ -0,0 +1,18 @@
+## Counter
+
+The classic counter example explained in the [`README`](../../README.md).
+
+The __[`main`]__ file contains all the code of the example.
+
+<div align="center">
+  <a href="https://gfycat.com/fairdeadcatbird">
+    <img src="https://thumbs.gfycat.com/FairDeadCatbird-small.gif">
+  </a>
+</div>
+
+You can run it with `cargo run`:
+```
+cargo run --package counter
+```
+
+[`main`]: src/main.rs

examples/pane_grid/src/main.rs

@@ -0,0 +1,179 @@
+use iced::{
+    pane_grid, Application, Command, Element, PaneGrid, Settings, Subscription,
+};
+use iced_native::input::keyboard;
+
+use clock::{self, Clock};
+use stopwatch::{self, Stopwatch};
+
+pub fn main() {
+    Launcher::run(Settings {
+        antialiasing: true,
+        ..Settings::default()
+    })
+}
+
+#[derive(Debug)]
+struct Launcher {
+    panes: pane_grid::State<Example>,
+}
+
+#[derive(Debug)]
+enum Example {
+    Clock(Clock),
+    Stopwatch(Stopwatch),
+}
+
+#[derive(Debug, Clone)]
+enum Message {
+    Clock(pane_grid::Pane, clock::Message),
+    Stopwatch(pane_grid::Pane, stopwatch::Message),
+    Split(pane_grid::Split),
+    Close,
+}
+
+impl Application for Launcher {
+    type Executor = iced::executor::Default;
+    type Message = Message;
+
+    fn new() -> (Self, Command<Message>) {
+        let (clock, _) = Clock::new();
+        let (panes, _) = pane_grid::State::new(Example::Clock(clock));
+
+        (Self { panes }, Command::none())
+    }
+
+    fn title(&self) -> String {
+        String::from("Panes - Iced")
+    }
+
+    fn update(&mut self, message: Message) -> Command<Message> {
+        match message {
+            Message::Clock(pane, message) => {
+                if let Some(Example::Clock(clock)) = self.panes.get_mut(&pane) {
+                    let _ = clock.update(message);
+                }
+            }
+            Message::Stopwatch(pane, message) => {
+                if let Some(Example::Stopwatch(stopwatch)) =
+                    self.panes.get_mut(&pane)
+                {
+                    let _ = stopwatch.update(message);
+                }
+            }
+            Message::Split(kind) => {
+                if let Some(pane) = self.panes.focused_pane() {
+                    let state = if pane.index() % 2 == 0 {
+                        let (stopwatch, _) = Stopwatch::new();
+
+                        Example::Stopwatch(stopwatch)
+                    } else {
+                        let (clock, _) = Clock::new();
+
+                        Example::Clock(clock)
+                    };
+
+                    self.panes.split(kind, &pane, state);
+                }
+            }
+            Message::Close => {
+                if let Some(pane) = self.panes.focused_pane() {
+                    self.panes.close(&pane);
+                }
+            }
+        }
+
+        Command::none()
+    }
+
+    fn subscription(&self) -> Subscription<Message> {
+        let panes_subscriptions =
+            Subscription::batch(self.panes.iter().map(|(pane, example)| {
+                match example {
+                    Example::Clock(clock) => clock
+                        .subscription()
+                        .with(pane)
+                        .map(|(pane, message)| Message::Clock(pane, message)),
+
+                    Example::Stopwatch(stopwatch) => {
+                        stopwatch.subscription().with(pane).map(
+                            |(pane, message)| Message::Stopwatch(pane, message),
+                        )
+                    }
+                }
+            }));
+
+        Subscription::batch(vec![
+            events::key_released(keyboard::KeyCode::H)
+                .map(|_| Message::Split(pane_grid::Split::Horizontal)),
+            events::key_released(keyboard::KeyCode::V)
+                .map(|_| Message::Split(pane_grid::Split::Vertical)),
+            events::key_released(keyboard::KeyCode::Q).map(|_| Message::Close),
+            panes_subscriptions,
+        ])
+    }
+
+    fn view(&mut self) -> Element<Message> {
+        let Self { panes } = self;
+
+        PaneGrid::new(panes, |pane, example| match example {
+            Example::Clock(clock) => clock
+                .view()
+                .map(move |message| Message::Clock(pane, message)),
+
+            Example::Stopwatch(stopwatch) => stopwatch
+                .view()
+                .map(move |message| Message::Stopwatch(pane, message)),
+        })
+        .into()
+    }
+}
+
+mod events {
+    use iced_native::{
+        futures::{
+            self,
+            stream::{BoxStream, StreamExt},
+        },
+        input::{keyboard, ButtonState},
+        subscription, Event, Hasher, Subscription,
+    };
+
+    pub fn key_released(key_code: keyboard::KeyCode) -> Subscription<()> {
+        Subscription::from_recipe(KeyReleased { key_code })
+    }
+
+    struct KeyReleased {
+        key_code: keyboard::KeyCode,
+    }
+
+    impl subscription::Recipe<Hasher, Event> for KeyReleased {
+        type Output = ();
+
+        fn hash(&self, state: &mut Hasher) {
+            use std::hash::Hash;
+
+            std::any::TypeId::of::<Self>().hash(state);
+            self.key_code.hash(state);
+        }
+
+        fn stream(
+            self: Box<Self>,
+            events: subscription::EventStream,
+        ) -> BoxStream<'static, Self::Output> {
+            events
+                .filter(move |event| match event {
+                    Event::Keyboard(keyboard::Event::Input {
+                        key_code,
+                        state: ButtonState::Released,
+                        ..
+                    }) if *key_code == self.key_code => {
+                        futures::future::ready(true)
+                    }
+                    _ => futures::future::ready(false),
+                })
+                .map(|_| ())
+                .boxed()
+        }
+    }
+}