Feature: window minimisation

api/protobuf/pinnacle/window/v1/window.proto

@@ -62,6 +62,13 @@ message GetLayoutModeResponse {
   LayoutMode layout_mode = 1;
 }
 
+message GetMinimizedRequest {
+  uint32 window_id = 1;
+}
+message GetMinimizedResponse {
+  bool minimized = 1;
+}
+
 message GetTagIdsRequest {
   uint32 window_id = 1;
 }
@@ -116,16 +123,39 @@ message SetMaximizedRequest {
   pinnacle.util.v1.SetOrToggle set_or_toggle = 2;
 }
 
+message SetMinimizedRequest {
+  uint32 window_id = 1;
+  pinnacle.util.v1.SetOrToggle set_or_toggle = 2;
+}
+
+message SetMinimizedResponse {}
+
 message SetFloatingRequest {
   uint32 window_id = 1;
   pinnacle.util.v1.SetOrToggle set_or_toggle = 2;
 }
 
 message SetFocusedRequest {
+  // TrySetFocusedRequest is for the new RPC.
+  option deprecated = true;
   uint32 window_id = 1;
   pinnacle.util.v1.SetOrToggle set_or_toggle = 2;
 }
 
+message TrySetFocusedRequest {
+  uint32 window_id = 1; 
+  pinnacle.util.v1.SetOrToggle set_or_toggle = 2;
+}
+
+message TrySetFocusedResponse {
+  enum TrySetFocusedStatus {
+    TRY_SET_FOCUSED_STATUS_SUCCESS = 0;
+    TRY_SET_FOCUSED_STATUS_WINDOW_MINIMIZED = 1;
+  }
+
+  TrySetFocusedStatus status = 1;
+}
+
 enum DecorationMode {
   DECORATION_MODE_UNSPECIFIED = 0;
   DECORATION_MODE_CLIENT_SIDE = 1;
@@ -222,6 +252,7 @@ service WindowService {
   rpc GetSize(GetSizeRequest) returns (GetSizeResponse);
   rpc GetFocused(GetFocusedRequest) returns (GetFocusedResponse);
   rpc GetLayoutMode(GetLayoutModeRequest) returns (GetLayoutModeResponse);
+  rpc GetMinimized(GetMinimizedRequest) returns (GetMinimizedResponse);
   rpc GetTagIds(GetTagIdsRequest) returns (GetTagIdsResponse);
   rpc GetWindowsInDir(GetWindowsInDirRequest) returns (GetWindowsInDirResponse);
   rpc GetForeignToplevelListIdentifier(GetForeignToplevelListIdentifierRequest) returns (GetForeignToplevelListIdentifierResponse);
@@ -231,8 +262,13 @@ service WindowService {
   rpc ResizeTile(ResizeTileRequest) returns (google.protobuf.Empty);
   rpc SetFullscreen(SetFullscreenRequest) returns (google.protobuf.Empty);
   rpc SetMaximized(SetMaximizedRequest) returns (google.protobuf.Empty);
-  rpc SetFloating(SetFloatingRequest) returns (google.protobuf.Empty);
-  rpc SetFocused(SetFocusedRequest) returns (google.protobuf.Empty);
+  rpc SetMinimized(SetMinimizedRequest) returns (SetMinimizedResponse);
+  rpc SetFloating(SetFloatingRequest) returns (google.protobuf.Empty); 
+  rpc SetFocused(SetFocusedRequest) returns (google.protobuf.Empty) {
+    // use `TrySetFocused` instead.
+    option deprecated = true;
+  };
+  rpc TrySetFocused(TrySetFocusedRequest) returns (TrySetFocusedResponse);
   rpc SetDecorationMode(SetDecorationModeRequest) returns (google.protobuf.Empty);
   rpc MoveToTag(MoveToTagRequest) returns (google.protobuf.Empty);
   rpc SetTag(SetTagRequest) returns (google.protobuf.Empty);

api/rust/examples/default_config/main.rs

@@ -151,6 +151,33 @@ async fn config() {
         .group("Window")
         .description("Toggle maximized on the focused window");
 
+    // `mod_key + n` makes minimized
+    input::keybind(mod_key, 'n')
+        .on_press(|| {
+            if let Some(window) = window::get_focused() {
+                window.set_minimized(true);
+            }
+        })
+        .group("Window")
+        .description("Minimize the focused window");
+
+    // `mon_key + shift + n` unminimises the "most recently focused"
+    // minimised window that is on the active tags in this current output.
+    input::keybind(mod_key | Mod::SHIFT, 'n')
+        .on_press(|| {
+            let Some(output) = output::get_focused() else { return };
+            let Some(most_recently_minimised_active_window) = output
+                .keyboard_focus_stack_visible()
+                .filter(|w| w.minimized())
+                .last()
+            else {
+                return;
+            };
+            most_recently_minimised_active_window.set_minimized(false);
+        })
+        .group("Window")
+        .description("Unminimize the most recently focused window on the active tags");
+
     // Media keybinds ------------------------------------------------------
 
     input::keybind(Mod::empty(), Keysym::XF86_AudioRaiseVolume)
@@ -462,7 +489,7 @@ async fn config() {
 
     // Enable sloppy focus
     window::connect_signal(WindowSignal::PointerEnter(Box::new(|win| {
-        win.set_focused(true);
+        let _ = win.try_set_focused(true);
     })));
 
     // Focus outputs when the pointer enters them

api/rust/src/util.rs

@@ -269,3 +269,26 @@ impl From<Rect> for pinnacle_api_defs::pinnacle::util::v1::Rect {
         }
     }
 }
+
+/// Extension trait for [`Result`].
+pub(crate) trait ResultExt {
+    type T;
+    type E;
+
+    /// Swap the "error" and "ok" components of a result.
+    fn swap_ok_err(self) -> Result<Self::E, Self::T>;
+}
+
+impl<T, E> ResultExt for Result<T, E> {
+    type T = T;
+
+    type E = E;
+
+    #[inline(always)]
+    fn swap_ok_err(self) -> Result<Self::E, Self::T> {
+        match self {
+            Ok(t) => Err(t),
+            Err(e) => Ok(e),
+        }
+    }
+}

api/rust/src/window.rs

@@ -19,12 +19,12 @@ use pinnacle_api_defs::pinnacle::{
         self,
         v1::{
             GetAppIdRequest, GetFocusedRequest, GetForeignToplevelListIdentifierRequest,
-            GetLayoutModeRequest, GetLocRequest, GetSizeRequest, GetTagIdsRequest, GetTitleRequest,
-            GetWindowsInDirRequest, LowerRequest, MoveGrabRequest, MoveToOutputRequest,
-            MoveToTagRequest, RaiseRequest, ResizeGrabRequest, ResizeTileRequest,
-            SetDecorationModeRequest, SetFloatingRequest, SetFocusedRequest, SetFullscreenRequest,
-            SetGeometryRequest, SetMaximizedRequest, SetTagRequest, SetTagsRequest,
-            SetVrrDemandRequest, SwapRequest,
+            GetLayoutModeRequest, GetLocRequest, GetMinimizedRequest, GetSizeRequest,
+            GetTagIdsRequest, GetTitleRequest, GetWindowsInDirRequest, LowerRequest,
+            MoveGrabRequest, MoveToOutputRequest, MoveToTagRequest, RaiseRequest,
+            ResizeGrabRequest, ResizeTileRequest, SetDecorationModeRequest, SetFloatingRequest,
+            SetFullscreenRequest, SetGeometryRequest, SetMaximizedRequest, SetMinimizedRequest,
+            SetTagRequest, SetTagsRequest, SetVrrDemandRequest, SwapRequest, TrySetFocusedRequest,
         },
     },
 };
@@ -38,7 +38,7 @@ use crate::{
     output::OutputHandle,
     signal::{SignalHandle, WindowSignal},
     tag::TagHandle,
-    util::{Batch, Direction, Point, Size},
+    util::{Batch, Direction, Point, ResultExt, Size},
 };
 
 /// Gets handles to all windows.
@@ -235,6 +235,29 @@ impl VrrDemand {
     }
 }
 
+/// Error when trying to focus/unfocus a window.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum TrySetFocusedError {
+    /// Window was minimized and could not be focused.
+    WindowMinimized,
+}
+
+impl TryFrom<pinnacle_api_defs::pinnacle::window::v1::TrySetFocusedResponse>
+    for TrySetFocusedError
+{
+    type Error = ();
+
+    fn try_from(
+        value: pinnacle_api_defs::pinnacle::window::v1::TrySetFocusedResponse,
+    ) -> Result<Self, Self::Error> {
+        use pinnacle_api_defs::pinnacle::window::v1::try_set_focused_response::TrySetFocusedStatus;
+        match value.status() {
+            TrySetFocusedStatus::Success => Err(()),
+            TrySetFocusedStatus::WindowMinimized => Ok(Self::WindowMinimized),
+        }
+    }
+}
+
 impl WindowHandle {
     /// Sends a close request to this window.
     ///
@@ -365,6 +388,34 @@ impl WindowHandle {
             .unwrap();
     }
 
+    /// Sets this window to minimized or not.
+    pub fn set_minimized(&self, set: bool) {
+        let window_id = self.id;
+        Client::window()
+            .set_minimized(SetMinimizedRequest {
+                window_id,
+                set_or_toggle: match set {
+                    true => SetOrToggle::Set,
+                    false => SetOrToggle::Unset,
+                }
+                .into(),
+            })
+            .block_on_tokio()
+            .unwrap();
+    }
+
+    /// Toggles this window between minimized and not.
+    pub fn toggle_minimized(&self) {
+        let window_id = self.id;
+        Client::window()
+            .set_minimized(SetMinimizedRequest {
+                window_id,
+                set_or_toggle: SetOrToggle::Toggle.into(),
+            })
+            .block_on_tokio()
+            .unwrap();
+    }
+
     /// Sets this window to floating or not.
     ///
     /// Floating windows will not be tiled and can be moved around and resized freely.
@@ -398,10 +449,20 @@ impl WindowHandle {
     }
 
     /// Focuses or unfocuses this window.
+    ///
+    /// Silently fails if trying to focus a minimized window.
+    #[deprecated = "use `WindowHandle::try_set_focused` instead"]
     pub fn set_focused(&self, set: bool) {
+        let _ = self.try_set_focused(set);
+    }
+
+    /// Tries to focus or unfocus this window.
+    ///
+    /// Fails if the window is minimized.
+    pub fn try_set_focused(&self, set: bool) -> Result<(), TrySetFocusedError> {
         let window_id = self.id;
         Client::window()
-            .set_focused(SetFocusedRequest {
+            .try_set_focused(TrySetFocusedRequest {
                 window_id,
                 set_or_toggle: match set {
                     true => SetOrToggle::Set,
@@ -410,19 +471,35 @@ impl WindowHandle {
                 .into(),
             })
             .block_on_tokio()
-            .unwrap();
+            .expect("successful rpc communication is expected")
+            .into_inner()
+            .try_into()
+            .swap_ok_err()
     }
 
     /// Toggles this window between focused and unfocused.
+    ///
+    /// Silently fails if trying to focus a minimized window.
+    #[deprecated = "use `WindowHandle::try_toggle_focused` instead"]
     pub fn toggle_focused(&self) {
+        let _ = self.try_toggle_focused();
+    }
+
+    /// Tries to toggle this window between focused and unfocused.
+    ///
+    /// Fails if the window is minimized.
+    pub fn try_toggle_focused(&self) -> Result<(), TrySetFocusedError> {
         let window_id = self.id;
         Client::window()
-            .set_focused(SetFocusedRequest {
+            .try_set_focused(TrySetFocusedRequest {
                 window_id,
                 set_or_toggle: SetOrToggle::Toggle.into(),
             })
             .block_on_tokio()
-            .unwrap();
+            .expect("successful rpc communication is expected")
+            .into_inner()
+            .try_into()
+            .swap_ok_err()
     }
 
     /// Sets this window's decoration mode.
@@ -807,6 +884,22 @@ impl WindowHandle {
         self.layout_mode_async().await == LayoutMode::Maximized
     }
 
+    /// Gets whether or not this window is minimized
+    pub fn minimized(&self) -> bool {
+        self.minimized_async().block_on_tokio()
+    }
+
+    /// Async impl for [`Self::minimized`]
+    pub async fn minimized_async(&self) -> bool {
+        let window_id = self.id;
+        Client::window()
+            .get_minimized(GetMinimizedRequest { window_id })
+            .await
+            .unwrap()
+            .into_inner()
+            .minimized
+    }
+
     /// Gets handles to all tags on this window.
     pub fn tags(&self) -> impl Iterator<Item = TagHandle> + use<> {
         self.tags_async().block_on_tokio()