From 3eb3e3b1c0fc6d7794cb410cd04dcf8dc6990d8d Mon Sep 17 00:00:00 2001
From: Victoria Brekenfeld <victoria@system76.com>
Date: Mon, 8 Jul 2024 20:33:25 +0200
Subject: [PATCH] xwm: Fix edge-cases for fullscreening

---
 src/shell/workspace.rs | 12 +++++-------
 src/xwayland.rs        | 43 +++++++++++++++++++++---------------------
 2 files changed, 27 insertions(+), 28 deletions(-)

diff --git a/src/shell/workspace.rs b/src/shell/workspace.rs
index bff8c956..c161886d 100644
--- a/src/shell/workspace.rs
+++ b/src/shell/workspace.rs
@@ -788,7 +788,7 @@ impl Workspace {
         self.fullscreen
             .as_ref()
             .filter(|f| f.alive())
-            .filter(|f| f.ended_at.is_none() && f.start_at.is_none())
+            .filter(|f| f.ended_at.is_none())
             .map(|f| &f.surface)
     }
 
@@ -800,11 +800,9 @@ impl Workspace {
         amount: i32,
     ) -> bool {
         if let Some(toplevel) = focused.toplevel() {
-            if self
-                .fullscreen
-                .as_ref()
-                .is_some_and(|f| f.surface.wl_surface().as_deref() == Some(&toplevel))
-            {
+            if self.fullscreen.as_ref().is_some_and(|f| {
+                f.ended_at.is_none() && f.surface.wl_surface().as_deref() == Some(&toplevel)
+            }) {
                 return false;
             }
         }
@@ -934,7 +932,7 @@ impl Workspace {
     pub fn is_fullscreen(&self, mapped: &CosmicMapped) -> bool {
         self.fullscreen
             .as_ref()
-            .is_some_and(|f| f.surface == mapped.active_window())
+            .is_some_and(|f| f.ended_at.is_none() && f.surface == mapped.active_window())
             || self
                 .minimized_windows
                 .iter()
diff --git a/src/xwayland.rs b/src/xwayland.rs
index d9e0fb63..62ae3886 100644
--- a/src/xwayland.rs
+++ b/src/xwayland.rs
@@ -213,20 +213,20 @@ impl Common {
                                                     .map(|m| &m.window),
                                             )
                                             .flat_map(|mapped| {
-                                            let active = mapped.active_window();
-                                            std::iter::once(active.clone()).chain(
-                                                mapped
-                                                    .is_stack()
-                                                    .then(move || {
-                                                        mapped
-                                                            .windows()
-                                                            .map(|(s, _)| s)
-                                                            .filter(move |s| s != &active)
-                                                    })
-                                                    .into_iter()
-                                                    .flatten(),
-                                            )
-                                        }),
+                                                let active = mapped.active_window();
+                                                std::iter::once(active.clone()).chain(
+                                                    mapped
+                                                        .is_stack()
+                                                        .then(move || {
+                                                            mapped
+                                                                .windows()
+                                                                .map(|(s, _)| s)
+                                                                .filter(move |s| s != &active)
+                                                        })
+                                                        .into_iter()
+                                                        .flatten(),
+                                                )
+                                            }),
                                     )
                                 }),
                         )
@@ -376,14 +376,15 @@ impl XwmHandler for State {
         // We only allow floating X11 windows to resize themselves. Nothing else
         let shell = self.common.shell.read().unwrap();
 
-        if let Some(mapped) = shell.element_for_surface(&window) {
+        if let Some(mapped) = shell
+            .element_for_surface(&window)
+            .filter(|mapped| !mapped.is_minimized())
+        {
             let current_geo = if let Some(workspace) = shell.space_for(mapped) {
-                workspace.is_floating(mapped).then_some(
-                    workspace
-                        .element_geometry(mapped)
-                        .unwrap()
-                        .to_global(workspace.output()),
-                )
+                workspace
+                    .element_geometry(mapped)
+                    .filter(|_| workspace.is_floating(mapped))
+                    .map(|geo| geo.to_global(workspace.output()))
             } else if let Some((output, set)) = shell
                 .workspaces
                 .sets