Implement SetMode and FetchMode window actions

native/src/command/action.rs

@@ -20,7 +20,7 @@ pub enum Action<T> {
     Clipboard(clipboard::Action<T>),
 
     /// Run a window action.
-    Window(window::Action),
+    Window(window::Action<T>),
 
     /// Run a system action.
     System(system::Action<T>),
@@ -46,7 +46,7 @@ impl<T> Action<T> {
         match self {
             Self::Future(future) => Action::Future(Box::pin(future.map(f))),
             Self::Clipboard(action) => Action::Clipboard(action.map(f)),
-            Self::Window(window) => Action::Window(window),
+            Self::Window(window) => Action::Window(window.map(f)),
             Self::System(system) => Action::System(system.map(f)),
             Self::Widget(widget) => Action::Widget(widget.map(f)),
         }

native/src/window.rs

@@ -1,6 +1,8 @@
 //! Build window-based GUI applications.
 mod action;
 mod event;
+mod mode;
 
 pub use action::Action;
 pub use event::Event;
+pub use mode::Mode;

native/src/window/action.rs

@@ -1,6 +1,10 @@
+use crate::window::Mode;
+
+use iced_futures::MaybeSend;
+use std::fmt;
+
 /// An operation to be performed on some window.
-#[derive(Debug)]
+pub enum Action<T> {
-pub enum Action {
     /// Resize the window.
     Resize {
         /// The new logical width of the window
@@ -15,4 +19,43 @@ pub enum Action {
         /// The new logical y location of the window
         y: i32,
     },
+    /// Set the [`Mode`] of the window.
+    SetMode(Mode),
+    /// Fetch the current [`Mode`] of the window.
+    FetchMode(Box<dyn FnOnce(Mode) -> T + 'static>),
+}
+
+impl<T> Action<T> {
+    /// Maps the output of a window [`Action`] using the provided closure.
+    pub fn map<A>(
+        self,
+        f: impl Fn(T) -> A + 'static + MaybeSend + Sync,
+    ) -> Action<A>
+    where
+        T: 'static,
+    {
+        match self {
+            Self::Resize { width, height } => Action::Resize { width, height },
+            Self::Move { x, y } => Action::Move { x, y },
+            Self::SetMode(mode) => Action::SetMode(mode),
+            Self::FetchMode(o) => Action::FetchMode(Box::new(move |s| f(o(s)))),
+        }
+    }
+}
+
+impl<T> fmt::Debug for Action<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Resize { width, height } => write!(
+                f,
+                "Action::Resize {{ widget: {}, height: {} }}",
+                width, height
+            ),
+            Self::Move { x, y } => {
+                write!(f, "Action::Move {{ x: {}, y: {} }}", x, y)
+            }
+            Self::SetMode(mode) => write!(f, "Action::SetMode({:?})", mode),
+            Self::FetchMode(_) => write!(f, "Action::FetchMode"),
+        }
+    }
 }

native/src/window/mode.rs

@@ -0,0 +1,12 @@
+/// The mode of a window-based application.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Mode {
+    /// The application appears in its own window.
+    Windowed,
+
+    /// The application takes the whole screen of its current monitor.
+    Fullscreen,
+
+    /// The application is hidden
+    Hidden,
+}

winit/src/application.rs

@@ -640,6 +640,20 @@ pub fn run_command<A, E>(
                         y,
                     });
                 }
+                window::Action::SetMode(mode) => {
+                    window.set_visible(conversion::visible(mode));
+                    window.set_fullscreen(conversion::fullscreen(
+                        window.primary_monitor(),
+                        mode,
+                    ));
+                }
+                window::Action::FetchMode(tag) => {
+                    let mode = conversion::mode(window.fullscreen());
+
+                    proxy
+                        .send_event(tag(mode))
+                        .expect("Send message to event loop");
+                }
             },
             command::Action::System(action) => match action {
                 system::Action::QueryInformation(_tag) => {

winit/src/conversion.rs

@@ -182,6 +182,39 @@ pub fn position(
     }
 }
 
+/// Converts a [`window::Mode`] to a [`winit`] fullscreen mode.
+///
+/// [`winit`]: https://github.com/rust-windowing/winit
+pub fn fullscreen(
+    monitor: Option<winit::monitor::MonitorHandle>,
+    mode: window::Mode,
+) -> Option<winit::window::Fullscreen> {
+    match mode {
+        window::Mode::Windowed | window::Mode::Hidden => None,
+        window::Mode::Fullscreen => {
+            Some(winit::window::Fullscreen::Borderless(monitor))
+        }
+    }
+}
+
+/// Converts a [`window::Mode`] to a visibility flag.
+pub fn visible(mode: window::Mode) -> bool {
+    match mode {
+        window::Mode::Windowed | window::Mode::Fullscreen => true,
+        window::Mode::Hidden => false,
+    }
+}
+
+/// Converts a [`winit`] fullscreen mode to a [`window::Mode`].
+///
+/// [`winit`]: https://github.com/rust-windowing/winit
+pub fn mode(mode: Option<winit::window::Fullscreen>) -> window::Mode {
+    match mode {
+        None => window::Mode::Windowed,
+        Some(_) => window::Mode::Fullscreen,
+    }
+}
+
 /// Converts a `MouseCursor` from [`iced_native`] to a [`winit`] cursor icon.
 ///
 /// [`winit`]: https://github.com/rust-windowing/winit

winit/src/window.rs

@@ -2,7 +2,7 @@
 use crate::command::{self, Command};
 use iced_native::window;
 
-pub use window::Event;
+pub use window::{Event, Mode};
 
 /// Resizes the window to the given logical dimensions.
 pub fn resize<Message>(width: u32, height: u32) -> Command<Message> {
@@ -16,3 +16,17 @@ pub fn resize<Message>(width: u32, height: u32) -> Command<Message> {
 pub fn move_to<Message>(x: i32, y: i32) -> Command<Message> {
     Command::single(command::Action::Window(window::Action::Move { x, y }))
 }
+
+/// Sets the [`Mode`] of the window.
+pub fn set_mode<Message>(mode: Mode) -> Command<Message> {
+    Command::single(command::Action::Window(window::Action::SetMode(mode)))
+}
+
+/// Fetches the current [`Mode`] of the window.
+pub fn fetch_mode<Message>(
+    f: impl FnOnce(Mode) -> Message + 'static,
+) -> Command<Message> {
+    Command::single(command::Action::Window(window::Action::FetchMode(
+        Box::new(f),
+    )))
+}