Use `AtomicU64` for `window::Id`

9 files changed, 228 insertions, 212 deletions

diff --git a/core/src/window/event.rs b/core/src/window/event.rs
index 3ab7cd81..b9ee7aca 100644
--- a/core/src/window/event.rs
+++ b/core/src/window/event.rs
@@ -6,6 +6,22 @@ use std::path::PathBuf;
 /// A window-related event.
 #[derive(PartialEq, Clone, Debug)]
 pub enum Event {
+    /// A window was opened.
+    Opened {
+        /// The position of the opened window. This is relative to the top-left corner of the desktop
+        /// the window is on, including virtual desktops. Refers to window's "inner" position,
+        /// or the client area, in logical pixels.
+        ///
+        /// **Note**: Not available in Wayland.
+        position: Option<Point>,
+        /// The size of the created window. This is its "inner" size, or the size of the
+        /// client area, in logical pixels.
+        size: Size,
+    },
+
+    /// A window was closed.
+    Closed,
+
     /// A window was moved.
     Moved {
         /// The new logical x location of the window
@@ -30,22 +46,6 @@ pub enum Event {
     /// The user has requested for the window to close.
     CloseRequested,
 
-    /// A window was created.
-    Created {
-        /// The position of the created window. This is relative to the top-left corner of the desktop
-        /// the window is on, including virtual desktops. Refers to window's "inner" position,
-        /// or the client area, in logical pixels.
-        ///
-        /// **Note**: Not available in Wayland.
-        position: Option<Point>,
-        /// The size of the created window. This is its "inner" size, or the size of the
-        /// client area, in logical pixels.
-        size: Size,
-    },
-
-    /// A window was destroyed by the runtime.
-    Destroyed,
-
     /// A window was focused.
     Focused,
 
diff --git a/core/src/window/id.rs b/core/src/window/id.rs
index 65002d43..20474c8f 100644
--- a/core/src/window/id.rs
+++ b/core/src/window/id.rs
@@ -1,5 +1,6 @@
-use std::collections::hash_map::DefaultHasher;
-use std::hash::{Hash, Hasher};
+use std::hash::Hash;
+
+use std::sync::atomic::{self, AtomicU64};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
 /// The id of the window.
@@ -7,15 +8,14 @@ use std::hash::{Hash, Hasher};
 /// Internally Iced reserves `window::Id::MAIN` for the first window spawned.
 pub struct Id(u64);
 
+static COUNT: AtomicU64 = AtomicU64::new(1);
+
 impl Id {
     /// The reserved window [`Id`] for the first window in an Iced application.
     pub const MAIN: Self = Id(0);
 
     /// Creates a new unique window [`Id`].
-    pub fn new(id: impl Hash) -> Id {
-        let mut hasher = DefaultHasher::new();
-        id.hash(&mut hasher);
-
-        Id(hasher.finish())
+    pub fn unique() -> Id {
+        Id(COUNT.fetch_add(1, atomic::Ordering::Relaxed))
     }
 }
diff --git a/examples/multi_window/src/main.rs b/examples/multi_window/src/main.rs
index 16beb46e..5a5e70c1 100644
--- a/examples/multi_window/src/main.rs
+++ b/examples/multi_window/src/main.rs
@@ -35,8 +35,8 @@ enum Message {
     ScaleChanged(window::Id, String),
     TitleChanged(window::Id, String),
     CloseWindow(window::Id),
-    WindowCreated(window::Id, Option<Point>),
-    WindowDestroyed(window::Id),
+    WindowOpened(window::Id, Option<Point>),
+    WindowClosed(window::Id),
     NewWindow,
 }
 
@@ -69,6 +69,8 @@ impl multi_window::Application for Example {
                 let window =
                     self.windows.get_mut(&id).expect("Window not found!");
                 window.scale_input = scale;
+
+                Command::none()
             }
             Message::ScaleChanged(id, scale) => {
                 let window =
@@ -78,20 +80,23 @@ impl multi_window::Application for Example {
                     .parse::<f64>()
                     .unwrap_or(window.current_scale)
                     .clamp(0.5, 5.0);
+
+                Command::none()
             }
             Message::TitleChanged(id, title) => {
                 let window =
                     self.windows.get_mut(&id).expect("Window not found.");
 
                 window.title = title;
+
+                Command::none()
             }
-            Message::CloseWindow(id) => {
-                return window::close(id);
-            }
-            Message::WindowDestroyed(id) => {
+            Message::CloseWindow(id) => window::close(id),
+            Message::WindowClosed(id) => {
                 self.windows.remove(&id);
+                Command::none()
             }
-            Message::WindowCreated(id, position) => {
+            Message::WindowOpened(id, position) => {
                 if let Some(position) = position {
                     self.next_window_pos = window::Position::Specific(
                         position + Vector::new(20.0, 20.0),
@@ -99,27 +104,25 @@ impl multi_window::Application for Example {
                 }
 
                 if let Some(window) = self.windows.get(&id) {
-                    return text_input::focus(window.input_id.clone());
+                    text_input::focus(window.input_id.clone())
+                } else {
+                    Command::none()
                 }
             }
             Message::NewWindow => {
                 let count = self.windows.len() + 1;
-                let id = window::Id::new(count);
+
+                let (id, spawn_window) = window::spawn(window::Settings {
+                    position: self.next_window_pos,
+                    exit_on_close_request: count % 2 == 0,
+                    ..Default::default()
+                });
 
                 self.windows.insert(id, Window::new(count));
 
-                return window::spawn(
-                    id,
-                    window::Settings {
-                        position: self.next_window_pos,
-                        exit_on_close_request: count % 2 == 0,
-                        ..Default::default()
-                    },
-                );
+                spawn_window
             }
         }
-
-        Command::none()
     }
 
     fn view(&self, window: window::Id) -> Element<Message> {
@@ -151,12 +154,10 @@ impl multi_window::Application for Example {
                     window::Event::CloseRequested => {
                         Some(Message::CloseWindow(id))
                     }
-                    window::Event::Destroyed => {
-                        Some(Message::WindowDestroyed(id))
-                    }
-                    window::Event::Created { position, .. } => {
-                        Some(Message::WindowCreated(id, position))
+                    window::Event::Opened { position, .. } => {
+                        Some(Message::WindowOpened(id, position))
                     }
+                    window::Event::Closed => Some(Message::WindowClosed(id)),
                     _ => None,
                 }
             } else {
diff --git a/runtime/src/command/action.rs b/runtime/src/command/action.rs
index 7a70920e..cb0936df 100644
--- a/runtime/src/command/action.rs
+++ b/runtime/src/command/action.rs
@@ -27,7 +27,7 @@ pub enum Action<T> {
     Clipboard(clipboard::Action<T>),
 
     /// Run a window action.
-    Window(window::Id, window::Action<T>),
+    Window(window::Action<T>),
 
     /// Run a system action.
     System(system::Action<T>),
@@ -63,7 +63,7 @@ impl<T> Action<T> {
             Self::Future(future) => Action::Future(Box::pin(future.map(f))),
             Self::Stream(stream) => Action::Stream(Box::pin(stream.map(f))),
             Self::Clipboard(action) => Action::Clipboard(action.map(f)),
-            Self::Window(id, window) => Action::Window(id, window.map(f)),
+            Self::Window(window) => Action::Window(window.map(f)),
             Self::System(system) => Action::System(system.map(f)),
             Self::Widget(operation) => {
                 Action::Widget(Box::new(widget::operation::map(operation, f)))
@@ -84,8 +84,8 @@ impl<T> fmt::Debug for Action<T> {
             Self::Clipboard(action) => {
                 write!(f, "Action::Clipboard({action:?})")
             }
-            Self::Window(id, action) => {
-                write!(f, "Action::Window({id:?}, {action:?})")
+            Self::Window(action) => {
+                write!(f, "Action::Window({action:?})")
             }
             Self::System(action) => write!(f, "Action::System({action:?})"),
             Self::Widget(_action) => write!(f, "Action::Widget"),
diff --git a/runtime/src/multi_window/program.rs b/runtime/src/multi_window/program.rs
index c3989d0d..591b3e9a 100644
--- a/runtime/src/multi_window/program.rs
+++ b/runtime/src/multi_window/program.rs
@@ -1,8 +1,8 @@
 //! Build interactive programs using The Elm Architecture.
-use crate::{window, Command};
-
 use crate::core::text;
+use crate::core::window;
 use crate::core::{Element, Renderer};
+use crate::Command;
 
 /// The core of a user interface for a multi-window application following The Elm Architecture.
 pub trait Program: Sized {
diff --git a/runtime/src/window.rs b/runtime/src/window.rs
index f46ac1b8..f9d943f6 100644
--- a/runtime/src/window.rs
+++ b/runtime/src/window.rs
@@ -3,13 +3,14 @@ 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::{self, Event, Icon, Level, Mode, UserAttention};
+use crate::core::window::{
+    Event, Icon, Id, Level, Mode, Settings, UserAttention,
+};
 use crate::core::{Point, Size};
 use crate::futures::event;
 use crate::futures::Subscription;
@@ -29,73 +30,77 @@ pub fn frames() -> Subscription<Instant> {
     })
 }
 
-/// 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 }))
+/// Spawns a new window with the given `settings`.
+///
+/// Returns the new window [`Id`] alongside the [`Command`].
+pub fn spawn<Message>(settings: Settings) -> (Id, Command<Message>) {
+    let id = Id::unique();
+
+    (
+        id,
+        Command::single(command::Action::Window(Action::Spawn(id, settings))),
+    )
 }
 
 /// Closes the window with `id`.
-pub fn close<Message>(id: window::Id) -> Command<Message> {
-    Command::single(command::Action::Window(id, Action::Close))
+pub fn close<Message>(id: Id) -> Command<Message> {
+    Command::single(command::Action::Window(Action::Close(id)))
 }
 
 /// Begins dragging the window while the left mouse button is held.
-pub fn drag<Message>(id: window::Id) -> Command<Message> {
-    Command::single(command::Action::Window(id, Action::Drag))
+pub fn drag<Message>(id: Id) -> Command<Message> {
+    Command::single(command::Action::Window(Action::Drag(id)))
 }
 
 /// Resizes the window to the given logical dimensions.
-pub fn resize<Message>(id: window::Id, new_size: Size) -> Command<Message> {
-    Command::single(command::Action::Window(id, Action::Resize(new_size)))
+pub fn resize<Message>(id: Id, new_size: Size) -> Command<Message> {
+    Command::single(command::Action::Window(Action::Resize(id, new_size)))
 }
 
 /// Fetches the window's size in logical dimensions.
 pub fn fetch_size<Message>(
-    id: window::Id,
+    id: Id,
     f: impl FnOnce(Size) -> Message + 'static,
 ) -> Command<Message> {
-    Command::single(command::Action::Window(id, Action::FetchSize(Box::new(f))))
+    Command::single(command::Action::Window(Action::FetchSize(id, Box::new(f))))
 }
 
 /// Maximizes the window.
-pub fn maximize<Message>(id: window::Id, maximized: bool) -> Command<Message> {
-    Command::single(command::Action::Window(id, Action::Maximize(maximized)))
+pub fn maximize<Message>(id: Id, maximized: bool) -> Command<Message> {
+    Command::single(command::Action::Window(Action::Maximize(id, maximized)))
 }
 
 /// Minimizes the window.
-pub fn minimize<Message>(id: window::Id, minimized: bool) -> Command<Message> {
-    Command::single(command::Action::Window(id, Action::Minimize(minimized)))
+pub fn minimize<Message>(id: Id, minimized: bool) -> Command<Message> {
+    Command::single(command::Action::Window(Action::Minimize(id, minimized)))
 }
 
 /// Moves the window to the given logical coordinates.
-pub fn move_to<Message>(id: window::Id, position: Point) -> Command<Message> {
-    Command::single(command::Action::Window(id, Action::Move(position)))
+pub fn move_to<Message>(id: Id, position: Point) -> Command<Message> {
+    Command::single(command::Action::Window(Action::Move(id, position)))
 }
 
 /// Changes the [`Mode`] of the window.
-pub fn change_mode<Message>(id: window::Id, mode: Mode) -> Command<Message> {
-    Command::single(command::Action::Window(id, Action::ChangeMode(mode)))
+pub fn change_mode<Message>(id: Id, mode: Mode) -> Command<Message> {
+    Command::single(command::Action::Window(Action::ChangeMode(id, mode)))
 }
 
 /// Fetches the current [`Mode`] of the window.
 pub fn fetch_mode<Message>(
-    id: window::Id,
+    id: Id,
     f: impl FnOnce(Mode) -> Message + 'static,
 ) -> Command<Message> {
-    Command::single(command::Action::Window(id, Action::FetchMode(Box::new(f))))
+    Command::single(command::Action::Window(Action::FetchMode(id, Box::new(f))))
 }
 
 /// Toggles the window to maximized or back.
-pub fn toggle_maximize<Message>(id: window::Id) -> Command<Message> {
-    Command::single(command::Action::Window(id, Action::ToggleMaximize))
+pub fn toggle_maximize<Message>(id: Id) -> Command<Message> {
+    Command::single(command::Action::Window(Action::ToggleMaximize(id)))
 }
 
 /// Toggles the window decorations.
-pub fn toggle_decorations<Message>(id: window::Id) -> Command<Message> {
-    Command::single(command::Action::Window(id, Action::ToggleDecorations))
+pub fn toggle_decorations<Message>(id: Id) -> Command<Message> {
+    Command::single(command::Action::Window(Action::ToggleDecorations(id)))
 }
 
 /// Request user attention to the window. This has no effect if the application
@@ -105,13 +110,13 @@ pub fn toggle_decorations<Message>(id: window::Id) -> Command<Message> {
 /// 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,
+    id: Id,
     user_attention: Option<UserAttention>,
 ) -> Command<Message> {
-    Command::single(command::Action::Window(
+    Command::single(command::Action::Window(Action::RequestUserAttention(
         id,
-        Action::RequestUserAttention(user_attention),
-    ))
+        user_attention,
+    )))
 }
 
 /// Brings the window to the front and sets input focus. Has no effect if the window is
@@ -120,36 +125,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>(id: window::Id) -> Command<Message> {
-    Command::single(command::Action::Window(id, Action::GainFocus))
+pub fn gain_focus<Message>(id: Id) -> Command<Message> {
+    Command::single(command::Action::Window(Action::GainFocus(id)))
 }
 
 /// Changes the window [`Level`].
-pub fn change_level<Message>(id: window::Id, level: Level) -> Command<Message> {
-    Command::single(command::Action::Window(id, Action::ChangeLevel(level)))
+pub fn change_level<Message>(id: Id, level: Level) -> Command<Message> {
+    Command::single(command::Action::Window(Action::ChangeLevel(id, level)))
 }
 
 /// Fetches an identifier unique to the window, provided by the underlying windowing system. This is
-/// not to be confused with [`window::Id`].
+/// not to be confused with [`Id`].
 pub fn fetch_id<Message>(
-    id: window::Id,
+    id: Id,
     f: impl FnOnce(u64) -> Message + 'static,
 ) -> Command<Message> {
-    Command::single(command::Action::Window(id, Action::FetchId(Box::new(f))))
+    Command::single(command::Action::Window(Action::FetchId(id, Box::new(f))))
 }
 
 /// Changes the [`Icon`] of the window.
-pub fn change_icon<Message>(id: window::Id, icon: Icon) -> Command<Message> {
-    Command::single(command::Action::Window(id, Action::ChangeIcon(icon)))
+pub fn change_icon<Message>(id: Id, icon: Icon) -> Command<Message> {
+    Command::single(command::Action::Window(Action::ChangeIcon(id, icon)))
 }
 
 /// Captures a [`Screenshot`] from the window.
 pub fn screenshot<Message>(
-    id: window::Id,
+    id: Id,
     f: impl FnOnce(Screenshot) -> Message + Send + 'static,
 ) -> Command<Message> {
-    Command::single(command::Action::Window(
+    Command::single(command::Action::Window(Action::Screenshot(
         id,
-        Action::Screenshot(Box::new(f)),
-    ))
+        Box::new(f),
+    )))
 }
diff --git a/runtime/src/window/action.rs b/runtime/src/window/action.rs
index 5afe0389..2d98b607 100644
--- a/runtime/src/window/action.rs
+++ b/runtime/src/window/action.rs
@@ -1,4 +1,4 @@
-use crate::core::window::{Icon, Level, Mode, Settings, UserAttention};
+use crate::core::window::{Icon, Id, Level, Mode, Settings, UserAttention};
 use crate::core::{Point, Size};
 use crate::futures::MaybeSend;
 use crate::window::Screenshot;
@@ -7,43 +7,40 @@ use std::fmt;
 
 /// An operation to be performed on some window.
 pub enum Action<T> {
-    /// Close the current window and exits the application.
-    Close,
+    /// Spawns a new window with some [`Settings`].
+    Spawn(Id, Settings),
+    /// Close the window and exits the application.
+    Close(Id),
     /// Move the window with the left mouse button until the button is
     /// released.
     ///
     /// 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.
-    Spawn {
-        /// The settings of the window.
-        settings: Settings,
-    },
+    Drag(Id),
     /// Resize the window to the given logical dimensions.
-    Resize(Size),
+    Resize(Id, Size),
     /// Fetch the current logical dimensions of the window.
-    FetchSize(Box<dyn FnOnce(Size) -> T + 'static>),
+    FetchSize(Id, Box<dyn FnOnce(Size) -> T + 'static>),
     /// Set the window to maximized or back
-    Maximize(bool),
+    Maximize(Id, bool),
     /// Set the window to minimized or back
-    Minimize(bool),
+    Minimize(Id, bool),
     /// Move the window to the given logical coordinates.
     ///
     /// Unsupported on Wayland.
-    Move(Point),
+    Move(Id, Point),
     /// Change the [`Mode`] of the window.
-    ChangeMode(Mode),
+    ChangeMode(Id, Mode),
     /// Fetch the current [`Mode`] of the window.
-    FetchMode(Box<dyn FnOnce(Mode) -> T + 'static>),
+    FetchMode(Id, Box<dyn FnOnce(Mode) -> T + 'static>),
     /// Toggle the window to maximized or back
-    ToggleMaximize,
+    ToggleMaximize(Id),
     /// Toggle whether window has decorations.
     ///
     /// ## Platform-specific
     /// - **X11:** Not implemented.
     /// - **Web:** Unsupported.
-    ToggleDecorations,
+    ToggleDecorations(Id),
     /// 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.
@@ -57,7 +54,7 @@ pub enum Action<T> {
     /// - **macOS:** `None` has no effect.
     /// - **X11:** Requests for user attention must be manually cleared.
     /// - **Wayland:** Requires `xdg_activation_v1` protocol, `None` has no effect.
-    RequestUserAttention(Option<UserAttention>),
+    RequestUserAttention(Id, Option<UserAttention>),
     /// Bring the window to the front and sets input focus. Has no effect if the window is
     /// already in focus, minimized, or not visible.
     ///
@@ -68,11 +65,11 @@ pub enum Action<T> {
     /// ## Platform-specific
     ///
     /// - **Web / Wayland:** Unsupported.
-    GainFocus,
+    GainFocus(Id),
     /// Change the window [`Level`].
-    ChangeLevel(Level),
-    /// Fetch an identifier unique to the window.
-    FetchId(Box<dyn FnOnce(u64) -> T + 'static>),
+    ChangeLevel(Id, Level),
+    /// Fetch the raw identifier unique to the window.
+    FetchId(Id, Box<dyn FnOnce(u64) -> T + 'static>),
     /// Change the window [`Icon`].
     ///
     /// On Windows and X11, this is typically the small icon in the top-left
@@ -87,9 +84,9 @@ pub enum Action<T> {
     ///
     /// - **X11:** Has no universal guidelines for icon sizes, so you're at the whims of the WM. That
     ///   said, it's usually in the same ballpark as on Windows.
-    ChangeIcon(Icon),
+    ChangeIcon(Id, Icon),
     /// Screenshot the viewport of the window.
-    Screenshot(Box<dyn FnOnce(Screenshot) -> T + 'static>),
+    Screenshot(Id, Box<dyn FnOnce(Screenshot) -> T + 'static>),
 }
 
 impl<T> Action<T> {
@@ -102,30 +99,35 @@ impl<T> Action<T> {
         T: 'static,
     {
         match self {
-            Self::Close => Action::Close,
-            Self::Drag => Action::Drag,
-            Self::Spawn { settings } => Action::Spawn { settings },
-            Self::Resize(size) => Action::Resize(size),
-            Self::FetchSize(o) => Action::FetchSize(Box::new(move |s| f(o(s)))),
-            Self::Maximize(maximized) => Action::Maximize(maximized),
-            Self::Minimize(minimized) => Action::Minimize(minimized),
-            Self::Move(position) => Action::Move(position),
-            Self::ChangeMode(mode) => Action::ChangeMode(mode),
-            Self::FetchMode(o) => Action::FetchMode(Box::new(move |s| f(o(s)))),
-            Self::ToggleMaximize => Action::ToggleMaximize,
-            Self::ToggleDecorations => Action::ToggleDecorations,
-            Self::RequestUserAttention(attention_type) => {
-                Action::RequestUserAttention(attention_type)
+            Self::Spawn(id, settings) => Action::Spawn(id, settings),
+            Self::Close(id) => Action::Close(id),
+            Self::Drag(id) => Action::Drag(id),
+            Self::Resize(id, size) => Action::Resize(id, size),
+            Self::FetchSize(id, o) => {
+                Action::FetchSize(id, Box::new(move |s| f(o(s))))
             }
-            Self::GainFocus => Action::GainFocus,
-            Self::ChangeLevel(level) => Action::ChangeLevel(level),
-            Self::FetchId(o) => Action::FetchId(Box::new(move |s| f(o(s)))),
-            Self::ChangeIcon(icon) => Action::ChangeIcon(icon),
-            Self::Screenshot(tag) => {
-                Action::Screenshot(Box::new(move |screenshot| {
-                    f(tag(screenshot))
-                }))
+            Self::Maximize(id, maximized) => Action::Maximize(id, maximized),
+            Self::Minimize(id, minimized) => Action::Minimize(id, minimized),
+            Self::Move(id, position) => Action::Move(id, position),
+            Self::ChangeMode(id, mode) => Action::ChangeMode(id, mode),
+            Self::FetchMode(id, o) => {
+                Action::FetchMode(id, Box::new(move |s| f(o(s))))
             }
+            Self::ToggleMaximize(id) => Action::ToggleMaximize(id),
+            Self::ToggleDecorations(id) => Action::ToggleDecorations(id),
+            Self::RequestUserAttention(id, attention_type) => {
+                Action::RequestUserAttention(id, attention_type)
+            }
+            Self::GainFocus(id) => Action::GainFocus(id),
+            Self::ChangeLevel(id, level) => Action::ChangeLevel(id, level),
+            Self::FetchId(id, o) => {
+                Action::FetchId(id, Box::new(move |s| f(o(s))))
+            }
+            Self::ChangeIcon(id, icon) => Action::ChangeIcon(id, icon),
+            Self::Screenshot(id, tag) => Action::Screenshot(
+                id,
+                Box::new(move |screenshot| f(tag(screenshot))),
+            ),
         }
     }
 }
@@ -133,38 +135,46 @@ impl<T> Action<T> {
 impl<T> fmt::Debug for Action<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::Close => write!(f, "Action::Close"),
-            Self::Drag => write!(f, "Action::Drag"),
-            Self::Spawn { settings } => {
-                write!(f, "Action::Spawn {{ settings: {:?} }}", settings)
+            Self::Spawn(id, settings) => {
+                write!(f, "Action::Spawn({id:?}, {settings:?})")
+            }
+            Self::Close(id) => write!(f, "Action::Close({id:?})"),
+            Self::Drag(id) => write!(f, "Action::Drag({id:?})"),
+            Self::Resize(id, size) => {
+                write!(f, "Action::Resize({id:?}, {size:?})")
+            }
+            Self::FetchSize(id, _) => write!(f, "Action::FetchSize({id:?})"),
+            Self::Maximize(id, maximized) => {
+                write!(f, "Action::Maximize({id:?}, {maximized})")
+            }
+            Self::Minimize(id, minimized) => {
+                write!(f, "Action::Minimize({id:?}, {minimized}")
+            }
+            Self::Move(id, position) => {
+                write!(f, "Action::Move({id:?}, {position})")
             }
-            Self::Resize(size) => write!(f, "Action::Resize({size:?})"),
-            Self::FetchSize(_) => write!(f, "Action::FetchSize"),
-            Self::Maximize(maximized) => {
-                write!(f, "Action::Maximize({maximized})")
+            Self::ChangeMode(id, mode) => {
+                write!(f, "Action::SetMode({id:?}, {mode:?})")
             }
-            Self::Minimize(minimized) => {
-                write!(f, "Action::Minimize({minimized}")
+            Self::FetchMode(id, _) => write!(f, "Action::FetchMode({id:?})"),
+            Self::ToggleMaximize(id) => {
+                write!(f, "Action::ToggleMaximize({id:?})")
             }
-            Self::Move(position) => {
-                write!(f, "Action::Move({position})")
+            Self::ToggleDecorations(id) => {
+                write!(f, "Action::ToggleDecorations({id:?})")
             }
-            Self::ChangeMode(mode) => write!(f, "Action::SetMode({mode:?})"),
-            Self::FetchMode(_) => write!(f, "Action::FetchMode"),
-            Self::ToggleMaximize => write!(f, "Action::ToggleMaximize"),
-            Self::ToggleDecorations => write!(f, "Action::ToggleDecorations"),
-            Self::RequestUserAttention(_) => {
-                write!(f, "Action::RequestUserAttention")
+            Self::RequestUserAttention(id, _) => {
+                write!(f, "Action::RequestUserAttention({id:?})")
             }
-            Self::GainFocus => write!(f, "Action::GainFocus"),
-            Self::ChangeLevel(level) => {
-                write!(f, "Action::ChangeLevel({level:?})")
+            Self::GainFocus(id) => write!(f, "Action::GainFocus({id:?})"),
+            Self::ChangeLevel(id, level) => {
+                write!(f, "Action::ChangeLevel({id:?}, {level:?})")
             }
-            Self::FetchId(_) => write!(f, "Action::FetchId"),
-            Self::ChangeIcon(_icon) => {
-                write!(f, "Action::ChangeIcon(icon)")
+            Self::FetchId(id, _) => write!(f, "Action::FetchId({id:?})"),
+            Self::ChangeIcon(id, _icon) => {
+                write!(f, "Action::ChangeIcon({id:?})")
             }
-            Self::Screenshot(_) => write!(f, "Action::Screenshot"),
+            Self::Screenshot(id, _) => write!(f, "Action::Screenshot({id:?})"),
         }
     }
 }
diff --git a/winit/src/application.rs b/winit/src/application.rs
index 4e6a879f..cc1db8cb 100644
--- a/winit/src/application.rs
+++ b/winit/src/application.rs
@@ -712,11 +712,11 @@ pub fn run_command<A, C, E>(
                     clipboard.write(contents);
                 }
             },
-            command::Action::Window(_, action) => match action {
-                window::Action::Close => {
+            command::Action::Window(action) => match action {
+                window::Action::Close(_id) => {
                     *should_exit = true;
                 }
-                window::Action::Drag => {
+                window::Action::Drag(_id) => {
                     let _res = window.drag_window();
                 }
                 window::Action::Spawn { .. } => {
@@ -725,13 +725,13 @@ pub fn run_command<A, C, E>(
                         multi-window applications."
                     );
                 }
-                window::Action::Resize(size) => {
+                window::Action::Resize(_id, size) => {
                     window.set_inner_size(winit::dpi::LogicalSize {
                         width: size.width,
                         height: size.height,
                     });
                 }
-                window::Action::FetchSize(callback) => {
+                window::Action::FetchSize(_id, callback) => {
                     let size =
                         window.inner_size().to_logical(window.scale_factor());
 
@@ -742,29 +742,29 @@ pub fn run_command<A, C, E>(
                         )))
                         .expect("Send message to event loop");
                 }
-                window::Action::Maximize(maximized) => {
+                window::Action::Maximize(_id, maximized) => {
                     window.set_maximized(maximized);
                 }
-                window::Action::Minimize(minimized) => {
+                window::Action::Minimize(_id, minimized) => {
                     window.set_minimized(minimized);
                 }
-                window::Action::Move(position) => {
+                window::Action::Move(_id, position) => {
                     window.set_outer_position(winit::dpi::LogicalPosition {
                         x: position.x,
                         y: position.y,
                     });
                 }
-                window::Action::ChangeMode(mode) => {
+                window::Action::ChangeMode(_id, mode) => {
                     window.set_visible(conversion::visible(mode));
                     window.set_fullscreen(conversion::fullscreen(
                         window.current_monitor(),
                         mode,
                     ));
                 }
-                window::Action::ChangeIcon(icon) => {
+                window::Action::ChangeIcon(_id, icon) => {
                     window.set_window_icon(conversion::icon(icon));
                 }
-                window::Action::FetchMode(tag) => {
+                window::Action::FetchMode(_id, tag) => {
                     let mode = if window.is_visible().unwrap_or(true) {
                         conversion::mode(window.fullscreen())
                     } else {
@@ -775,29 +775,29 @@ pub fn run_command<A, C, E>(
                         .send_event(tag(mode))
                         .expect("Send message to event loop");
                 }
-                window::Action::ToggleMaximize => {
+                window::Action::ToggleMaximize(_id) => {
                     window.set_maximized(!window.is_maximized());
                 }
-                window::Action::ToggleDecorations => {
+                window::Action::ToggleDecorations(_id) => {
                     window.set_decorations(!window.is_decorated());
                 }
-                window::Action::RequestUserAttention(user_attention) => {
+                window::Action::RequestUserAttention(_id, user_attention) => {
                     window.request_user_attention(
                         user_attention.map(conversion::user_attention),
                     );
                 }
-                window::Action::GainFocus => {
+                window::Action::GainFocus(_id) => {
                     window.focus_window();
                 }
-                window::Action::ChangeLevel(level) => {
+                window::Action::ChangeLevel(_id, level) => {
                     window.set_window_level(conversion::window_level(level));
                 }
-                window::Action::FetchId(tag) => {
+                window::Action::FetchId(_id, tag) => {
                     proxy
                         .send_event(tag(window.id().into()))
                         .expect("Send message to event loop");
                 }
-                window::Action::Screenshot(tag) => {
+                window::Action::Screenshot(_id, tag) => {
                     let bytes = compositor.screenshot(
                         renderer,
                         surface,
diff --git a/winit/src/multi_window.rs b/winit/src/multi_window.rs
index 73476452..aeb2c5e1 100644
--- a/winit/src/multi_window.rs
+++ b/winit/src/multi_window.rs
@@ -361,7 +361,7 @@ async fn run_instance<A, E, C>(
             Some(window::Id::MAIN),
             core::Event::Window(
                 window::Id::MAIN,
-                window::Event::Created { position, size },
+                window::Event::Opened { position, size },
             ),
         )]
     };
@@ -402,7 +402,7 @@ async fn run_instance<A, E, C>(
                     Some(id),
                     core::Event::Window(
                         id,
-                        window::Event::Created { position, size },
+                        window::Event::Opened { position, size },
                     ),
                 ));
             }
@@ -761,7 +761,7 @@ async fn run_instance<A, E, C>(
                                         None,
                                         core::Event::Window(
                                             id,
-                                            window::Event::Destroyed,
+                                            window::Event::Closed,
                                         ),
                                     ));
                                 }
@@ -884,8 +884,8 @@ fn run_command<A, C, E>(
                     clipboard.write(contents);
                 }
             },
-            command::Action::Window(id, action) => match action {
-                window::Action::Spawn { settings } => {
+            command::Action::Window(action) => match action {
+                window::Action::Spawn(id, settings) => {
                     let monitor = windows.last_monitor();
 
                     control_sender
@@ -897,7 +897,7 @@ fn run_command<A, C, E>(
                         })
                         .expect("Send control action");
                 }
-                window::Action::Close => {
+                window::Action::Close(id) => {
                     use winit::event_loop::ControlFlow;
 
                     let i = windows.delete(id);
@@ -911,10 +911,10 @@ fn run_command<A, C, E>(
                             .expect("Send control action");
                     }
                 }
-                window::Action::Drag => {
+                window::Action::Drag(id) => {
                     let _ = windows.with_raw(id).drag_window();
                 }
-                window::Action::Resize(size) => {
+                window::Action::Resize(id, size) => {
                     windows.with_raw(id).set_inner_size(
                         winit::dpi::LogicalSize {
                             width: size.width,
@@ -922,7 +922,7 @@ fn run_command<A, C, E>(
                         },
                     );
                 }
-                window::Action::FetchSize(callback) => {
+                window::Action::FetchSize(id, callback) => {
                     let window = windows.with_raw(id);
                     let size =
                         window.inner_size().to_logical(window.scale_factor());
@@ -934,13 +934,13 @@ fn run_command<A, C, E>(
                         )))
                         .expect("Send message to event loop");
                 }
-                window::Action::Maximize(maximized) => {
+                window::Action::Maximize(id, maximized) => {
                     windows.with_raw(id).set_maximized(maximized);
                 }
-                window::Action::Minimize(minimized) => {
+                window::Action::Minimize(id, minimized) => {
                     windows.with_raw(id).set_minimized(minimized);
                 }
-                window::Action::Move(position) => {
+                window::Action::Move(id, position) => {
                     windows.with_raw(id).set_outer_position(
                         winit::dpi::LogicalPosition {
                             x: position.x,
@@ -948,7 +948,7 @@ fn run_command<A, C, E>(
                         },
                     );
                 }
-                window::Action::ChangeMode(mode) => {
+                window::Action::ChangeMode(id, mode) => {
                     let window = windows.with_raw(id);
                     window.set_visible(conversion::visible(mode));
                     window.set_fullscreen(conversion::fullscreen(
@@ -956,12 +956,12 @@ fn run_command<A, C, E>(
                         mode,
                     ));
                 }
-                window::Action::ChangeIcon(icon) => {
+                window::Action::ChangeIcon(id, icon) => {
                     windows
                         .with_raw(id)
                         .set_window_icon(conversion::icon(icon));
                 }
-                window::Action::FetchMode(tag) => {
+                window::Action::FetchMode(id, tag) => {
                     let window = windows.with_raw(id);
                     let mode = if window.is_visible().unwrap_or(true) {
                         conversion::mode(window.fullscreen())
@@ -973,33 +973,33 @@ fn run_command<A, C, E>(
                         .send_event(tag(mode))
                         .expect("Event loop doesn't exist.");
                 }
-                window::Action::ToggleMaximize => {
+                window::Action::ToggleMaximize(id) => {
                     let window = windows.with_raw(id);
                     window.set_maximized(!window.is_maximized());
                 }
-                window::Action::ToggleDecorations => {
+                window::Action::ToggleDecorations(id) => {
                     let window = windows.with_raw(id);
                     window.set_decorations(!window.is_decorated());
                 }
-                window::Action::RequestUserAttention(attention_type) => {
+                window::Action::RequestUserAttention(id, attention_type) => {
                     windows.with_raw(id).request_user_attention(
                         attention_type.map(conversion::user_attention),
                     );
                 }
-                window::Action::GainFocus => {
+                window::Action::GainFocus(id) => {
                     windows.with_raw(id).focus_window();
                 }
-                window::Action::ChangeLevel(level) => {
+                window::Action::ChangeLevel(id, level) => {
                     windows
                         .with_raw(id)
                         .set_window_level(conversion::window_level(level));
                 }
-                window::Action::FetchId(tag) => {
+                window::Action::FetchId(id, tag) => {
                     proxy
                         .send_event(tag(windows.with_raw(id).id().into()))
                         .expect("Event loop doesn't exist.");
                 }
-                window::Action::Screenshot(tag) => {
+                window::Action::Screenshot(id, tag) => {
                     let i = windows.index_from_id(id);
                     let state = &windows.states[i];
                     let surface = &mut windows.surfaces[i];