Cargo fix

Cargo.toml

@@ -47,7 +47,7 @@ chrome-trace = [
     "iced_glow?/tracing",
 ]
 # Enables experimental multi-window support
-multi_window = ["iced_winit/multi_window", "iced_glutin/multi_window"]
+multi_window = ["iced_winit/multi_window", "iced_glutin?/multi_window"]
 
 [badges]
 maintenance = { status = "actively-developed" }

examples/multi_window/Cargo.toml

@@ -7,7 +7,7 @@ publish = false
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-iced = { path = "../..", features = ["debug", "multi_window"] }
+iced = { path = "../..", features = ["debug", "multi_window", "tokio"] }
 env_logger = "0.10.0"
 iced_native = { path = "../../native" }
 iced_lazy = { path = "../../lazy" }

examples/multi_window/src/main.rs

@@ -1,5 +1,5 @@
 use iced::alignment::{self, Alignment};
-use iced::executor;
+use iced::{executor, time};
 use iced::keyboard;
 use iced::multi_window::Application;
 use iced::theme::{self, Theme};
@@ -15,6 +15,7 @@ use iced_native::{event, subscription, Event};
 use iced_native::widget::scrollable::{Properties, RelativeOffset};
 use iced_native::window::Id;
 use std::collections::HashMap;
+use std::time::{Duration, Instant};
 
 pub fn main() -> iced::Result {
     env_logger::init();
@@ -25,6 +26,7 @@ pub fn main() -> iced::Result {
 struct Example {
     windows: HashMap<window::Id, Window>,
     panes_created: usize,
+    count: usize,
     _focused: window::Id,
 }
 
@@ -39,6 +41,7 @@ struct Window {
 #[derive(Debug, Clone)]
 enum Message {
     Window(window::Id, WindowMessage),
+    CountIncremented(Instant),
 }
 
 #[derive(Debug, Clone)]
@@ -80,6 +83,7 @@ impl Application for Example {
             Example {
                 windows: HashMap::from([(window::Id::MAIN, window)]),
                 panes_created: 1,
+                count: 0,
                 _focused: window::Id::MAIN,
             },
             Command::none(),
@@ -94,8 +98,8 @@ impl Application for Example {
     }
 
     fn update(&mut self, message: Message) -> Command<Message> {
-        let Message::Window(id, message) = message;
         match message {
+            Message::Window(id, message) => match message {
                 WindowMessage::SnapToggle => {
                     let window = self.windows.get_mut(&id).unwrap();
 
@@ -251,12 +255,17 @@ impl Application for Example {
                         }
                     }
                 }
+            },
+            Message::CountIncremented(_) => {
+                self.count += 1;
+            }
         }
 
         Command::none()
     }
 
     fn subscription(&self) -> Subscription<Message> {
+        Subscription::batch(vec![
             subscription::events_with(|event, status| {
                 if let event::Status::Captured = status {
                     return None;
@@ -273,7 +282,9 @@ impl Application for Example {
                     } // TODO(derezzedex)
                     _ => None,
                 }
-        })
+            }),
+            time::every(Duration::from_secs(1)).map(Message::CountIncremented),
+        ])
     }
 
     fn view(&self, window_id: window::Id) -> Element<Message> {
@@ -335,6 +346,7 @@ impl Application for Example {
                     view_content(
                         id,
                         pane.scrollable_id.clone(),
+                        self.count,
                         total_panes,
                         pane.is_pinned,
                         size,
@@ -453,6 +465,7 @@ impl Pane {
 fn view_content<'a>(
     pane: pane_grid::Pane,
     scrollable_id: scrollable::Id,
+    count: usize,
     total_panes: usize,
     is_pinned: bool,
     size: Size,
@@ -493,6 +506,7 @@ fn view_content<'a>(
     let content = column![
         text(format!("{}x{}", size.width, size.height)).size(24),
         controls,
+        text(format!("{count}")).size(48),
     ]
     .width(Length::Fill)
     .height(800)

winit/src/multi_window.rs

@@ -416,6 +416,7 @@ async fn run_instance<A, E, C>(
             }
             event::Event::MainEventsCleared => {
                 for id in states.keys().copied().collect::<Vec<_>>() {
+                    // Partition events into only events for this window
                     let (filtered, remaining): (Vec<_>, Vec<_>) =
                         events.iter().cloned().partition(
                             |(window_id, _event): &(
@@ -426,7 +427,9 @@ async fn run_instance<A, E, C>(
                             },
                         );
 
+                    // Only retain events which have not been processed for next iteration
                     events.retain(|el| remaining.contains(el));
+
                     let window_events: Vec<_> = filtered
                         .into_iter()
                         .map(|(_id, event)| event)
@@ -439,8 +442,8 @@ async fn run_instance<A, E, C>(
                         continue;
                     }
 
+                    // Process winit events for window
                     debug.event_processing_started();
-
                     let cursor_position =
                         states.get(&id).unwrap().cursor_position();
 
@@ -455,15 +458,16 @@ async fn run_instance<A, E, C>(
                         )
                     };
 
-                    debug.event_processing_finished();
-
                     for event in
                         window_events.into_iter().zip(statuses.into_iter())
                     {
                         runtime.broadcast(event);
                     }
+                    debug.event_processing_finished();
 
-                    // TODO(derezzedex): Should we redraw every window? We can't know what changed.
+                    // Update application with app message(s)
+                    // Note: without tying an app message to a window ID, we must redraw all windows
+                    // as we cannot know what changed without some kind of damage tracking.
                     if !messages.is_empty()
                         || matches!(
                             interface_state,
@@ -498,7 +502,7 @@ async fn run_instance<A, E, C>(
                             || compositor.fetch_information(),
                         );
 
-                        // Update window
+                        // synchronize window state with application state.
                         states.get_mut(&id).unwrap().synchronize(
                             &application,
                             id,
@@ -564,6 +568,7 @@ async fn run_instance<A, E, C>(
 
                     for window in windows.values() {
                         window.request_redraw();
+                    }
 
                     runtime.broadcast((
                         redraw_event.clone(),
@@ -588,7 +593,6 @@ async fn run_instance<A, E, C>(
                     redraw_pending = false;
                 }
             }
-            }
             event::Event::PlatformSpecific(event::PlatformSpecific::MacOS(
                 event::MacOS::ReceivedUrl(url),
             )) => {