Update iced example to 0.13 (#145)

Author: Exidex

Cargo.toml

@@ -46,5 +46,5 @@ x11-dl = "2.21"
 winit = "0.30"
 tao = "0.30"
 eframe = "0.27"
-iced = "0.12.1"
+iced = "0.13.1"
 async-std = "1.12.0"

examples/iced.rs

@@ -1,12 +1,16 @@
 use global_hotkey::hotkey::{Code, HotKey, Modifiers};
 use global_hotkey::{GlobalHotKeyEvent, GlobalHotKeyManager};
 
-use iced::futures::SinkExt;
+use iced::futures::{SinkExt, Stream};
+use iced::stream::channel;
 use iced::widget::{container, row, text};
-use iced::{executor, Application, Command, Element, Subscription, Theme};
+use iced::{application, Element, Subscription, Task, Theme};
 
 fn main() -> iced::Result {
-    Example::run(iced::Settings::default())
+    application("Iced Example!", update, view)
+        .subscription(subscription)
+        .theme(|_| Theme::Dark)
+        .run_with(new)
 }
 
 struct Example {
@@ -21,67 +25,58 @@ enum ProgramCommands {
     Received(String),
 }
 
-impl Application for Example {
-    type Executor = executor::Default;
-    type Message = ProgramCommands;
-    type Theme = Theme;
-    type Flags = ();
+fn new() -> (Example, Task<ProgramCommands>) {
+    let manager = GlobalHotKeyManager::new().unwrap();
+    let hotkey_1 = HotKey::new(Some(Modifiers::CONTROL), Code::ArrowRight);
+    let hotkey_2 = HotKey::new(None, Code::ArrowUp);
 
-    fn new(_flags: Self::Flags) -> (Example, iced::Command<Self::Message>) {
-        let manager = GlobalHotKeyManager::new().unwrap();
-        let hotkey_1 = HotKey::new(Some(Modifiers::CONTROL), Code::ArrowRight);
-        let hotkey_2 = HotKey::new(None, Code::ArrowUp);
+    manager.register(hotkey_1).unwrap();
+    manager.register(hotkey_2).unwrap();
 
-        manager.register(hotkey_1).unwrap();
-        manager.register(hotkey_2).unwrap();
-        (
-            Example {
-                last_pressed: "".to_string(),
-                _manager: manager,
-            },
-            Command::none(),
-        )
-    }
-    fn title(&self) -> String {
-        String::from("Iced example!")
-    }
+    (
+        Example {
+            last_pressed: "".to_string(),
+            _manager: manager,
+        },
+        Task::none(),
+    )
+}
 
-    fn theme(&self) -> Self::Theme {
-        Theme::Dark // dark theme :D
-    }
-    fn update(&mut self, msg: Self::Message) -> iced::Command<ProgramCommands> {
-        match msg {
-            Self::Message::Received(code) => {
-                // update the text widget
-                self.last_pressed = code.to_string();
+fn update(state: &mut Example, msg: ProgramCommands) -> Task<ProgramCommands> {
+    match msg {
+        ProgramCommands::Received(code) => {
+            // update the text widget
+            state.last_pressed = code.to_string();
 
-                Command::none()
-            }
+            Task::none()
         }
     }
-    fn view(&self) -> Element<'_, Self::Message> {
-        container(row![text("You pressed: "), text(self.last_pressed.clone())]).into()
-    }
+}
 
-    fn subscription(&self) -> Subscription<Self::Message> {
-        self.hotkey_sub()
-    }
+fn view(state: &Example) -> Element<'_, ProgramCommands> {
+    container(row![
+        text("You pressed: "),
+        text(state.last_pressed.clone())
+    ])
+    .into()
+}
+
+fn subscription(_state: &Example) -> Subscription<ProgramCommands> {
+    Subscription::run(hotkey_sub)
 }
 
-impl Example {
-    pub fn hotkey_sub(&self) -> Subscription<ProgramCommands> {
-        iced::subscription::channel(0, 32, |mut sender| async move {
-            let receiver = GlobalHotKeyEvent::receiver();
-            // poll for global hotkey events every 50ms
-            loop {
-                if let Ok(event) = receiver.try_recv() {
-                    sender
-                        .send(ProgramCommands::Received(format!("{:?}", event)))
-                        .await
-                        .unwrap();
-                }
-                async_std::task::sleep(std::time::Duration::from_millis(50)).await;
+fn hotkey_sub() -> impl Stream<Item = ProgramCommands> {
+    channel(32, |mut sender| async move {
+        let receiver = GlobalHotKeyEvent::receiver();
+        // poll for global hotkey events every 50ms
+        loop {
+            if let Ok(event) = receiver.try_recv() {
+                sender
+                    .send(ProgramCommands::Received(format!("{:?}", event)))
+                    .await
+                    .unwrap();
             }
-        })
-    }
+            async_std::task::sleep(std::time::Duration::from_millis(50)).await;
+        }
+    })
 }