Remove `pane_grid` example for now

It's too contrived. I will work on something simpler.

3 files changed, 0 insertions, 209 deletions

diff --git a/examples/pane_grid/Cargo.toml b/examples/pane_grid/Cargo.toml
deleted file mode 100644
index 6d8573bd..00000000
--- a/examples/pane_grid/Cargo.toml
+++ /dev/null
@@ -1,12 +0,0 @@
-[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" }
diff --git a/examples/pane_grid/README.md b/examples/pane_grid/README.md
deleted file mode 100644
index 4d9fc5b9..00000000
--- a/examples/pane_grid/README.md
+++ /dev/null
@@ -1,18 +0,0 @@
-## 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
diff --git a/examples/pane_grid/src/main.rs b/examples/pane_grid/src/main.rs
deleted file mode 100644
index eb8aaa51..00000000
--- a/examples/pane_grid/src/main.rs
+++ /dev/null
@@ -1,179 +0,0 @@
-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()
-        }
-    }
-}