Merge branch 'master' into remove-vertex-indexing

1 files changed, 117 insertions, 80 deletions

diff --git a/runtime/src/window/action.rs b/runtime/src/window/action.rs
index b6964e36..8b532569 100644
--- a/runtime/src/window/action.rs
+++ b/runtime/src/window/action.rs
@@ -1,5 +1,5 @@
-use crate::core::window::{Icon, Level, Mode, UserAttention};
-use crate::core::Size;
+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,51 @@ 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,
-    /// Resize the window.
-    Resize(Size<u32>),
-    /// Fetch the current size of the window.
-    FetchSize(Box<dyn FnOnce(Size<u32>) -> T + 'static>),
+    Drag(Id),
+    /// Resize the window to the given logical dimensions.
+    Resize(Id, Size),
+    /// Fetch the current logical dimensions of the window.
+    FetchSize(Id, Box<dyn FnOnce(Size) -> T + 'static>),
+    /// Fetch if the current window is maximized or not.
+    ///
+    /// ## Platform-specific
+    /// - **iOS / Android / Web:** Unsupported.
+    FetchMaximized(Id, Box<dyn FnOnce(bool) -> T + 'static>),
     /// Set the window to maximized or back
-    Maximize(bool),
+    Maximize(Id, bool),
+    /// Fetch if the current window is minimized or not.
+    ///
+    /// ## Platform-specific
+    /// - **Wayland:** Always `None`.
+    /// - **iOS / Android / Web:** Unsupported.
+    FetchMinimized(Id, Box<dyn FnOnce(Option<bool>) -> T + 'static>),
     /// Set the window to minimized or back
-    Minimize(bool),
-    /// Move the window.
+    Minimize(Id, bool),
+    /// Move the window to the given logical coordinates.
     ///
     /// Unsupported on Wayland.
-    Move {
-        /// The new logical x location of the window
-        x: i32,
-        /// The new logical y location of the window
-        y: i32,
-    },
+    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 +65,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 +76,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 +95,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,29 +110,41 @@ impl<T> Action<T> {
         T: 'static,
     {
         match self {
-            Self::Close => Action::Close,
-            Self::Drag => Action::Drag,
-            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 { x, y } => Action::Move { x, y },
-            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::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::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::FetchMaximized(id, o) => {
+                Action::FetchMaximized(id, Box::new(move |s| f(o(s))))
+            }
+            Self::Maximize(id, maximized) => Action::Maximize(id, maximized),
+            Self::FetchMinimized(id, o) => {
+                Action::FetchMinimized(id, Box::new(move |s| f(o(s))))
+            }
+            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))),
+            ),
         }
     }
 }
@@ -132,35 +152,52 @@ 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::Resize(size) => write!(f, "Action::Resize({size:?})"),
-            Self::FetchSize(_) => write!(f, "Action::FetchSize"),
-            Self::Maximize(maximized) => {
-                write!(f, "Action::Maximize({maximized})")
-            }
-            Self::Minimize(minimized) => {
-                write!(f, "Action::Minimize({minimized}")
-            }
-            Self::Move { x, y } => {
-                write!(f, "Action::Move {{ x: {x}, y: {y} }}")
-            }
-            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::GainFocus => write!(f, "Action::GainFocus"),
-            Self::ChangeLevel(level) => {
-                write!(f, "Action::ChangeLevel({level:?})")
-            }
-            Self::FetchId(_) => write!(f, "Action::FetchId"),
-            Self::ChangeIcon(_icon) => {
-                write!(f, "Action::ChangeIcon(icon)")
-            }
-            Self::Screenshot(_) => write!(f, "Action::Screenshot"),
+            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::FetchMaximized(id, _) => {
+                write!(f, "Action::FetchMaximized({id:?})")
+            }
+            Self::Maximize(id, maximized) => {
+                write!(f, "Action::Maximize({id:?}, {maximized})")
+            }
+            Self::FetchMinimized(id, _) => {
+                write!(f, "Action::FetchMinimized({id:?})")
+            }
+            Self::Minimize(id, minimized) => {
+                write!(f, "Action::Minimize({id:?}, {minimized}")
+            }
+            Self::Move(id, position) => {
+                write!(f, "Action::Move({id:?}, {position})")
+            }
+            Self::ChangeMode(id, mode) => {
+                write!(f, "Action::SetMode({id:?}, {mode:?})")
+            }
+            Self::FetchMode(id, _) => write!(f, "Action::FetchMode({id:?})"),
+            Self::ToggleMaximize(id) => {
+                write!(f, "Action::ToggleMaximize({id:?})")
+            }
+            Self::ToggleDecorations(id) => {
+                write!(f, "Action::ToggleDecorations({id:?})")
+            }
+            Self::RequestUserAttention(id, _) => {
+                write!(f, "Action::RequestUserAttention({id:?})")
+            }
+            Self::GainFocus(id) => write!(f, "Action::GainFocus({id:?})"),
+            Self::ChangeLevel(id, level) => {
+                write!(f, "Action::ChangeLevel({id:?}, {level:?})")
+            }
+            Self::FetchId(id, _) => write!(f, "Action::FetchId({id:?})"),
+            Self::ChangeIcon(id, _icon) => {
+                write!(f, "Action::ChangeIcon({id:?})")
+            }
+            Self::Screenshot(id, _) => write!(f, "Action::Screenshot({id:?})"),
         }
     }
 }