refactored window storage;

new helper window events (Destroyed, Created);
clippy + fmt;

runtime/Cargo.toml

@@ -9,6 +9,7 @@ repository = "https://github.com/iced-rs/iced"
 
 [features]
 debug = []
+multi-window = []
 
 [dependencies]
 thiserror = "1"

runtime/src/lib.rs

@@ -53,6 +53,9 @@ pub mod system;
 pub mod user_interface;
 pub mod window;
 
+#[cfg(feature = "multi-window")]
+pub mod multi_window;
+
 // We disable debug capabilities on release builds unless the `debug` feature
 // is explicitly enabled.
 #[cfg(feature = "debug")]

runtime/src/multi_window.rs

@@ -0,0 +1,6 @@
+//! A multi-window application.
+pub mod program;
+pub mod state;
+
+pub use program::Program;
+pub use state::State;

runtime/src/multi_window/program.rs

@@ -0,0 +1,32 @@
+//! Build interactive programs using The Elm Architecture.
+use crate::{window, Command};
+
+use crate::core::text;
+use crate::core::{Element, Renderer};
+
+/// The core of a user interface for a multi-window application following The Elm Architecture.
+pub trait Program: Sized {
+    /// The graphics backend to use to draw the [`Program`].
+    type Renderer: Renderer + text::Renderer;
+
+    /// The type of __messages__ your [`Program`] will produce.
+    type Message: std::fmt::Debug + Send;
+
+    /// Handles a __message__ and updates the state of the [`Program`].
+    ///
+    /// This is where you define your __update logic__. All the __messages__,
+    /// produced by either user interactions or commands, will be handled by
+    /// this method.
+    ///
+    /// Any [`Command`] returned will be executed immediately in the
+    /// background by shells.
+    fn update(&mut self, message: Self::Message) -> Command<Self::Message>;
+
+    /// Returns the widgets to display in the [`Program`] for the `window`.
+    ///
+    /// These widgets can produce __messages__ based on user interaction.
+    fn view(
+        &self,
+        window: window::Id,
+    ) -> Element<'_, Self::Message, Self::Renderer>;
+}

runtime/src/multi_window/state.rs

@@ -0,0 +1,280 @@
+//! The internal state of a multi-window [`Program`].
+use crate::core::event::{self, Event};
+use crate::core::mouse;
+use crate::core::renderer;
+use crate::core::widget::operation::{self, Operation};
+use crate::core::{Clipboard, Size};
+use crate::user_interface::{self, UserInterface};
+use crate::{Command, Debug, Program};
+
+/// The execution state of a multi-window [`Program`]. It leverages caching, event
+/// processing, and rendering primitive storage.
+#[allow(missing_debug_implementations)]
+pub struct State<P>
+where
+    P: Program + 'static,
+{
+    program: P,
+    caches: Option<Vec<user_interface::Cache>>,
+    queued_events: Vec<Event>,
+    queued_messages: Vec<P::Message>,
+    mouse_interaction: mouse::Interaction,
+}
+
+impl<P> State<P>
+where
+    P: Program + 'static,
+{
+    /// Creates a new [`State`] with the provided [`Program`], initializing its
+    /// primitive with the given logical bounds and renderer.
+    pub fn new(
+        program: P,
+        bounds: Size,
+        renderer: &mut P::Renderer,
+        debug: &mut Debug,
+    ) -> Self {
+        let user_interface = build_user_interface(
+            &program,
+            user_interface::Cache::default(),
+            renderer,
+            bounds,
+            debug,
+        );
+
+        let caches = Some(vec![user_interface.into_cache()]);
+
+        State {
+            program,
+            caches,
+            queued_events: Vec::new(),
+            queued_messages: Vec::new(),
+            mouse_interaction: mouse::Interaction::Idle,
+        }
+    }
+
+    /// Returns a reference to the [`Program`] of the [`State`].
+    pub fn program(&self) -> &P {
+        &self.program
+    }
+
+    /// Queues an event in the [`State`] for processing during an [`update`].
+    ///
+    /// [`update`]: Self::update
+    pub fn queue_event(&mut self, event: Event) {
+        self.queued_events.push(event);
+    }
+
+    /// Queues a message in the [`State`] for processing during an [`update`].
+    ///
+    /// [`update`]: Self::update
+    pub fn queue_message(&mut self, message: P::Message) {
+        self.queued_messages.push(message);
+    }
+
+    /// Returns whether the event queue of the [`State`] is empty or not.
+    pub fn is_queue_empty(&self) -> bool {
+        self.queued_events.is_empty() && self.queued_messages.is_empty()
+    }
+
+    /// Returns the current [`mouse::Interaction`] of the [`State`].
+    pub fn mouse_interaction(&self) -> mouse::Interaction {
+        self.mouse_interaction
+    }
+
+    /// Processes all the queued events and messages, rebuilding and redrawing
+    /// the widgets of the linked [`Program`] if necessary.
+    ///
+    /// Returns a list containing the instances of [`Event`] that were not
+    /// captured by any widget, and the [`Command`] obtained from [`Program`]
+    /// after updating it, only if an update was necessary.
+    pub fn update(
+        &mut self,
+        bounds: Size,
+        cursor: mouse::Cursor,
+        renderer: &mut P::Renderer,
+        theme: &<P::Renderer as iced_core::Renderer>::Theme,
+        style: &renderer::Style,
+        clipboard: &mut dyn Clipboard,
+        debug: &mut Debug,
+    ) -> (Vec<Event>, Option<Command<P::Message>>) {
+        let mut user_interfaces = build_user_interfaces(
+            &self.program,
+            self.caches.take().unwrap(),
+            renderer,
+            bounds,
+            debug,
+        );
+
+        debug.event_processing_started();
+        let mut messages = Vec::new();
+
+        let uncaptured_events = user_interfaces.iter_mut().fold(
+            vec![],
+            |mut uncaptured_events, ui| {
+                let (_, event_statuses) = ui.update(
+                    &self.queued_events,
+                    cursor,
+                    renderer,
+                    clipboard,
+                    &mut messages,
+                );
+
+                uncaptured_events.extend(
+                    self.queued_events
+                        .iter()
+                        .zip(event_statuses)
+                        .filter_map(|(event, status)| {
+                            matches!(status, event::Status::Ignored)
+                                .then_some(event)
+                        })
+                        .cloned(),
+                );
+                uncaptured_events
+            },
+        );
+
+        self.queued_events.clear();
+        messages.append(&mut self.queued_messages);
+        debug.event_processing_finished();
+
+        let commands = if messages.is_empty() {
+            debug.draw_started();
+
+            for ui in &mut user_interfaces {
+                self.mouse_interaction =
+                    ui.draw(renderer, theme, style, cursor);
+            }
+
+            debug.draw_finished();
+
+            self.caches = Some(
+                user_interfaces
+                    .drain(..)
+                    .map(UserInterface::into_cache)
+                    .collect(),
+            );
+
+            None
+        } else {
+            let temp_caches = user_interfaces
+                .drain(..)
+                .map(UserInterface::into_cache)
+                .collect();
+
+            drop(user_interfaces);
+
+            let commands = Command::batch(messages.into_iter().map(|msg| {
+                debug.log_message(&msg);
+
+                debug.update_started();
+                let command = self.program.update(msg);
+                debug.update_finished();
+
+                command
+            }));
+
+            let mut user_interfaces = build_user_interfaces(
+                &self.program,
+                temp_caches,
+                renderer,
+                bounds,
+                debug,
+            );
+
+            debug.draw_started();
+            for ui in &mut user_interfaces {
+                self.mouse_interaction =
+                    ui.draw(renderer, theme, style, cursor);
+            }
+            debug.draw_finished();
+
+            self.caches = Some(
+                user_interfaces
+                    .drain(..)
+                    .map(UserInterface::into_cache)
+                    .collect(),
+            );
+
+            Some(commands)
+        };
+
+        (uncaptured_events, commands)
+    }
+
+    /// Applies [`widget::Operation`]s to the [`State`]
+    pub fn operate(
+        &mut self,
+        renderer: &mut P::Renderer,
+        operations: impl Iterator<Item = Box<dyn Operation<P::Message>>>,
+        bounds: Size,
+        debug: &mut Debug,
+    ) {
+        let mut user_interfaces = build_user_interfaces(
+            &self.program,
+            self.caches.take().unwrap(),
+            renderer,
+            bounds,
+            debug,
+        );
+
+        for operation in operations {
+            let mut current_operation = Some(operation);
+
+            while let Some(mut operation) = current_operation.take() {
+                for ui in &mut user_interfaces {
+                    ui.operate(renderer, operation.as_mut());
+                }
+
+                match operation.finish() {
+                    operation::Outcome::None => {}
+                    operation::Outcome::Some(message) => {
+                        self.queued_messages.push(message)
+                    }
+                    operation::Outcome::Chain(next) => {
+                        current_operation = Some(next);
+                    }
+                };
+            }
+        }
+
+        self.caches = Some(
+            user_interfaces
+                .drain(..)
+                .map(UserInterface::into_cache)
+                .collect(),
+        );
+    }
+}
+
+fn build_user_interfaces<'a, P: Program>(
+    program: &'a P,
+    mut caches: Vec<user_interface::Cache>,
+    renderer: &mut P::Renderer,
+    size: Size,
+    debug: &mut Debug,
+) -> Vec<UserInterface<'a, P::Message, P::Renderer>> {
+    caches
+        .drain(..)
+        .map(|cache| {
+            build_user_interface(program, cache, renderer, size, debug)
+        })
+        .collect()
+}
+
+fn build_user_interface<'a, P: Program>(
+    program: &'a P,
+    cache: user_interface::Cache,
+    renderer: &mut P::Renderer,
+    size: Size,
+    debug: &mut Debug,
+) -> UserInterface<'a, P::Message, P::Renderer> {
+    debug.view_started();
+    let view = program.view();
+    debug.view_finished();
+
+    debug.layout_started();
+    let user_interface = UserInterface::build(view, size, cache, renderer);
+    debug.layout_finished();
+
+    user_interface
+}

runtime/src/window.rs

@@ -3,101 +3,117 @@ mod action;
 
 pub mod screenshot;
 
+pub use crate::core::window::Id;
 pub use action::Action;
 pub use screenshot::Screenshot;
 
 use crate::command::{self, Command};
 use crate::core::time::Instant;
-use crate::core::window::{Event, Icon, Level, Mode, UserAttention};
+use crate::core::window::{self, Event, Icon, Level, Mode, UserAttention};
 use crate::core::Size;
 use crate::futures::subscription::{self, Subscription};
 
 /// Subscribes to the frames of the window of the running application.
 ///
 /// The resulting [`Subscription`] will produce items at a rate equal to the
-/// refresh rate of the window. Note that this rate may be variable, as it is
+/// refresh rate of the first application window. Note that this rate may be variable, as it is
 /// normally managed by the graphics driver and/or the OS.
 ///
 /// In any case, this [`Subscription`] is useful to smoothly draw application-driven
 /// animations without missing any frames.
 pub fn frames() -> Subscription<Instant> {
     subscription::raw_events(|event, _status| match event {
-        iced_core::Event::Window(Event::RedrawRequested(at)) => Some(at),
+        iced_core::Event::Window(_, Event::RedrawRequested(at)) => Some(at),
         _ => None,
     })
 }
 
-/// Closes the current window and exits the application.
-pub fn close<Message>() -> Command<Message> {
-    Command::single(command::Action::Window(Action::Close))
+/// Spawns a new window with the given `id` and `settings`.
+pub fn spawn<Message>(
+    id: window::Id,
+    settings: window::Settings,
+) -> Command<Message> {
+    Command::single(command::Action::Window(id, Action::Spawn { settings }))
+}
+
+/// Closes the window with `id`.
+pub fn close<Message>(id: window::Id) -> Command<Message> {
+    Command::single(command::Action::Window(id, Action::Close))
 }
 
 /// Begins dragging the window while the left mouse button is held.
-pub fn drag<Message>() -> Command<Message> {
-    Command::single(command::Action::Window(Action::Drag))
+pub fn drag<Message>(id: window::Id) -> Command<Message> {
+    Command::single(command::Action::Window(id, Action::Drag))
 }
 
 /// Resizes the window to the given logical dimensions.
-pub fn resize<Message>(new_size: Size<u32>) -> Command<Message> {
-    Command::single(command::Action::Window(Action::Resize(new_size)))
+pub fn resize<Message>(
+    id: window::Id,
+    new_size: Size<u32>,
+) -> Command<Message> {
+    Command::single(command::Action::Window(id, Action::Resize(new_size)))
 }
 
-/// Fetches the current window size in logical dimensions.
+/// Fetches the window's size in logical dimensions.
 pub fn fetch_size<Message>(
+    id: window::Id,
     f: impl FnOnce(Size<u32>) -> Message + 'static,
 ) -> Command<Message> {
-    Command::single(command::Action::Window(Action::FetchSize(Box::new(f))))
+    Command::single(command::Action::Window(id, Action::FetchSize(Box::new(f))))
 }
 
 /// Maximizes the window.
-pub fn maximize<Message>(maximized: bool) -> Command<Message> {
-    Command::single(command::Action::Window(Action::Maximize(maximized)))
+pub fn maximize<Message>(id: window::Id, maximized: bool) -> Command<Message> {
+    Command::single(command::Action::Window(id, Action::Maximize(maximized)))
 }
 
-/// Minimes the window.
-pub fn minimize<Message>(minimized: bool) -> Command<Message> {
-    Command::single(command::Action::Window(Action::Minimize(minimized)))
+/// Minimizes the window.
+pub fn minimize<Message>(id: window::Id, minimized: bool) -> Command<Message> {
+    Command::single(command::Action::Window(id, Action::Minimize(minimized)))
 }
 
-/// Moves a window to the given logical coordinates.
-pub fn move_to<Message>(x: i32, y: i32) -> Command<Message> {
-    Command::single(command::Action::Window(Action::Move { x, y }))
+/// Moves the window to the given logical coordinates.
+pub fn move_to<Message>(id: window::Id, x: i32, y: i32) -> Command<Message> {
+    Command::single(command::Action::Window(id, Action::Move { x, y }))
 }
 
 /// Changes the [`Mode`] of the window.
-pub fn change_mode<Message>(mode: Mode) -> Command<Message> {
-    Command::single(command::Action::Window(Action::ChangeMode(mode)))
+pub fn change_mode<Message>(id: window::Id, mode: Mode) -> Command<Message> {
+    Command::single(command::Action::Window(id, Action::ChangeMode(mode)))
 }
 
 /// Fetches the current [`Mode`] of the window.
 pub fn fetch_mode<Message>(
+    id: window::Id,
     f: impl FnOnce(Mode) -> Message + 'static,
 ) -> Command<Message> {
-    Command::single(command::Action::Window(Action::FetchMode(Box::new(f))))
+    Command::single(command::Action::Window(id, Action::FetchMode(Box::new(f))))
 }
 
 /// Toggles the window to maximized or back.
-pub fn toggle_maximize<Message>() -> Command<Message> {
-    Command::single(command::Action::Window(Action::ToggleMaximize))
+pub fn toggle_maximize<Message>(id: window::Id) -> Command<Message> {
+    Command::single(command::Action::Window(id, Action::ToggleMaximize))
 }
 
 /// Toggles the window decorations.
-pub fn toggle_decorations<Message>() -> Command<Message> {
-    Command::single(command::Action::Window(Action::ToggleDecorations))
+pub fn toggle_decorations<Message>(id: window::Id) -> Command<Message> {
+    Command::single(command::Action::Window(id, Action::ToggleDecorations))
 }
 
-/// Request user attention to the window, this has no effect if the application
+/// Request user attention to the window. This has no effect if the application
 /// is already focused. How requesting for user attention manifests is platform dependent,
 /// see [`UserAttention`] for details.
 ///
 /// Providing `None` will unset the request for user attention. Unsetting the request for
 /// user attention might not be done automatically by the WM when the window receives input.
 pub fn request_user_attention<Message>(
+    id: window::Id,
     user_attention: Option<UserAttention>,
 ) -> Command<Message> {
-    Command::single(command::Action::Window(Action::RequestUserAttention(
-        user_attention,
-    )))
+    Command::single(command::Action::Window(
+        id,
+        Action::RequestUserAttention(user_attention),
+    ))
 }
 
 /// Brings the window to the front and sets input focus. Has no effect if the window is
@@ -106,30 +122,36 @@ pub fn request_user_attention<Message>(
 /// This [`Command`] steals input focus from other applications. Do not use this method unless
 /// you are certain that's what the user wants. Focus stealing can cause an extremely disruptive
 /// user experience.
-pub fn gain_focus<Message>() -> Command<Message> {
-    Command::single(command::Action::Window(Action::GainFocus))
+pub fn gain_focus<Message>(id: window::Id) -> Command<Message> {
+    Command::single(command::Action::Window(id, Action::GainFocus))
 }
 
 /// Changes the window [`Level`].
-pub fn change_level<Message>(level: Level) -> Command<Message> {
-    Command::single(command::Action::Window(Action::ChangeLevel(level)))
+pub fn change_level<Message>(id: window::Id, level: Level) -> Command<Message> {
+    Command::single(command::Action::Window(id, Action::ChangeLevel(level)))
 }
 
-/// Fetches an identifier unique to the window.
+/// Fetches an identifier unique to the window, provided by the underlying windowing system. This is
+/// not to be confused with [`window::Id`].
 pub fn fetch_id<Message>(
+    id: window::Id,
     f: impl FnOnce(u64) -> Message + 'static,
 ) -> Command<Message> {
-    Command::single(command::Action::Window(Action::FetchId(Box::new(f))))
+    Command::single(command::Action::Window(id, Action::FetchId(Box::new(f))))
 }
 
 /// Changes the [`Icon`] of the window.
-pub fn change_icon<Message>(icon: Icon) -> Command<Message> {
-    Command::single(command::Action::Window(Action::ChangeIcon(icon)))
+pub fn change_icon<Message>(id: window::Id, icon: Icon) -> Command<Message> {
+    Command::single(command::Action::Window(id, Action::ChangeIcon(icon)))
 }
 
 /// Captures a [`Screenshot`] from the window.
 pub fn screenshot<Message>(
+    id: window::Id,
     f: impl FnOnce(Screenshot) -> Message + Send + 'static,
 ) -> Command<Message> {
-    Command::single(command::Action::Window(Action::Screenshot(Box::new(f))))
+    Command::single(command::Action::Window(
+        id,
+        Action::Screenshot(Box::new(f)),
+    ))
 }

runtime/src/window/action.rs

@@ -1,4 +1,4 @@
-use crate::core::window::{Icon, Level, Mode, UserAttention, Settings};
+use crate::core::window::{Icon, Level, Mode, Settings, UserAttention};
 use crate::core::Size;
 use crate::futures::MaybeSend;
 use crate::window::Screenshot;
@@ -15,7 +15,7 @@ pub enum Action<T> {
     /// There’s no guarantee that this will work unless the left mouse
     /// button was pressed immediately before this function is called.
     Drag,
-    /// Spawns a new window with the provided [`window::Settings`].
+    /// Spawns a new window.
     Spawn {
         /// The settings of the [`Window`].
         settings: Settings,