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,6 +123,11 @@ 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 SetFloatingRequest {
   uint32 window_id = 1;
   pinnacle.util.v1.SetOrToggle set_or_toggle = 2;
@@ -222,6 +234,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,6 +244,7 @@ service WindowService {
   rpc ResizeTile(ResizeTileRequest) returns (google.protobuf.Empty);
   rpc SetFullscreen(SetFullscreenRequest) returns (google.protobuf.Empty);
   rpc SetMaximized(SetMaximizedRequest) returns (google.protobuf.Empty);
+  rpc SetMinimized(SetMinimizedRequest) returns (google.protobuf.Empty);
   rpc SetFloating(SetFloatingRequest) returns (google.protobuf.Empty);
   rpc SetFocused(SetFocusedRequest) returns (google.protobuf.Empty);
   rpc SetDecorationMode(SetDecorationModeRequest) 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)

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,
+            SetFocusedRequest, SetFullscreenRequest, SetGeometryRequest, SetMaximizedRequest,
+            SetMinimizedRequest, SetTagRequest, SetTagsRequest, SetVrrDemandRequest, SwapRequest,
         },
     },
 };
@@ -365,6 +365,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.
@@ -807,6 +835,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()

src/api/window.rs

@@ -65,13 +65,51 @@ pub fn set_geometry(
     );
 }
 
-// TODO: minimized
+/// Sets or toggles if a window is minimized.
+///
+/// Minimized windows are always unfocused.
+pub fn set_minimized(state: &mut State, window: &WindowElement, set: impl Into<Option<bool>>) {
+    if window.is_x11_override_redirect() {
+        return;
+    }
+
+    let set = set.into();
+
+    let is_minimized = window.with_state(|state| state.minimized);
+    let set = match set {
+        Some(absolute_set) => absolute_set,
+        None => !is_minimized,
+    };
+    window.with_state_mut(|state| state.minimized = set);
+
+    if !set && state.pinnacle.keyboard_focus_stack.current_focus() == Some(window) {
+        state.pinnacle.keyboard_focus_stack.unset_focus();
+    }
+
+    // Note: tag moving will automatically adjust the output on the window directly even if
+    // minimised, so we can rely on this.
+    let Some(output) = window.output(&state.pinnacle) else {
+        warn!("adjusted minimization-state of window without an output.");
+        return;
+    };
+
+    // This means we can rely on the output associated with the [`WindowElementState`] even while
+    // minimized, and we can use it to schedule layouts.
+    if set != is_minimized {
+        state.pinnacle.request_layout(&output);
+        state.schedule_render(&output);
+        state.pinnacle.update_xwayland_stacking_order();
+    }
+}
 
 /// Sets a window to focused or not.
 ///
 /// If the window is on another output and an attempt is made to
 /// focus it, the focused output will change to that output UNLESS
 /// the window overlaps the currently focused output.
+///
+/// If the window is being set to be focused, then if it's minimized,
+/// this will automatically unminimize it.
 pub fn set_focused(state: &mut State, window: &WindowElement, set: impl Into<Option<bool>>) {
     if window.is_x11_override_redirect() {
         return;
@@ -140,6 +178,11 @@ pub fn set_focused(state: &mut State, window: &WindowElement, set: impl Into<Opt
                 }
             }
         }
+
+        if window.with_state(|window_state| window_state.minimized) {
+            // Will automatically do correct scheduling of re-layouting and such ^.^
+            set_minimized(state, window, false);
+        }
     } else {
         state.pinnacle.keyboard_focus_stack.unset_focus();
     }

src/api/window/v1.rs

@@ -12,15 +12,15 @@ use pinnacle_api_defs::pinnacle::{
             self, CloseRequest, GetAppIdRequest, GetAppIdResponse, GetFocusedRequest,
             GetFocusedResponse, GetForeignToplevelListIdentifierRequest,
             GetForeignToplevelListIdentifierResponse, GetLayoutModeRequest, GetLayoutModeResponse,
-            GetLocRequest, GetLocResponse, GetRequest, GetResponse, GetSizeRequest,
-            GetSizeResponse, GetTagIdsRequest, GetTagIdsResponse, GetTitleRequest,
-            GetTitleResponse, GetWindowsInDirRequest, GetWindowsInDirResponse, LowerRequest,
-            LowerResponse, MoveGrabRequest, MoveToOutputRequest, MoveToOutputResponse,
-            MoveToTagRequest, RaiseRequest, ResizeGrabRequest, ResizeTileRequest,
-            SetDecorationModeRequest, SetFloatingRequest, SetFocusedRequest, SetFullscreenRequest,
-            SetGeometryRequest, SetMaximizedRequest, SetTagRequest, SetTagsRequest,
-            SetTagsResponse, SetVrrDemandRequest, SetVrrDemandResponse, SwapRequest, SwapResponse,
-            WindowRuleRequest, WindowRuleResponse,
+            GetLocRequest, GetLocResponse, GetMinimizedRequest, GetMinimizedResponse, GetRequest,
+            GetResponse, GetSizeRequest, GetSizeResponse, GetTagIdsRequest, GetTagIdsResponse,
+            GetTitleRequest, GetTitleResponse, GetWindowsInDirRequest, GetWindowsInDirResponse,
+            LowerRequest, LowerResponse, MoveGrabRequest, MoveToOutputRequest,
+            MoveToOutputResponse, MoveToTagRequest, RaiseRequest, ResizeGrabRequest,
+            ResizeTileRequest, SetDecorationModeRequest, SetFloatingRequest, SetFocusedRequest,
+            SetFullscreenRequest, SetGeometryRequest, SetMaximizedRequest, SetMinimizedRequest,
+            SetTagRequest, SetTagsRequest, SetTagsResponse, SetVrrDemandRequest,
+            SetVrrDemandResponse, SwapRequest, SwapResponse, WindowRuleRequest, WindowRuleResponse,
         },
     },
 };
@@ -194,6 +194,27 @@ impl v1::window_service_server::WindowService for super::WindowService {
         .await
     }
 
+    async fn get_minimized(
+        &self,
+        request: Request<GetMinimizedRequest>,
+    ) -> TonicResult<GetMinimizedResponse> {
+        let window_id = WindowId(request.into_inner().window_id);
+
+        run_unary(&self.sender, move |state| {
+            let minimized = window_id
+                .window(&state.pinnacle)
+                .or_else(|| {
+                    window_id
+                        .unmapped_window(&state.pinnacle)
+                        .map(|unmapped| unmapped.window.clone())
+                })
+                .map(|win| win.with_state(|state| state.minimized))
+                .unwrap_or(false);
+            Ok(GetMinimizedResponse { minimized })
+        })
+        .await
+    }
+
     async fn get_tag_ids(
         &self,
         request: Request<GetTagIdsRequest>,
@@ -479,6 +500,31 @@ impl v1::window_service_server::WindowService for super::WindowService {
         .await
     }
 
+    async fn set_minimized(&self, request: Request<SetMinimizedRequest>) -> TonicResult<()> {
+        let request = request.into_inner();
+        let window_id = WindowId(request.window_id);
+        let absolute_minimized = match request.set_or_toggle() {
+            SetOrToggle::Unspecified => {
+                return Err(Status::invalid_argument("unspecified set or toggle"));
+            }
+            SetOrToggle::Set => Some(true),
+            SetOrToggle::Unset => Some(false),
+            SetOrToggle::Toggle => None,
+        };
+
+        run_unary_no_response(&self.sender, move |state| {
+            if let Some(window) = window_id.window(&state.pinnacle) {
+                crate::api::window::set_minimized(state, &window, absolute_minimized);
+            } else if let Some(unmapped) = window_id.unmapped_window_mut(&mut state.pinnacle)
+                && let UnmappedState::WaitingForRules { rules: _, .. } = &mut unmapped.state
+            {
+                // TODO: find a way to immediately minimize a window upon mapping.
+                warn!("minimizing unmapped windows not yet supported");
+            }
+        })
+        .await
+    }
+
     async fn set_floating(&self, request: Request<SetFloatingRequest>) -> TonicResult<()> {
         let request = request.into_inner();
 

src/focus.rs

@@ -365,7 +365,7 @@ impl WindowKeyboardFocusStack {
     /// Gets the currently focused window on this stack.
     ///
     /// This is the topmost window that is on an active tag and not
-    /// an OR window.
+    /// an OR window, and is not minimized.
     pub fn current_focus(&self) -> Option<&WindowElement> {
         if !self.focused {
             return None;
@@ -375,6 +375,7 @@ impl WindowKeyboardFocusStack {
             .iter()
             .rev()
             .filter(|win| win.is_on_active_tag())
+            .filter(|win| win.with_state(|state| !state.minimized))
             .find(|win| !win.is_x11_override_redirect())
     }
 }

src/handlers/foreign_toplevel.rs

@@ -21,6 +21,9 @@ impl ForeignToplevelHandler for State {
             return;
         };
 
+        // TODO make a nice `self.pinnacle` function somewhere for this?? IDK though >.<
+        let was_minimized = window.with_state(|state| state.minimized);
+        window.with_state_mut(|state| state.minimized = false);
         self.pinnacle.keyboard_focus_stack.set_focus(window.clone());
         self.pinnacle.raise_window(window.clone());
 
@@ -37,6 +40,11 @@ impl ForeignToplevelHandler for State {
                 crate::api::tag::switch_to(self, &tag);
             }
         } else {
+            // Need to re-layout things if the window was un-minimized.
+            if was_minimized {
+                self.pinnacle.update_xwayland_stacking_order();
+                self.pinnacle.request_layout(&output);
+            }
             self.schedule_render(&output);
         }
     }
@@ -103,7 +111,6 @@ impl ForeignToplevelHandler for State {
             });
     }
 
-    // TODO:
     fn set_minimized(&mut self, wl_surface: WlSurface) {
         let _span = tracy_client::span!("ForeignToplevelHandler::set_minimized");
 
@@ -121,7 +128,6 @@ impl ForeignToplevelHandler for State {
         self.schedule_render(&output);
     }
 
-    // TODO:
     fn unset_minimized(&mut self, wl_surface: WlSurface) {
         let _span = tracy_client::span!("ForeignToplevelHandler::unset_minimized");
 

src/handlers/xwayland.rs

@@ -601,7 +601,9 @@ impl Pinnacle {
             .iter()
             .filter_map(|z| z.window())
             .filter(|win| !win.is_x11_override_redirect())
-            .partition::<Vec<_>, _>(|win| win.is_on_active_tag());
+            .partition::<Vec<_>, _>(|win| {
+                win.is_on_active_tag() && win.with_state(|state| !state.minimized)
+            });
 
         let active_windows = active_windows.into_iter().flat_map(|win| win.x11_surface());
         let non_active_windows = non_active_windows