diff --git a/src/input/mod.rs b/src/input/mod.rs
index 145c8270..ca0e6804 100644
--- a/src/input/mod.rs
+++ b/src/input/mod.rs
@@ -2069,9 +2069,7 @@ impl State {
                     .update_orientation(Some(orientation), &seat);
             }
             Action::ToggleStacking => {
-                let output = seat.active_output();
-                let workspace = self.common.shell.active_space_mut(&output);
-                if let Some(new_focus) = workspace.toggle_stacking_focused(seat) {
+                if let Some(new_focus) = self.common.shell.toggle_stacking_focused(seat) {
                     Common::set_focus(self, Some(&new_focus), seat, Some(serial));
                 }
             }
diff --git a/src/shell/grabs/menu/default.rs b/src/shell/grabs/menu/default.rs
index 03107515..d66ffa21 100644
--- a/src/shell/grabs/menu/default.rs
+++ b/src/shell/grabs/menu/default.rs
@@ -14,18 +14,9 @@ use crate::{
 
 use super::{Item, ResizeEdge};
 
-fn unstack(state: &mut State, mapped: &CosmicMapped) {
+fn toggle_stacking(state: &mut State, mapped: &CosmicMapped) {
     let seat = state.common.last_active_seat().clone();
-    let Some(ws) = state.common.shell.space_for_mut(mapped) else { return };
-    if let Some(new_focus) = ws.toggle_stacking(mapped) {
-        Common::set_focus(state, Some(&new_focus), &seat, None);
-    }
-}
-
-fn stack(state: &mut State, mapped: &CosmicMapped) {
-    let seat = state.common.last_active_seat().clone();
-    let Some(ws) = state.common.shell.space_for_mut(&mapped) else { return };
-    if let Some(new_focus) = ws.toggle_stacking(&mapped) {
+    if let Some(new_focus) = state.common.shell.toggle_stacking(mapped) {
         Common::set_focus(state, Some(&new_focus), &seat, None);
     }
 }
@@ -182,7 +173,7 @@ pub fn window_items(
             Item::new(fl!("window-menu-unstack-all"), move |handle| {
                 let mapped = unstack_clone.clone();
                 let _ = handle.insert_idle(move |state| {
-                    unstack(state, &mapped);
+                    toggle_stacking(state, &mapped);
                 });
             })
             .shortcut(config.get_shortcut_for_action(&Action::ToggleStacking)),
@@ -282,7 +273,7 @@ pub fn window_items(
         (!is_stacked).then_some(
             Item::new(fl!("window-menu-stack"), move |handle| {
                 let mapped = stack_clone.clone();
-                let _ = handle.insert_idle(move |state| stack(state, &mapped));
+                let _ = handle.insert_idle(move |state| toggle_stacking(state, &mapped));
             })
             .shortcut(config.get_shortcut_for_action(&Action::ToggleStacking)),
         ),
diff --git a/src/shell/mod.rs b/src/shell/mod.rs
index bf57b772..bdd99911 100644
--- a/src/shell/mod.rs
+++ b/src/shell/mod.rs
@@ -2539,6 +2539,55 @@ impl Shell {
         }
     }
 
+    pub fn toggle_stacking(&mut self, window: &CosmicMapped) -> Option<KeyboardFocusTarget> {
+        if let Some(set) = self
+            .workspaces
+            .sets
+            .values_mut()
+            .find(|set| set.sticky_layer.mapped().any(|m| m == window))
+        {
+            set.sticky_layer.toggle_stacking(window)
+        } else if let Some(workspace) = self.space_for_mut(window) {
+            if workspace.tiling_layer.mapped().any(|(_, m, _)| m == window) {
+                workspace.tiling_layer.toggle_stacking(window)
+            } else if workspace.floating_layer.mapped().any(|w| w == window) {
+                workspace.floating_layer.toggle_stacking(window)
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    }
+
+    pub fn toggle_stacking_focused(&mut self, seat: &Seat<State>) -> Option<KeyboardFocusTarget> {
+        let set = self.workspaces.sets.get_mut(&seat.active_output()).unwrap();
+        let workspace = &mut set.workspaces[set.active];
+        let maybe_window = workspace.focus_stack.get(seat).iter().next().cloned();
+        if let Some(window) = maybe_window {
+            if set.sticky_layer.mapped().any(|m| m == &window) {
+                set.sticky_layer
+                    .toggle_stacking_focused(seat, workspace.focus_stack.get_mut(seat))
+            } else if workspace
+                .tiling_layer
+                .mapped()
+                .any(|(_, m, _)| m == &window)
+            {
+                workspace
+                    .tiling_layer
+                    .toggle_stacking_focused(seat, workspace.focus_stack.get_mut(seat))
+            } else if workspace.floating_layer.mapped().any(|w| w == &window) {
+                workspace
+                    .floating_layer
+                    .toggle_stacking_focused(seat, workspace.focus_stack.get_mut(seat))
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    }
+
     pub fn toggle_sticky<'a>(
         &mut self,
         seats: impl Iterator<Item = &'a Seat<State>>,
diff --git a/src/shell/workspace.rs b/src/shell/workspace.rs
index d5cfb43e..77210ca2 100644
--- a/src/shell/workspace.rs
+++ b/src/shell/workspace.rs
@@ -699,33 +699,6 @@ impl Workspace {
         }
     }
 
-    pub fn toggle_stacking(&mut self, window: &CosmicMapped) -> Option<KeyboardFocusTarget> {
-        if self.tiling_layer.mapped().any(|(_, m, _)| m == window) {
-            self.tiling_layer.toggle_stacking(window)
-        } else if self.floating_layer.mapped().any(|w| w == window) {
-            self.floating_layer.toggle_stacking(window)
-        } else {
-            None
-        }
-    }
-
-    pub fn toggle_stacking_focused(&mut self, seat: &Seat<State>) -> Option<KeyboardFocusTarget> {
-        let maybe_window = self.focus_stack.get(seat).iter().next().cloned();
-        if let Some(window) = maybe_window {
-            if self.tiling_layer.mapped().any(|(_, m, _)| m == &window) {
-                self.tiling_layer
-                    .toggle_stacking_focused(seat, self.focus_stack.get_mut(seat))
-            } else if self.floating_layer.mapped().any(|w| w == &window) {
-                self.floating_layer
-                    .toggle_stacking_focused(seat, self.focus_stack.get_mut(seat))
-            } else {
-                None
-            }
-        } else {
-            None
-        }
-    }
-
     pub fn mapped(&self) -> impl Iterator<Item = &CosmicMapped> {
         self.floating_layer
             .mapped()