leyoda/cosmic-comp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

shell: Lift toggle_stacking(_focused) to handle sticky windows

Browse source
This commit is contained in:
Victoria Brekenfeld 2023-12-20 20:48:19 +00:00 • committed by Victoria Brekenfeld
parent 807f63bb72
commit a333753c96
4 changed files with 54 additions and 43 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/input/mod.rs
View file

@ -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));
}
}

17
src/shell/grabs/menu/default.rs
View file

@ -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)),
),

49
src/shell/mod.rs
View file

@ -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>>,

27
src/shell/workspace.rs
View file

@ -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()