Merge pull request #1471 from pop-os/cosmic-window-controls

feat: Additional actions for window controls

native/src/window/action.rs

@@ -5,13 +5,23 @@ use std::fmt;
 
 /// An operation to be performed on some window.
 pub enum Action<T> {
+    /// Moves 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 {
         /// The new logical width of the window
         width: u32,
         /// The new logical height of the window
         height: u32,
     },
+    /// Sets the window to maximized or back
+    Maximize(bool),
+    /// Set the window to minimized or back
+    Minimize(bool),
     /// Move the window.
     ///
     /// Unsupported on Wayland.
@@ -23,6 +33,8 @@ pub enum Action<T> {
     },
     /// Set the [`Mode`] of the window.
     SetMode(Mode),
+    /// Sets the window to maximized or back
+    ToggleMaximize,
     /// Fetch the current [`Mode`] of the window.
     FetchMode(Box<dyn FnOnce(Mode) -> T + 'static>),
 }
@@ -37,9 +49,13 @@ impl<T> Action<T> {
         T: 'static,
     {
         match self {
+            Self::Drag => Action::Drag,
             Self::Resize { width, height } => Action::Resize { width, height },
+            Self::Maximize(bool) => Action::Maximize(bool),
+            Self::Minimize(bool) => Action::Minimize(bool),
             Self::Move { x, y } => Action::Move { x, y },
             Self::SetMode(mode) => Action::SetMode(mode),
+            Self::ToggleMaximize => Action::ToggleMaximize,
             Self::FetchMode(o) => Action::FetchMode(Box::new(move |s| f(o(s)))),
         }
     }
@@ -48,15 +64,19 @@ impl<T> Action<T> {
 impl<T> fmt::Debug for Action<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
+            Self::Drag => write!(f, "Action::Drag"),
             Self::Resize { width, height } => write!(
                 f,
                 "Action::Resize {{ widget: {}, height: {} }}",
                 width, height
             ),
+            Self::Maximize(value) => write!(f, "Action::Maximize({})", value),
+            Self::Minimize(value) => write!(f, "Action::Minimize({}", value),
             Self::Move { x, y } => {
                 write!(f, "Action::Move {{ x: {}, y: {} }}", x, y)
             }
             Self::SetMode(mode) => write!(f, "Action::SetMode({:?})", mode),
+            Self::ToggleMaximize => write!(f, "Action::ToggleMaximize"),
             Self::FetchMode(_) => write!(f, "Action::FetchMode"),
         }
     }

winit/src/application.rs

@@ -615,12 +615,21 @@ pub fn run_command<A, E>(
                 }
             },
             command::Action::Window(action) => match action {
+                window::Action::Drag => {
+                    let _res = window.drag_window();
+                }
                 window::Action::Resize { width, height } => {
                     window.set_inner_size(winit::dpi::LogicalSize {
                         width,
                         height,
                     });
                 }
+                window::Action::Maximize(value) => {
+                    window.set_maximized(value);
+                }
+                window::Action::Minimize(value) => {
+                    window.set_minimized(value);
+                }
                 window::Action::Move { x, y } => {
                     window.set_outer_position(winit::dpi::LogicalPosition {
                         x,
@@ -634,6 +643,9 @@ pub fn run_command<A, E>(
                         mode,
                     ));
                 }
+                window::Action::ToggleMaximize => {
+                    window.set_maximized(!window.is_maximized())
+                }
                 window::Action::FetchMode(tag) => {
                     let mode = if window.is_visible().unwrap_or(true) {
                         conversion::mode(window.fullscreen())

winit/src/window.rs

@@ -4,6 +4,11 @@ use iced_native::window;
 
 pub use window::{Event, Mode};
 
+/// Begins dragging the window while the left mouse button is held.
+pub fn drag<Message>() -> Command<Message> {
+    Command::single(command::Action::Window(window::Action::Drag))
+}
+
 /// Resizes the window to the given logical dimensions.
 pub fn resize<Message>(width: u32, height: u32) -> Command<Message> {
     Command::single(command::Action::Window(window::Action::Resize {
@@ -12,6 +17,16 @@ pub fn resize<Message>(width: u32, height: u32) -> Command<Message> {
     }))
 }
 
+/// Sets the window to maximized or back.
+pub fn maximize<Message>(value: bool) -> Command<Message> {
+    Command::single(command::Action::Window(window::Action::Maximize(value)))
+}
+
+/// Set the window to minimized or back.
+pub fn minimize<Message>(value: bool) -> Command<Message> {
+    Command::single(command::Action::Window(window::Action::Minimize(value)))
+}
+
 /// Moves a window to the given logical coordinates.
 pub fn move_to<Message>(x: i32, y: i32) -> Command<Message> {
     Command::single(command::Action::Window(window::Action::Move { x, y }))
@@ -22,6 +37,11 @@ pub fn set_mode<Message>(mode: Mode) -> Command<Message> {
     Command::single(command::Action::Window(window::Action::SetMode(mode)))
 }
 
+/// Sets the window to maximized or back.
+pub fn toggle_maximize<Message>() -> Command<Message> {
+    Command::single(command::Action::Window(window::Action::ToggleMaximize))
+}
+
 /// Fetches the current [`Mode`] of the window.
 pub fn fetch_mode<Message>(
     f: impl FnOnce(Mode) -> Message + 'static,