From 6151c528241d0a6ece88e6e664df1b50f8174ecb Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector0193@gmail.com>
Date: Tue, 10 Mar 2020 02:57:13 +0100
Subject: Rename `Panes` widget to `PaneGrid`

---
 examples/panes/src/main.rs | 179 ---------------------------------------------
 1 file changed, 179 deletions(-)
 delete mode 100644 examples/panes/src/main.rs

(limited to 'examples/panes/src')

diff --git a/examples/panes/src/main.rs b/examples/panes/src/main.rs
deleted file mode 100644
index 34206a2c..00000000
--- a/examples/panes/src/main.rs
+++ /dev/null
@@ -1,179 +0,0 @@
-use iced::{
-    panes, Application, Command, Element, Panes, 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: panes::State<Example>,
-}
-
-#[derive(Debug)]
-enum Example {
-    Clock(Clock),
-    Stopwatch(Stopwatch),
-}
-
-#[derive(Debug, Clone)]
-enum Message {
-    Clock(panes::Pane, clock::Message),
-    Stopwatch(panes::Pane, stopwatch::Message),
-    Split(panes::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, _) = panes::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(panes::Split::Horizontal)),
-            events::key_released(keyboard::KeyCode::V)
-                .map(|_| Message::Split(panes::Split::Vertical)),
-            events::key_released(keyboard::KeyCode::Q).map(|_| Message::Close),
-            panes_subscriptions,
-        ])
-    }
-
-    fn view(&mut self) -> Element<Message> {
-        let Self { panes } = self;
-
-        Panes::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()
-        }
-    }
-}
-- 
cgit