leyoda/cosmic-comp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
cosmic-comp/src/shell/mod.rs
Victoria Brekenfeld 835dbe45f3 shell: Unify mapping windows into stacks logic
2024-01-15 11:02:56 +01:00

2994 lines
107 KiB
Rust
Raw Blame History

use calloop::LoopHandle;
use indexmap::IndexMap;
use std::{
collections::HashMap,
sync::atomic::Ordering,
time::{Duration, Instant},
};
use wayland_backend::server::ClientId;
use cosmic_comp_config::workspace::{WorkspaceAmount, WorkspaceMode};
use cosmic_protocols::workspace::v1::server::zcosmic_workspace_handle_v1::State as WState;
use keyframe::{ease, functions::EaseInOutCubic};
use smithay::{
desktop::{
layer_map_for_output, space::SpaceElement, LayerSurface, PopupKind, PopupManager,
WindowSurfaceType,
},
input::{
pointer::{Focus, GrabStartData as PointerGrabStartData, MotionEvent},
Seat,
},
output::Output,
reexports::{
wayland_protocols::{
ext::session_lock::v1::server::ext_session_lock_v1::ExtSessionLockV1,
xdg::shell::server::xdg_toplevel::WmCapabilities,
},
wayland_server::{protocol::wl_surface::WlSurface, Client, DisplayHandle},
},
utils::{Logical, Point, Rectangle, Serial, Size, SERIAL_COUNTER},
wayland::{
compositor::with_states,
seat::WaylandFocus,
session_lock::LockSurface,
shell::{
wlr_layer::{
KeyboardInteractivity, Layer, LayerSurfaceCachedState, WlrLayerShellState,
},
xdg::XdgShellState,
},
xdg_activation::XdgActivationState,
},
xwayland::X11Surface,
};
use crate::{
config::{Config, KeyModifiers, KeyPattern},
state::client_should_see_privileged_protocols,
utils::prelude::*,
wayland::{
handlers::{xdg_activation::ActivationContext, xdg_shell::popup::get_popup_toplevel},
protocols::{
toplevel_info::ToplevelInfoState,
toplevel_management::{ManagementCapabilities, ToplevelManagementState},
workspace::{
WorkspaceCapabilities, WorkspaceGroupHandle, WorkspaceHandle, WorkspaceState,
WorkspaceUpdateGuard,
},
},
},
xwayland::XWaylandState,
};
pub mod element;
pub mod focus;
pub mod grabs;
pub mod layout;
mod workspace;
pub use self::element::{CosmicMapped, CosmicMappedRenderElement, CosmicSurface};
pub use self::workspace::*;
use self::{
element::{
resize_indicator::{resize_indicator, ResizeIndicator},
swap_indicator::{swap_indicator, SwapIndicator},
CosmicWindow, MaximizedState,
},
focus::{
target::{KeyboardFocusTarget, PointerFocusTarget},
FocusDirection,
},
grabs::{
tab_items, window_items, Item, MenuGrab, MoveGrab, ReleaseMode, ResizeEdge, ResizeGrab,
},
layout::{
floating::{FloatingLayout, ResizeState},
tiling::{NodeDesc, ResizeForkGrab, TilingLayout},
},
};
const ANIMATION_DURATION: Duration = Duration::from_millis(200);
#[derive(Debug, Clone)]
pub enum Trigger {
KeyboardSwap(KeyPattern, NodeDesc),
KeyboardMove(KeyModifiers),
Pointer(u32),
}
#[derive(Debug, Clone)]
pub enum OverviewMode {
None,
Started(Trigger, Instant),
Ended(Option<Trigger>, Instant),
}
impl OverviewMode {
pub fn alpha(&self) -> Option<f32> {
match self {
OverviewMode::Started(_, start) => {
let percentage = Instant::now().duration_since(*start).as_millis() as f32
/ ANIMATION_DURATION.as_millis() as f32;
Some(ease(EaseInOutCubic, 0.0, 1.0, percentage))
}
OverviewMode::Ended(_, end) => {
let percentage = Instant::now().duration_since(*end).as_millis() as f32
/ ANIMATION_DURATION.as_millis() as f32;
if percentage < 1.0 {
Some(ease(EaseInOutCubic, 1.0, 0.0, percentage))
} else {
None
}
}
OverviewMode::None => None,
}
}
}
#[derive(Debug, Clone, Copy, serde::Deserialize, PartialEq, Eq, Hash)]
pub enum ResizeDirection {
Inwards,
Outwards,
}
#[derive(Debug, Clone)]
pub enum ResizeMode {
None,
Started(KeyPattern, Instant, ResizeDirection),
Ended(Instant, ResizeDirection),
}
impl ResizeMode {
pub fn alpha(&self) -> Option<f32> {
match self {
ResizeMode::Started(_, start, _) => {
let percentage = Instant::now().duration_since(*start).as_millis() as f32
/ ANIMATION_DURATION.as_millis() as f32;
Some(ease(EaseInOutCubic, 0.0, 1.0, percentage))
}
ResizeMode::Ended(end, _) => {
let percentage = Instant::now().duration_since(*end).as_millis() as f32
/ ANIMATION_DURATION.as_millis() as f32;
if percentage < 1.0 {
Some(ease(EaseInOutCubic, 1.0, 0.0, percentage))
} else {
None
}
}
ResizeMode::None => None,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ActivationKey {
Wayland(WlSurface),
X11(u32),
}
impl From<&CosmicSurface> for ActivationKey {
fn from(value: &CosmicSurface) -> Self {
match value {
CosmicSurface::Wayland(w) => ActivationKey::Wayland(w.toplevel().wl_surface().clone()),
CosmicSurface::X11(s) => ActivationKey::X11(s.window_id()),
_ => unreachable!(),
}
}
}
#[derive(Debug)]
pub struct Shell {
pub workspaces: Workspaces,
pub popups: PopupManager,
pub pending_windows: Vec<(CosmicSurface, Seat<State>, Option<Output>)>,
pub pending_layers: Vec<(LayerSurface, Output, Seat<State>)>,
pub pending_activations: HashMap<ActivationKey, ActivationContext>,
pub override_redirect_windows: Vec<X11Surface>,
pub session_lock: Option<SessionLock>,
// wayland_state
pub layer_shell_state: WlrLayerShellState,
pub toplevel_info_state: ToplevelInfoState<State, CosmicSurface>,
pub toplevel_management_state: ToplevelManagementState,
pub xdg_shell_state: XdgShellState,
pub xdg_activation_state: XdgActivationState,
pub workspace_state: WorkspaceState<State>,
pub xwayland_state: Option<XWaylandState>,
theme: cosmic::Theme,
overview_mode: OverviewMode,
swap_indicator: Option<SwapIndicator>,
resize_mode: ResizeMode,
resize_state: Option<(
KeyboardFocusTarget,
ResizeDirection,
ResizeEdge,
i32,
usize,
Output,
)>,
resize_indicator: Option<ResizeIndicator>,
}
#[derive(Debug)]
pub struct SessionLock {
pub ext_session_lock: ExtSessionLockV1,
pub surfaces: HashMap<Output, LockSurface>,
}
#[derive(Debug)]
pub struct WorkspaceSet {
previously_active: Option<(usize, Instant)>,
active: usize,
group: WorkspaceGroupHandle,
idx: usize,
tiling_enabled: bool,
output: Output,
theme: cosmic::Theme,
pub sticky_layer: FloatingLayout,
pub workspaces: Vec<Workspace>,
}
fn create_workspace(
state: &mut WorkspaceUpdateGuard<'_, State>,
output: &Output,
group_handle: &WorkspaceGroupHandle,
active: bool,
tiling: bool,
theme: cosmic::Theme,
) -> Workspace {
let workspace_handle = state.create_workspace(&group_handle).unwrap();
if active {
state.add_workspace_state(&workspace_handle, WState::Active);
}
state.set_workspace_capabilities(
&workspace_handle,
[WorkspaceCapabilities::Activate].into_iter(),
);
Workspace::new(workspace_handle, output.clone(), tiling, theme.clone())
}
fn move_workspace_to_group(
workspace: &mut Workspace,
group: &WorkspaceGroupHandle,
workspace_state: &mut WorkspaceUpdateGuard<'_, State>,
toplevel_info_state: &mut ToplevelInfoState<State, CosmicSurface>,
) {
let old_workspace_handle = workspace.handle;
workspace.handle = workspace_state.create_workspace(group).unwrap();
workspace_state.set_workspace_capabilities(
&workspace.handle,
[WorkspaceCapabilities::Activate].into_iter(),
);
for window in workspace.mapped() {
for (surface, _) in window.windows() {
toplevel_info_state.toplevel_leave_workspace(&surface, &old_workspace_handle);
toplevel_info_state.toplevel_enter_workspace(&surface, &workspace.handle);
}
}
workspace_state.remove_workspace(old_workspace_handle);
}
fn merge_workspaces(
mut workspace: Workspace,
into: &mut Workspace,
workspace_state: &mut WorkspaceUpdateGuard<'_, State>,
toplevel_info_state: &mut ToplevelInfoState<State, CosmicSurface>,
) {
if into.fullscreen.is_some() {
// Don't handle the returned original workspace, for this nieche case.
let _ = workspace.remove_fullscreen();
}
for element in workspace.mapped() {
// fixup toplevel state
for (toplevel, _) in element.windows() {
toplevel_info_state.toplevel_leave_workspace(&toplevel, &workspace.handle);
toplevel_info_state.toplevel_enter_workspace(&toplevel, &into.handle);
}
}
into.tiling_layer.merge(workspace.tiling_layer);
into.floating_layer.merge(workspace.floating_layer);
workspace_state.remove_workspace(workspace.handle);
}
impl WorkspaceSet {
fn new(
state: &mut WorkspaceUpdateGuard<'_, State>,
output: &Output,
amount: WorkspaceAmount,
idx: usize,
tiling_enabled: bool,
theme: cosmic::Theme,
) -> WorkspaceSet {
let group_handle = state.create_workspace_group();
let workspaces = match amount {
WorkspaceAmount::Dynamic => {
let workspace = create_workspace(
state,
output,
&group_handle,
true,
tiling_enabled,
theme.clone(),
);
workspace_set_idx(state, 1, idx, &workspace.handle);
state.set_workspace_capabilities(
&workspace.handle,
[WorkspaceCapabilities::Activate].into_iter(),
);
vec![workspace]
}
WorkspaceAmount::Static(len) => (0..len)
.map(|i| {
let workspace = create_workspace(
state,
output,
&group_handle,
i == 0,
tiling_enabled,
theme.clone(),
);
workspace_set_idx(state, i + 1, idx, &workspace.handle);
state.set_workspace_capabilities(
&workspace.handle,
[WorkspaceCapabilities::Activate].into_iter(),
);
workspace
})
.collect(),
};
let sticky_layer = FloatingLayout::new(theme.clone(), output);
WorkspaceSet {
previously_active: None,
active: 0,
group: group_handle,
idx,
tiling_enabled,
theme,
sticky_layer,
workspaces,
output: output.clone(),
}
}
fn activate(
&mut self,
idx: usize,
state: &mut WorkspaceUpdateGuard<'_, State>,
) -> Result<bool, InvalidWorkspaceIndex> {
if idx >= self.workspaces.len() {
return Err(InvalidWorkspaceIndex);
}
if self.active != idx {
let old_active = self.active;
state.remove_workspace_state(&self.workspaces[old_active].handle, WState::Active);
state.remove_workspace_state(&self.workspaces[old_active].handle, WState::Urgent);
state.remove_workspace_state(&self.workspaces[idx].handle, WState::Urgent);
state.add_workspace_state(&self.workspaces[idx].handle, WState::Active);
self.previously_active = Some((old_active, Instant::now()));
self.active = idx;
Ok(true)
} else {
Ok(false)
}
}
fn set_output(
&mut self,
new_output: &Output,
toplevel_info: &mut ToplevelInfoState<State, CosmicSurface>,
) {
self.sticky_layer.set_output(new_output);
for window in self.sticky_layer.windows() {
toplevel_info.toplevel_leave_output(&window, &self.output);
toplevel_info.toplevel_enter_output(&window, &new_output);
}
for workspace in &mut self.workspaces {
workspace.set_output(new_output, toplevel_info);
}
self.output = new_output.clone();
}
fn refresh<'a>(&mut self, xdg_activation_state: &XdgActivationState) {
if let Some((_, start)) = self.previously_active {
if Instant::now().duration_since(start).as_millis() >= ANIMATION_DURATION.as_millis() {
self.previously_active = None;
}
} else {
self.workspaces[self.active].refresh(xdg_activation_state);
}
self.sticky_layer.refresh();
}
fn add_empty_workspace(&mut self, state: &mut WorkspaceUpdateGuard<State>) {
let workspace = create_workspace(
state,
&self.output,
&self.group,
false,
self.tiling_enabled,
self.theme.clone(),
);
workspace_set_idx(
state,
self.workspaces.len() as u8 + 1,
self.idx,
&workspace.handle,
);
self.workspaces.push(workspace);
}
fn ensure_last_empty<'a>(&mut self, state: &mut WorkspaceUpdateGuard<State>) {
// add empty at the end, if necessary
if self
.workspaces
.last()
.map(|last| !last.pending_tokens.is_empty() || last.windows().next().is_some())
.unwrap_or(true)
{
self.add_empty_workspace(state);
}
// remove empty workspaces in between, if they are not active
let len = self.workspaces.len();
let mut keep = vec![true; len];
for (i, workspace) in self.workspaces.iter().enumerate() {
let has_windows =
!workspace.pending_tokens.is_empty() || workspace.windows().next().is_some();
if !has_windows && i != self.active && i != len - 1 {
state.remove_workspace(workspace.handle);
keep[i] = false;
}
}
let mut iter = keep.iter();
self.workspaces.retain(|_| *iter.next().unwrap());
self.active -= keep
.iter()
.take(self.active + 1)
.filter(|keep| !**keep)
.count();
if keep.iter().any(|val| *val == false) {
for (i, workspace) in self.workspaces.iter().enumerate() {
workspace_set_idx(state, i as u8 + 1, self.idx, &workspace.handle);
}
}
}
fn ensure_static(
&mut self,
amount: usize,
state: &mut WorkspaceUpdateGuard<State>,
toplevel_info: &mut ToplevelInfoState<State, CosmicSurface>,
xdg_activation_state: &XdgActivationState,
) {
if amount < self.workspaces.len() {
// merge last ones
let overflow = self.workspaces.split_off(amount);
if self.active >= self.workspaces.len() {
self.active = self.workspaces.len() - 1;
state.add_workspace_state(&self.workspaces[self.active].handle, WState::Active);
}
let last_space = self.workspaces.last_mut().unwrap();
for workspace in overflow {
merge_workspaces(workspace, last_space, state, toplevel_info);
}
last_space.refresh(xdg_activation_state);
} else if amount > self.workspaces.len() {
// add empty ones
while amount > self.workspaces.len() {
let workspace = create_workspace(
state,
&self.output,
&self.group,
false,
self.tiling_enabled,
self.theme.clone(),
);
workspace_set_idx(
state,
self.workspaces.len() as u8 + 1,
self.idx,
&workspace.handle,
);
state.set_workspace_capabilities(
&workspace.handle,
[WorkspaceCapabilities::Activate].into_iter(),
);
self.workspaces.push(workspace);
}
}
}
fn update_idx(&mut self, state: &mut WorkspaceUpdateGuard<'_, State>, idx: usize) {
self.idx = idx;
for (i, workspace) in self.workspaces.iter().enumerate() {
workspace_set_idx(state, i as u8 + 1, idx, &workspace.handle);
}
}
fn update_tiling_status(&mut self, seat: &Seat<State>, tiling_enabled: bool) {
self.tiling_enabled = tiling_enabled;
for workspace in &mut self.workspaces {
if workspace.tiling_enabled != tiling_enabled {
workspace.toggle_tiling(seat);
}
}
}
}
#[derive(Debug)]
pub struct Workspaces {
pub sets: IndexMap<Output, WorkspaceSet>,
backup_set: Option<WorkspaceSet>,
amount: WorkspaceAmount,
mode: WorkspaceMode,
tiling_enabled: bool,
theme: cosmic::Theme,
}
impl Workspaces {
pub fn new(config: &Config, theme: cosmic::Theme) -> Workspaces {
Workspaces {
sets: IndexMap::new(),
backup_set: None,
amount: config.workspace.workspace_amount,
mode: config.workspace.workspace_mode,
tiling_enabled: config.static_conf.tiling_enabled,
theme,
}
}
pub fn add_output(
&mut self,
output: &Output,
workspace_state: &mut WorkspaceUpdateGuard<'_, State>,
toplevel_info_state: &mut ToplevelInfoState<State, CosmicSurface>,
xdg_activation_state: &XdgActivationState,
) {
if self.sets.contains_key(output) {
return;
}
let set = self
.backup_set
.take()
.map(|mut set| {
set.set_output(output, toplevel_info_state);
set
})
.unwrap_or_else(|| {
WorkspaceSet::new(
workspace_state,
&output,
self.amount,
self.sets.len(),
self.tiling_enabled,
self.theme.clone(),
)
});
workspace_state.add_group_output(&set.group, &output);
self.sets.insert(output.clone(), set);
let mut moved_workspaces = Vec::new();
for set in self.sets.values_mut() {
let (preferrs, doesnt) = set
.workspaces
.drain(..)
.partition(|w| w.preferrs_output(output));
moved_workspaces.extend(preferrs);
set.workspaces = doesnt;
}
{
let set = self.sets.get_mut(output).unwrap();
for workspace in &mut moved_workspaces {
move_workspace_to_group(
workspace,
&set.group,
workspace_state,
toplevel_info_state,
);
}
set.workspaces.extend(moved_workspaces);
for (i, workspace) in set.workspaces.iter_mut().enumerate() {
workspace.set_output(output, toplevel_info_state);
workspace.refresh(xdg_activation_state);
workspace_set_idx(workspace_state, i as u8 + 1, set.idx, &workspace.handle);
if i == set.active {
workspace_state.add_workspace_state(&workspace.handle, WState::Active);
}
}
}
}
pub fn remove_output(
&mut self,
output: &Output,
seats: impl Iterator<Item = Seat<State>>,
workspace_state: &mut WorkspaceUpdateGuard<'_, State>,
toplevel_info_state: &mut ToplevelInfoState<State, CosmicSurface>,
xdg_activation_state: &XdgActivationState,
) {
if !self.sets.contains_key(output) {
return;
}
if let Some(set) = self.sets.remove(output) {
{
let map = layer_map_for_output(output);
for surface in map.layers() {
surface.layer_surface().send_close();
}
}
// TODO: Heuristic which output to move to.
// It is supposed to be the *most* internal, we just pick the first one for now
// and hope enumeration order works in our favor.
let new_output = self.sets.get_index(0).map(|(o, _)| o.clone());
if let Some(new_output) = new_output {
for seat in seats {
if &seat.active_output() == output {
seat.set_active_output(&new_output);
}
}
let new_set = self.sets.get_mut(&new_output).unwrap();
let workspace_group = new_set.group;
for (i, mut workspace) in set.workspaces.into_iter().enumerate() {
if matches!(self.amount, WorkspaceAmount::Static(_))
&& i < new_set.workspaces.len()
{
merge_workspaces(
workspace,
&mut new_set.workspaces[i],
workspace_state,
toplevel_info_state,
);
} else {
// update workspace protocol state
move_workspace_to_group(
&mut workspace,
&workspace_group,
workspace_state,
toplevel_info_state,
);
// update mapping
workspace.set_output(&new_output, toplevel_info_state);
workspace.refresh(xdg_activation_state);
new_set.workspaces.push(workspace);
}
}
if self.mode == WorkspaceMode::OutputBound {
workspace_state.remove_workspace_group(set.group);
} else {
workspace_state.remove_group_output(&workspace_group, output);
}
for (i, set) in self.sets.values_mut().enumerate() {
set.update_idx(workspace_state, i);
}
} else {
workspace_state.remove_group_output(&set.group, output);
self.backup_set = Some(set);
}
self.refresh(workspace_state, toplevel_info_state, xdg_activation_state)
}
}
fn migrate_workspace(
&mut self,
from: &Output,
to: &Output,
handle: &WorkspaceHandle,
workspace_state: &mut WorkspaceUpdateGuard<'_, State>,
toplevel_info_state: &mut ToplevelInfoState<State, CosmicSurface>,
xdg_activation_state: &XdgActivationState,
) {
if !self.sets.contains_key(to) {
return;
}
if let Some(mut workspace) = self.sets.get_mut(from).and_then(|set| {
let pos = set.workspaces.iter().position(|w| &w.handle == handle)?;
Some(set.workspaces.remove(pos))
}) {
let new_set = self.sets.get_mut(to).unwrap();
match self.amount {
WorkspaceAmount::Dynamic => {
move_workspace_to_group(
&mut workspace,
&new_set.group,
workspace_state,
toplevel_info_state,
);
workspace.set_output(to, toplevel_info_state);
workspace.refresh(xdg_activation_state);
new_set.workspaces.insert(new_set.active + 1, workspace)
}
WorkspaceAmount::Static(_) => merge_workspaces(
workspace,
&mut new_set.workspaces[new_set.active],
workspace_state,
toplevel_info_state,
),
};
}
}
pub fn update_config(
&mut self,
config: &Config,
workspace_state: &mut WorkspaceUpdateGuard<'_, State>,
toplevel_info_state: &mut ToplevelInfoState<State, CosmicSurface>,
xdg_activation_state: &XdgActivationState,
) {
let old_mode = self.mode;
self.mode = config.workspace.workspace_mode;
self.amount = config.workspace.workspace_amount;
if self.sets.len() <= 1 {
return;
}
match (old_mode, self.mode) {
(WorkspaceMode::Global, WorkspaceMode::OutputBound) => {
// We basically just unlink the existing spaces, so nothing needs to be updated
}
(WorkspaceMode::OutputBound, WorkspaceMode::Global) => {
// lets construct an iterator of all the pairs of workspaces we have to "merge"
let mut pairs = Vec::new();
if let Some(max) = self.sets.values().map(|set| set.workspaces.len()).max() {
let offset = self.sets.values().map(|set| set.active).max().unwrap();
for i in 0..max {
pairs.push(
self.sets
.values()
.map(|set| {
let idx = set.active as isize + i as isize - offset as isize;
if idx < 0 || idx >= set.workspaces.len() as isize {
None
} else {
Some(idx)
}
})
.collect::<Vec<_>>(),
);
}
}
for (j, pair) in pairs.iter().enumerate() {
for (i, x) in pair.iter().enumerate() {
// Fill up sets, where necessary
if x.is_none() {
// create missing workspace
let (output, set) = self.sets.get_index_mut(i).unwrap();
set.workspaces.insert(
j,
create_workspace(
workspace_state,
output,
&set.group,
false,
config.static_conf.tiling_enabled,
self.theme.clone(),
),
);
}
// Otherwise we are fine
}
}
// fixup indices
for (i, set) in self.sets.values_mut().enumerate() {
set.update_idx(workspace_state, i);
}
}
_ => {}
};
self.refresh(workspace_state, toplevel_info_state, xdg_activation_state)
}
pub fn recalculate(&mut self) {
for set in self.sets.values_mut() {
set.sticky_layer.refresh();
set.workspaces.iter_mut().for_each(|w| w.recalculate());
}
}
pub fn refresh(
&mut self,
workspace_state: &mut WorkspaceUpdateGuard<'_, State>,
toplevel_info_state: &mut ToplevelInfoState<State, CosmicSurface>,
xdg_activation_state: &XdgActivationState,
) {
match self.mode {
WorkspaceMode::Global => {
match self.amount {
WorkspaceAmount::Dynamic => {
// this should never happen
let max = self
.sets
.values()
.map(|set| set.workspaces.len())
.max()
.unwrap_or_default();
for set in self
.sets
.values_mut()
.filter(|set| set.workspaces.len() < max)
{
while set.workspaces.len() < max {
set.add_empty_workspace(workspace_state)
}
}
// add empty at the end, if necessary
if self
.sets
.values()
.flat_map(|set| set.workspaces.last())
.any(|w| w.mapped().next().is_some())
{
for set in self.sets.values_mut() {
set.add_empty_workspace(workspace_state);
}
}
// remove empty workspaces in between, if they are not active
let len = self.sets[0].workspaces.len();
let mut active = self.sets[0].active;
let mut keep = vec![true; len];
for i in 0..len {
let has_windows = self.sets.values().any(|s| {
!s.workspaces[i].pending_tokens.is_empty()
|| s.workspaces[i].windows().next().is_some()
});
if !has_windows && i != active && i != len - 1 {
for workspace in self.sets.values().map(|s| &s.workspaces[i]) {
workspace_state.remove_workspace(workspace.handle);
}
keep[i] = false;
}
}
self.sets.values_mut().for_each(|s| {
let mut iter = keep.iter();
s.workspaces.retain(|_| *iter.next().unwrap());
});
active -= keep.iter().take(active + 1).filter(|keep| !**keep).count();
self.sets.values_mut().for_each(|s| {
s.active = active;
});
if keep.iter().any(|val| *val == false) {
for set in self.sets.values_mut() {
for (i, workspace) in set.workspaces.iter().enumerate() {
workspace_set_idx(
workspace_state,
i as u8 + 1,
set.idx,
&workspace.handle,
);
}
}
}
}
WorkspaceAmount::Static(amount) => {
for set in self.sets.values_mut() {
set.ensure_static(
amount as usize,
workspace_state,
toplevel_info_state,
xdg_activation_state,
)
}
}
}
}
WorkspaceMode::OutputBound => match self.amount {
WorkspaceAmount::Dynamic => {
for set in self.sets.values_mut() {
set.ensure_last_empty(workspace_state);
}
}
WorkspaceAmount::Static(amount) => {
for set in self.sets.values_mut() {
set.ensure_static(
amount as usize,
workspace_state,
toplevel_info_state,
xdg_activation_state,
)
}
}
},
}
for set in self.sets.values_mut() {
set.refresh(xdg_activation_state)
}
}
pub fn get(&self, num: usize, output: &Output) -> Option<&Workspace> {
self.sets
.get(output)
.and_then(|set| set.workspaces.get(num))
}
pub fn get_mut(&mut self, num: usize, output: &Output) -> Option<&mut Workspace> {
self.sets
.get_mut(output)
.and_then(|set| set.workspaces.get_mut(num))
}
pub fn active(&self, output: &Output) -> (Option<(&Workspace, Instant)>, &Workspace) {
let set = self.sets.get(output).or(self.backup_set.as_ref()).unwrap();
(
set.previously_active
.map(|(idx, start)| (&set.workspaces[idx], start)),
&set.workspaces[set.active],
)
}
pub fn active_mut(&mut self, output: &Output) -> &mut Workspace {
let set = self
.sets
.get_mut(output)
.or(self.backup_set.as_mut())
.unwrap();
&mut set.workspaces[set.active]
}
pub fn active_num(&self, output: &Output) -> (Option<usize>, usize) {
let set = self.sets.get(output).or(self.backup_set.as_ref()).unwrap();
(set.previously_active.map(|(idx, _)| idx), set.active)
}
pub fn idx_for_handle(&self, output: &Output, handle: &WorkspaceHandle) -> Option<usize> {
let set = self.sets.get(output).unwrap();
set.workspaces
.iter()
.enumerate()
.find_map(|(i, w)| (&w.handle == handle).then_some(i))
}
pub fn len(&self, output: &Output) -> usize {
let set = self.sets.get(output).unwrap();
set.workspaces.len()
}
pub fn iter(&self) -> impl Iterator<Item = (&Output, &WorkspaceSet)> {
self.sets.iter()
}
pub fn spaces(&self) -> impl Iterator<Item = &Workspace> {
self.sets.values().flat_map(|set| set.workspaces.iter())
}
pub fn space_for_handle(&self, handle: &WorkspaceHandle) -> Option<&Workspace> {
self.spaces().find(|w| &w.handle == handle)
}
pub fn space_for_handle_mut(&mut self, handle: &WorkspaceHandle) -> Option<&mut Workspace> {
self.spaces_mut().find(|w| &w.handle == handle)
}
pub fn spaces_for_output(&self, output: &Output) -> impl Iterator<Item = &Workspace> {
self.sets
.get(output)
.into_iter()
.flat_map(|set| set.workspaces.iter())
}
pub fn spaces_mut(&mut self) -> impl Iterator<Item = &mut Workspace> {
Box::new(
self.sets
.values_mut()
.flat_map(|set| set.workspaces.iter_mut()),
)
}
pub fn update_tiling_status(&mut self, seat: &Seat<State>, tiling: bool) {
for set in self.sets.values_mut() {
set.update_tiling_status(seat, tiling)
}
}
pub fn set_theme(&mut self, theme: cosmic::Theme, xdg_activation_state: &XdgActivationState) {
for (_, s) in &mut self.sets {
s.theme = theme.clone();
s.sticky_layer.theme = theme.clone();
s.sticky_layer.refresh();
for mut w in &mut s.workspaces {
w.tiling_layer.theme = theme.clone();
w.floating_layer.theme = theme.clone();
w.mapped().for_each(|m| {
m.update_theme(theme.clone());
m.force_redraw();
});
w.refresh(xdg_activation_state);
w.dirty.store(true, Ordering::Relaxed);
w.recalculate();
}
}
}
}
#[derive(Debug)]
pub struct InvalidWorkspaceIndex;
impl Shell {
pub fn new(config: &Config, dh: &DisplayHandle) -> Self {
let layer_shell_state = WlrLayerShellState::new_with_filter::<State, _>(
dh,
client_should_see_privileged_protocols,
);
let xdg_shell_state = XdgShellState::new_with_capabilities::<State>(
dh,
[
WmCapabilities::Fullscreen,
WmCapabilities::Maximize,
WmCapabilities::WindowMenu,
],
);
let xdg_activation_state = XdgActivationState::new::<State>(dh);
let toplevel_info_state =
ToplevelInfoState::new(dh, client_should_see_privileged_protocols);
let toplevel_management_state = ToplevelManagementState::new::<State, _>(
dh,
vec![
ManagementCapabilities::Close,
ManagementCapabilities::Activate,
],
client_should_see_privileged_protocols,
);
let workspace_state = WorkspaceState::new(dh, client_should_see_privileged_protocols);
let theme = cosmic::theme::system_preference();
Shell {
popups: PopupManager::default(),
workspaces: Workspaces::new(config, theme.clone()),
pending_windows: Vec::new(),
pending_layers: Vec::new(),
pending_activations: HashMap::new(),
override_redirect_windows: Vec::new(),
session_lock: None,
layer_shell_state,
toplevel_info_state,
toplevel_management_state,
xdg_shell_state,
xdg_activation_state,
workspace_state,
xwayland_state: None,
theme,
overview_mode: OverviewMode::None,
swap_indicator: None,
resize_mode: ResizeMode::None,
resize_state: None,
resize_indicator: None,
}
}
pub fn add_output(&mut self, output: &Output) {
self.workspaces.add_output(
output,
&mut self.workspace_state.update(),
&mut self.toplevel_info_state,
&self.xdg_activation_state,
);
self.refresh(); // fixes indicies of any moved workspaces
}
pub fn remove_output(&mut self, output: &Output, seats: impl Iterator<Item = Seat<State>>) {
self.workspaces.remove_output(
output,
seats,
&mut self.workspace_state.update(),
&mut self.toplevel_info_state,
&self.xdg_activation_state,
);
self.refresh(); // cleans up excess of workspaces and empty workspaces
}
pub fn migrate_workspace(&mut self, from: &Output, to: &Output, handle: &WorkspaceHandle) {
if from == to {
return;
}
self.workspaces.migrate_workspace(
from,
to,
handle,
&mut self.workspace_state.update(),
&mut self.toplevel_info_state,
&self.xdg_activation_state,
);
self.refresh(); // fixes index of moved workspace
}
pub fn update_config(&mut self, config: &Config) {
let mut workspace_state = self.workspace_state.update();
let toplevel_info_state = &mut self.toplevel_info_state;
self.workspaces.update_config(
config,
&mut workspace_state,
toplevel_info_state,
&self.xdg_activation_state,
);
}
pub fn activate(
&mut self,
output: &Output,
idx: usize,
) -> Result<Option<Point<i32, Global>>, InvalidWorkspaceIndex> {
match &mut self.workspaces.mode {
WorkspaceMode::OutputBound => {
if let Some(set) = self.workspaces.sets.get_mut(output) {
if matches!(
self.overview_mode,
OverviewMode::Started(Trigger::Pointer(_), _)
) {
set.workspaces[set.active].tiling_layer.cleanup_drag();
}
set.activate(idx, &mut self.workspace_state.update())?;
if let Some(xwm) = self
.xwayland_state
.as_mut()
.and_then(|state| state.xwm.as_mut())
{
{
for window in set.workspaces[set.active]
.tiling_layer
.mapped()
.map(|(_, w, _)| w)
.chain(set.workspaces[set.active].floating_layer.space.elements())
{
if let CosmicSurface::X11(surf) = window.active_window() {
let _ = xwm.raise_window(&surf);
}
}
for window in set.sticky_layer.space.elements() {
if let CosmicSurface::X11(surf) = window.active_window() {
let _ = xwm.raise_window(&surf);
}
}
if let Some(CosmicSurface::X11(ref surf)) = set.workspaces[set.active]
.fullscreen
.as_ref()
.map(|f| &f.surface)
{
let _ = xwm.raise_window(surf);
}
}
for surface in &self.override_redirect_windows {
let _ = xwm.raise_window(surface);
}
}
let output_geo = output.geometry();
Ok(Some(
output_geo.loc
+ Point::from((output_geo.size.w / 2, output_geo.size.h / 2)),
))
} else {
Ok(None)
}
}
WorkspaceMode::Global => {
for set in self.workspaces.sets.values_mut() {
set.activate(idx, &mut self.workspace_state.update())?;
}
Ok(None)
}
}
}
pub fn active_space(&self, output: &Output) -> &Workspace {
self.workspaces.active(output).1
}
pub fn active_space_mut(&mut self, output: &Output) -> &mut Workspace {
self.workspaces.active_mut(output)
}
pub fn refresh_active_space(&mut self, output: &Output) {
self.workspaces
.active_mut(output)
.refresh(&self.xdg_activation_state)
}
pub fn visible_output_for_surface(&self, surface: &WlSurface) -> Option<&Output> {
if let Some(session_lock) = &self.session_lock {
return session_lock
.surfaces
.iter()
.find(|(_, v)| v.wl_surface() == surface)
.map(|(k, _)| k);
}
self.outputs()
// layer map surface?
.find(|o| {
let map = layer_map_for_output(o);
map.layer_for_surface(surface, WindowSurfaceType::ALL)
.is_some()
})
// pending layer map surface?
.or_else(|| {
self.pending_layers.iter().find_map(|(l, output, _)| {
let mut found = false;
l.with_surfaces(|s, _| {
if s == surface {
found = true;
}
});
found.then_some(output)
})
})
// override redirect window?
.or_else(|| {
self.outputs().find(|o| {
self.override_redirect_windows.iter().any(|or| {
if or.wl_surface().as_ref() == Some(surface) {
or.geometry()
.as_global()
.intersection(o.geometry())
.is_some()
} else {
false
}
})
})
})
// sticky window ?
.or_else(|| {
self.outputs().find(|o| {
self.workspaces.sets[*o]
.sticky_layer
.mapped()
.any(|e| e.has_surface(surface, WindowSurfaceType::ALL))
})
})
// normal window?
.or_else(|| {
self.outputs().find(|o| {
self.active_space(o)
.mapped()
.any(|e| e.has_surface(surface, WindowSurfaceType::ALL))
})
})
}
pub fn workspace_for_surface(&self, surface: &WlSurface) -> Option<(WorkspaceHandle, Output)> {
match self.outputs().find(|o| {
let map = layer_map_for_output(o);
map.layer_for_surface(surface, WindowSurfaceType::ALL)
.is_some()
}) {
Some(output) => self
.workspaces
.spaces()
.find(move |workspace| workspace.output() == output)
.map(|w| (w.handle.clone(), output.clone())),
None => self
.workspaces
.spaces()
.find(|w| {
w.mapped()
.any(|e| e.has_surface(surface, WindowSurfaceType::ALL))
})
.map(|w| (w.handle.clone(), w.output().clone())),
}
}
pub fn element_for_surface(&self, surface: &CosmicSurface) -> Option<&CosmicMapped> {
self.workspaces.sets.values().find_map(|set| {
set.sticky_layer
.mapped()
.find(|w| w.windows().any(|(s, _)| &s == surface))
.or_else(|| {
set.workspaces
.iter()
.find_map(|w| w.element_for_surface(surface))
})
})
}
pub fn element_for_wl_surface(&self, surface: &WlSurface) -> Option<&CosmicMapped> {
self.workspaces.sets.values().find_map(|set| {
set.sticky_layer
.mapped()
.find(|w| {
w.windows()
.any(|(s, _)| s.wl_surface().as_ref() == Some(surface))
})
.or_else(|| {
set.workspaces
.iter()
.find_map(|w| w.element_for_wl_surface(surface))
})
})
}
pub fn space_for(&self, mapped: &CosmicMapped) -> Option<&Workspace> {
self.workspaces
.spaces()
.find(|workspace| workspace.mapped().any(|m| m == mapped))
}
pub fn space_for_mut(&mut self, mapped: &CosmicMapped) -> Option<&mut Workspace> {
self.workspaces
.spaces_mut()
.find(|workspace| workspace.mapped().any(|m| m == mapped))
}
pub fn outputs(&self) -> impl DoubleEndedIterator<Item = &Output> {
self.workspaces.sets.keys().chain(
self.workspaces
.backup_set
.as_ref()
.into_iter()
.map(|set| &set.output),
)
}
pub fn next_output(&self, current_output: &Output, direction: Direction) -> Option<&Output> {
let current_output_geo = current_output.geometry();
self.outputs()
.filter(|o| *o != current_output)
.filter(|o| {
let geo = o.geometry();
match direction {
Direction::Left | Direction::Right => {
!(geo.loc.y + geo.size.h < current_output_geo.loc.y
|| geo.loc.y > current_output_geo.loc.y + current_output_geo.size.h)
}
Direction::Up | Direction::Down => {
!(geo.loc.x + geo.size.w < current_output_geo.loc.x
|| geo.loc.x > current_output_geo.loc.x + current_output_geo.size.w)
}
}
})
.filter_map(|o| {
let origin = o.geometry().loc;
let res = match direction {
Direction::Up => current_output_geo.loc.y - origin.y,
Direction::Down => origin.y - current_output_geo.loc.y,
Direction::Left => current_output_geo.loc.x - origin.x,
Direction::Right => origin.x - current_output_geo.loc.x,
};
if res > 0 {
Some((o, res))
} else {
None
}
})
.min_by_key(|(_, res)| *res)
.map(|(o, _)| o)
}
pub fn builtin_output(&self) -> Option<&Output> {
self.outputs().find(|output| {
let name = output.name();
name.starts_with("eDP-") || name.starts_with("LVDS-") || name.starts_with("DSI-")
})
}
pub fn global_space(&self) -> Rectangle<i32, Global> {
self.outputs()
.fold(
Option::<Rectangle<i32, Global>>::None,
|maybe_geo, output| match maybe_geo {
Some(rect) => Some(rect.merge(output.geometry())),
None => Some(output.geometry()),
},
)
.unwrap_or_else(Rectangle::default)
}
pub fn animations_going(&self) -> bool {
self.workspaces
.sets
.values()
.any(|set| set.previously_active.is_some() || set.sticky_layer.animations_going())
|| !matches!(self.overview_mode, OverviewMode::None)
|| !matches!(self.resize_mode, ResizeMode::None)
|| self
.workspaces
.spaces()
.any(|workspace| workspace.animations_going())
}
pub fn update_animations(&mut self) -> HashMap<ClientId, Client> {
let mut clients = HashMap::new();
for set in self.workspaces.sets.values_mut() {
set.sticky_layer.update_animation_state();
}
for workspace in self.workspaces.spaces_mut() {
clients.extend(workspace.update_animations());
}
clients
}
pub fn set_overview_mode(
&mut self,
enabled: Option<Trigger>,
evlh: LoopHandle<'static, crate::state::State>,
) {
if let Some(trigger) = enabled {
if !matches!(self.overview_mode, OverviewMode::Started(_, _)) {
if matches!(trigger, Trigger::KeyboardSwap(_, _)) {
self.swap_indicator = Some(swap_indicator(evlh, self.theme.clone()));
}
self.overview_mode = OverviewMode::Started(trigger, Instant::now());
}
} else {
if matches!(self.overview_mode, OverviewMode::Started(_, _)) {
let (reverse_duration, trigger) =
if let OverviewMode::Started(trigger, start) = self.overview_mode.clone() {
(
ANIMATION_DURATION
- Instant::now().duration_since(start).min(ANIMATION_DURATION),
Some(trigger),
)
} else {
(Duration::ZERO, None)
};
self.overview_mode =
OverviewMode::Ended(trigger, Instant::now() - reverse_duration);
}
}
}
pub fn overview_mode(&mut self) -> (OverviewMode, Option<SwapIndicator>) {
if let OverviewMode::Ended(_, timestamp) = self.overview_mode {
if Instant::now().duration_since(timestamp) > ANIMATION_DURATION {
self.overview_mode = OverviewMode::None;
self.swap_indicator = None;
}
}
(self.overview_mode.clone(), self.swap_indicator.clone())
}
pub fn set_resize_mode(
&mut self,
enabled: Option<(KeyPattern, ResizeDirection)>,
config: &Config,
evlh: LoopHandle<'static, crate::state::State>,
) {
if let Some((pattern, direction)) = enabled {
if let ResizeMode::Started(old_pattern, _, old_direction) = &mut self.resize_mode {
*old_pattern = pattern;
*old_direction = direction;
} else {
self.resize_mode = ResizeMode::Started(pattern, Instant::now(), direction);
}
self.resize_indicator = Some(resize_indicator(
direction,
config,
evlh,
self.theme.clone(),
));
} else {
if let ResizeMode::Started(_, _, direction) = &self.resize_mode {
self.resize_mode = ResizeMode::Ended(Instant::now(), *direction);
if let Some((_, direction, edge, _, _, _)) = self.resize_state.as_ref() {
self.finish_resize(*direction, *edge);
}
}
}
}
pub fn resize_mode(&mut self) -> (ResizeMode, Option<ResizeIndicator>) {
if let ResizeMode::Ended(timestamp, _) = self.resize_mode {
if Instant::now().duration_since(timestamp) > ANIMATION_DURATION {
self.resize_mode = ResizeMode::None;
self.resize_indicator = None;
}
}
(self.resize_mode.clone(), self.resize_indicator.clone())
}
pub fn refresh(&mut self) {
#[cfg(feature = "debug")]
puffin::profile_function!();
self.popups.cleanup();
self.xdg_activation_state.retain_tokens(|_, data| {
Instant::now().duration_since(data.timestamp) < Duration::from_secs(5)
});
self.workspaces.refresh(
&mut self.workspace_state.update(),
&mut self.toplevel_info_state,
&self.xdg_activation_state,
);
for output in self.outputs() {
let mut map = layer_map_for_output(output);
map.cleanup();
}
self.override_redirect_windows.retain(|or| or.alive());
self.override_redirect_windows
.iter()
.for_each(|or| or.refresh());
self.toplevel_info_state
.refresh(Some(&self.workspace_state));
}
pub fn remap_unfullscreened_window(
&mut self,
mapped: CosmicMapped,
current_workspace: &WorkspaceHandle,
previous_workspace: &WorkspaceHandle,
target_layer: ManagedLayer,
) {
if self
.workspaces
.space_for_handle(previous_workspace)
.is_none()
{
return;
}
{
let Some(workspace) = self.workspaces.space_for_handle_mut(&current_workspace) else { return };
let _ = workspace.unmap(&mapped);
}
let new_workspace_output = self
.workspaces
.space_for_handle(&previous_workspace)
.unwrap()
.output()
.clone();
for (window, _) in mapped.windows() {
self.toplevel_info_state
.toplevel_enter_output(&window, &new_workspace_output);
self.toplevel_info_state
.toplevel_enter_workspace(&window, &previous_workspace);
}
let new_workspace = self
.workspaces
.space_for_handle_mut(&previous_workspace)
.unwrap();
match target_layer {
ManagedLayer::Sticky => {
let output = new_workspace.output().clone();
self.workspaces
.sets
.get_mut(&output)
.unwrap()
.sticky_layer
.map(mapped, None)
}
ManagedLayer::Floating => new_workspace.floating_layer.map(mapped, None),
ManagedLayer::Tiling => {
new_workspace
.tiling_layer
.map(mapped, Option::<std::iter::Empty<_>>::None, None)
}
};
}
pub fn map_window(state: &mut State, window: &CosmicSurface) {
let pos = state
.common
.shell
.pending_windows
.iter()
.position(|(w, _, _)| w == window)
.unwrap();
let (window, seat, output) = state.common.shell.pending_windows.remove(pos);
let parent_is_sticky = match window.clone() {
CosmicSurface::Wayland(toplevel) => {
if let Some(parent) = toplevel.toplevel().parent() {
if let Some(elem) = state.common.shell.element_for_wl_surface(&parent) {
state
.common
.shell
.workspaces
.sets
.values()
.any(|set| set.sticky_layer.mapped().any(|m| m == elem))
} else {
false
}
} else {
false
}
}
_ => false,
};
let pending_activation = state
.common
.shell
.pending_activations
.remove(&(&window).into());
let workspace_handle = match pending_activation {
Some(ActivationContext::Workspace(handle)) => Some(handle),
_ => None,
};
let should_be_fullscreen = output.is_some();
let mut output = output.unwrap_or_else(|| seat.active_output());
// this is beyond stupid, just to make the borrow checker happy
let workspace = if let Some(handle) = workspace_handle.filter(|handle| {
state
.common
.shell
.workspaces
.spaces()
.any(|space| &space.handle == handle)
}) {
state
.common
.shell
.workspaces
.spaces_mut()
.find(|space| space.handle == handle)
.unwrap()
} else {
state.common.shell.workspaces.active_mut(&output)
};
if output != workspace.output {
output = workspace.output.clone();
}
if let Some((mapped, layer, previous_workspace)) = workspace.remove_fullscreen() {
let old_handle = workspace.handle.clone();
let new_workspace_handle = state
.common
.shell
.workspaces
.space_for_handle(&previous_workspace)
.is_some()
.then_some(previous_workspace)
.unwrap_or(old_handle);
state.common.shell.remap_unfullscreened_window(
mapped,
&old_handle,
&new_workspace_handle,
layer,
);
};
let active_handle = state.common.shell.workspaces.active(&output).1.handle;
let workspace = if let Some(handle) = workspace_handle.filter(|handle| {
state
.common
.shell
.workspaces
.spaces()
.any(|space| &space.handle == handle)
}) {
state
.common
.shell
.workspaces
.spaces_mut()
.find(|space| space.handle == handle)
.unwrap()
} else {
state.common.shell.workspaces.active_mut(&output)
};
state.common.shell.toplevel_info_state.new_toplevel(&window);
state
.common
.shell
.toplevel_info_state
.toplevel_enter_output(&window, &output);
state
.common
.shell
.toplevel_info_state
.toplevel_enter_workspace(&window, &workspace.handle);
let workspace_output = workspace.output.clone();
let was_activated = workspace_handle.is_some()
&& (workspace_output != seat.active_output() || active_handle != workspace.handle);
let workspace_handle = workspace.handle;
let is_dialog = layout::is_dialog(&window);
let floating_exception = layout::has_floating_exception(&window);
let maybe_focused = workspace.focus_stack.get(&seat).iter().next().cloned();
if let Some(focused) = maybe_focused {
if (focused.is_stack() && !is_dialog && !should_be_fullscreen)
&& !(workspace.is_tiled(&focused) && floating_exception)
{
focused.stack_ref().unwrap().add_window(window, None);
if was_activated {
state.common.shell.set_urgent(&workspace_handle);
}
return;
}
}
let mapped = CosmicMapped::from(CosmicWindow::new(
window.clone(),
state.common.event_loop_handle.clone(),
state.common.theme.clone(),
));
#[cfg(feature = "debug")]
{
mapped.set_debug(state.common.egui.active);
}
let workspace_empty = workspace.mapped().next().is_none();
if is_dialog || floating_exception || !workspace.tiling_enabled {
workspace.floating_layer.map(mapped.clone(), None);
} else {
for mapped in workspace
.mapped()
.filter(|m| m.maximized_state.lock().unwrap().is_some())
.cloned()
.collect::<Vec<_>>()
.into_iter()
{
workspace.unmaximize_request(&mapped);
}
let focus_stack = workspace.focus_stack.get(&seat);
workspace
.tiling_layer
.map(mapped.clone(), Some(focus_stack.iter()), None);
}
if !parent_is_sticky && should_be_fullscreen {
workspace.fullscreen_request(&mapped.active_window(), None);
}
if parent_is_sticky {
let seats = state.common.seats().cloned().collect::<Vec<_>>();
state
.common
.shell
.toggle_sticky(seats.iter(), &seat, &mapped);
}
if (workspace_output == seat.active_output() && active_handle == workspace_handle)
|| parent_is_sticky
{
// TODO: enforce focus stealing prevention by also checking the same rules as for the else case.
Shell::set_focus(
state,
Some(&KeyboardFocusTarget::from(mapped.clone())),
&seat,
None,
);
} else if workspace_empty || was_activated || should_be_fullscreen {
Shell::append_focus_stack(
state,
Some(&KeyboardFocusTarget::from(mapped.clone())),
&seat,
);
state.common.shell.set_urgent(&workspace_handle);
}
let active_space = state.common.shell.active_space(&output);
for mapped in active_space.mapped() {
state.common.shell.update_reactive_popups(mapped);
}
}
pub fn map_override_redirect(state: &mut State, window: X11Surface) {
let geo = window.geometry();
for (output, overlap) in state.common.shell.outputs().cloned().filter_map(|o| {
o.geometry()
.as_logical()
.intersection(geo)
.map(|overlap| (o, overlap))
}) {
window.output_enter(&output, overlap);
}
state.common.shell.override_redirect_windows.push(window);
}
pub fn map_layer(state: &mut State, layer_surface: &LayerSurface) {
let pos = state
.common
.shell
.pending_layers
.iter()
.position(|(l, _, _)| l == layer_surface)
.unwrap();
let (layer_surface, output, seat) = state.common.shell.pending_layers.remove(pos);
let wants_focus = {
with_states(layer_surface.wl_surface(), |states| {
let state = states.cached_state.current::<LayerSurfaceCachedState>();
matches!(state.layer, Layer::Top | Layer::Overlay)
&& state.keyboard_interactivity != KeyboardInteractivity::None
})
};
{
let mut map = layer_map_for_output(&output);
map.map_layer(&layer_surface).unwrap();
}
for workspace in state.common.shell.workspaces.spaces_mut() {
workspace.tiling_layer.recalculate();
}
if wants_focus {
Shell::set_focus(state, Some(&layer_surface.into()), &seat, None)
}
}
pub fn element_under(
&mut self,
location: Point<f64, Global>,
output: &Output,
) -> Option<(PointerFocusTarget, Point<i32, Global>)> {
let overview = self.overview_mode.clone();
self.workspaces.sets.get_mut(output).and_then(|set| {
set.sticky_layer
.space
.element_under(location.to_local(output).as_logical())
.map(|(mapped, p)| (mapped.clone().into(), p.as_local().to_global(output)))
.or_else(|| set.workspaces[set.active].element_under(location, overview))
})
}
pub fn move_window(
state: &mut State,
seat: Option<&Seat<State>>,
mapped: &CosmicMapped,
from: &WorkspaceHandle,
to: &WorkspaceHandle,
follow: bool,
direction: Option<Direction>,
) -> Option<Point<i32, Global>> {
let from_output = state
.common
.shell
.workspaces
.space_for_handle(from)?
.output
.clone();
let to_output = state
.common
.shell
.workspaces
.space_for_handle(to)?
.output
.clone();
let from_workspace = state
.common
.shell
.workspaces
.space_for_handle_mut(from)
.unwrap(); // checked above
let window_state = from_workspace.unmap(mapped)?;
let elements = from_workspace.mapped().cloned().collect::<Vec<_>>();
for (toplevel, _) in mapped.windows() {
state
.common
.shell
.toplevel_info_state
.toplevel_leave_workspace(&toplevel, from);
if from_output != to_output {
state
.common
.shell
.toplevel_info_state
.toplevel_leave_output(&toplevel, &from_output);
}
}
for mapped in elements.into_iter() {
state.common.shell.update_reactive_popups(&mapped);
}
let new_pos = if follow {
if let Some(seat) = seat {
seat.set_active_output(&to_output);
}
state
.common
.shell
.workspaces
.idx_for_handle(&to_output, to)
.and_then(|to_idx| state.common.shell.activate(&to_output, to_idx).unwrap())
} else {
None
};
let mut to_workspace = state
.common
.shell
.workspaces
.space_for_handle_mut(to)
.unwrap(); // checked above
let focus_stack = seat.map(|seat| to_workspace.focus_stack.get(&seat));
if window_state.layer == ManagedLayer::Floating {
to_workspace.floating_layer.map(mapped.clone(), None);
} else {
to_workspace.tiling_layer.map(
mapped.clone(),
focus_stack.as_ref().map(|x| x.iter()),
direction,
);
}
let focus_target = if let Some(f) = window_state.was_fullscreen {
if to_workspace.fullscreen.is_some() {
if let Some((mapped, layer, previous_workspace)) = to_workspace.remove_fullscreen()
{
let old_handle = to.clone();
let new_workspace_handle = state
.common
.shell
.workspaces
.space_for_handle(&previous_workspace)
.is_some()
.then_some(previous_workspace)
.unwrap_or(old_handle);
state.common.shell.remap_unfullscreened_window(
mapped,
&old_handle,
&new_workspace_handle,
layer,
);
to_workspace = state
.common
.shell
.workspaces
.space_for_handle_mut(to)
.unwrap();
// checked above
}
}
to_workspace.fullscreen_request(&mapped.active_window(), f.previously);
to_workspace
.fullscreen
.as_ref()
.map(|f| KeyboardFocusTarget::from(f.surface.clone()))
.unwrap_or_else(|| KeyboardFocusTarget::from(mapped.clone()))
} else {
KeyboardFocusTarget::from(mapped.clone())
};
for mapped in to_workspace
.mapped()
.cloned()
.collect::<Vec<_>>()
.into_iter()
{
state.common.shell.update_reactive_popups(&mapped);
}
for (toplevel, _) in mapped.windows() {
if from_output != to_output {
state
.common
.shell
.toplevel_info_state
.toplevel_enter_output(&toplevel, &to_output);
}
state
.common
.shell
.toplevel_info_state
.toplevel_enter_workspace(&toplevel, to);
}
if follow {
if let Some(seat) = seat {
Common::set_focus(state, Some(&focus_target), &seat, None);
}
}
new_pos
}
pub fn move_current_window(
state: &mut State,
seat: &Seat<State>,
from_output: &Output,
to: (&Output, Option<usize>),
follow: bool,
direction: Option<Direction>,
) -> Result<Option<Point<i32, Global>>, InvalidWorkspaceIndex> {
let (to_output, to_idx) = to;
let to_idx = to_idx.unwrap_or(state.common.shell.workspaces.active_num(to_output).1);
if from_output == to_output
&& to_idx == state.common.shell.workspaces.active_num(from_output).1
{
return Ok(None);
}
let to = state
.common
.shell
.workspaces
.get(to_idx, to_output)
.map(|ws| ws.handle)
.ok_or(InvalidWorkspaceIndex)?;
let from_workspace = state.common.shell.workspaces.active_mut(from_output);
let maybe_window = from_workspace.focus_stack.get(seat).last().cloned();
let Some(mapped) = maybe_window else {
return Ok(None);
};
let from = from_workspace.handle;
Ok(Shell::move_window(
state,
Some(seat),
&mapped,
&from,
&to,
follow,
direction,
))
}
pub fn update_reactive_popups(&self, mapped: &CosmicMapped) {
if let Some(workspace) = self.space_for(mapped) {
let element_loc = workspace
.element_geometry(mapped)
.unwrap()
.loc
.to_global(&workspace.output);
for (toplevel, offset) in mapped.windows() {
if let CosmicSurface::Wayland(toplevel) = toplevel {
let window_geo_offset = toplevel.geometry().loc.as_global();
update_reactive_popups(
&toplevel,
element_loc + offset.as_global() + window_geo_offset,
self.outputs(),
);
}
}
}
}
pub fn menu_request(
state: &mut State,
surface: &WlSurface,
seat: &Seat<State>,
serial: impl Into<Option<Serial>>,
location: Point<i32, Logical>,
target_stack: bool,
) {
let serial = serial.into();
if let Some(start_data) =
check_grab_preconditions(&seat, surface, serial, ReleaseMode::NoMouseButtons)
{
if let Some(mapped) = state.common.shell.element_for_wl_surface(surface).cloned() {
let (_, relative_loc) = mapped
.windows()
.find(|(w, _)| w.wl_surface().as_ref() == Some(surface))
.unwrap();
let (global_position, edge, is_tiled, is_stacked, is_sticky, tiling_enabled) =
if let Some(set) = state
.common
.shell
.workspaces
.sets
.values_mut()
.find(|set| set.sticky_layer.mapped().any(|m| m == &mapped))
{
let output = set.output.clone();
let global_position =
(set.sticky_layer.element_geometry(&mapped).unwrap().loc
+ relative_loc.as_local()
+ location.as_local())
.to_global(&output);
(
global_position,
ResizeEdge::all(),
false,
mapped.is_stack(),
true,
false,
)
} else if let Some(workspace) = state.common.shell.space_for_mut(&mapped) {
let output = seat.active_output();
let global_position = (workspace.element_geometry(&mapped).unwrap().loc
+ relative_loc.as_local()
+ location.as_local())
.to_global(&output);
let is_tiled = workspace.is_tiled(&mapped);
let edge = if is_tiled {
mapped
.tiling_node_id
.lock()
.unwrap()
.clone()
.map(|node_id| {
TilingLayout::possible_resizes(
workspace.tiling_layer.tree(),
node_id,
)
})
.unwrap_or(ResizeEdge::empty())
} else {
ResizeEdge::all()
};
(
global_position,
edge,
is_tiled,
mapped.is_stack(),
false,
workspace.tiling_enabled,
)
} else {
return;
};
let grab = MenuGrab::new(
start_data,
seat,
if target_stack || !is_stacked {
Box::new(window_items(
&mapped,
is_tiled,
is_stacked,
is_sticky,
tiling_enabled,
edge,
&state.common.config.static_conf,
)) as Box<dyn Iterator<Item = Item>>
} else {
let (tab, _) = mapped
.windows()
.find(|(s, _)| s.wl_surface().as_ref() == Some(surface))
.unwrap();
Box::new(tab_items(
&mapped,
&tab,
is_tiled,
&state.common.config.static_conf,
)) as Box<dyn Iterator<Item = Item>>
},
global_position,
state.common.event_loop_handle.clone(),
state.common.theme.clone(),
);
seat.get_pointer().unwrap().set_grab(
state,
grab,
serial.unwrap_or_else(|| SERIAL_COUNTER.next_serial()),
Focus::Keep,
);
}
}
}
pub fn move_request(
state: &mut State,
surface: &WlSurface,
seat: &Seat<State>,
serial: impl Into<Option<Serial>>,
release: ReleaseMode,
move_out_of_stack: bool,
) {
let serial = serial.into();
let output = seat.active_output();
if let Some(mut start_data) = check_grab_preconditions(&seat, surface, serial, release) {
if let Some(mut old_mapped) =
state.common.shell.element_for_wl_surface(surface).cloned()
{
let seats = state.common.seats().cloned().collect::<Vec<_>>();
for workspace in state.common.shell.workspaces.spaces_mut() {
for seat in seats.iter() {
let mut stack = workspace.focus_stack.get_mut(seat);
stack.remove(&old_mapped);
}
}
let (window, _) = old_mapped
.windows()
.find(|(w, _)| w.wl_surface().as_ref() == Some(surface))
.unwrap();
let mapped = if move_out_of_stack {
let new_mapped: CosmicMapped = CosmicWindow::new(
window.clone(),
state.common.event_loop_handle.clone(),
state.common.theme.clone(),
)
.into();
start_data.focus = Some((new_mapped.clone().into(), Point::from((0, 0))));
new_mapped
} else {
old_mapped.clone()
};
let button = start_data.button;
let active_hint = state.common.theme.cosmic().active_hint as u8;
let pointer = seat.get_pointer().unwrap();
let pos = pointer.current_location().as_global();
let (initial_window_location, layer, workspace_handle) =
if let Some(workspace) = state.common.shell.space_for_mut(&old_mapped) {
if workspace
.fullscreen
.as_ref()
.is_some_and(|f| f.surface == window)
{
let _ = workspace.remove_fullscreen(); // We are moving this window, we don't need to send it back to it's original workspace
}
let mut initial_window_location = workspace
.element_geometry(&old_mapped)
.unwrap()
.loc
.to_global(&output);
if mapped.maximized_state.lock().unwrap().is_some() {
// If surface is maximized then unmaximize it
let new_size = workspace.unmaximize_request(&mapped);
let ratio = pos.to_local(&output).x / output.geometry().size.w as f64;
initial_window_location = new_size
.map(|size| (pos.x - (size.w as f64 * ratio), pos.y).into())
.unwrap_or_else(|| pos)
.to_i32_round();
}
let layer = if mapped == old_mapped {
let was_floating = workspace.floating_layer.unmap(&mapped);
let was_tiled = workspace.tiling_layer.unmap_as_placeholder(&mapped);
assert!(was_floating != was_tiled.is_some());
was_tiled.is_some()
} else {
workspace
.tiling_layer
.mapped()
.any(|(_, m, _)| m == &old_mapped)
}
.then_some(ManagedLayer::Tiling)
.unwrap_or(ManagedLayer::Floating);
(initial_window_location, layer, workspace.handle)
} else if let Some(sticky_layer) = state
.common
.shell
.workspaces
.sets
.get_mut(&output)
.filter(|set| set.sticky_layer.mapped().any(|m| m == &old_mapped))
.map(|set| &mut set.sticky_layer)
{
let mut initial_window_location = sticky_layer
.element_geometry(&old_mapped)
.unwrap()
.loc
.to_global(&output);
if let Some(state) = mapped.maximized_state.lock().unwrap().take() {
// If surface is maximized then unmaximize it
mapped.set_maximized(false);
let new_size = state.original_geometry.size.as_logical();
sticky_layer.map_internal(
mapped.clone(),
Some(state.original_geometry.loc),
Some(new_size),
);
let ratio = pos.to_local(&output).x / output.geometry().size.w as f64;
initial_window_location =
Point::<f64, _>::from((pos.x - (new_size.w as f64 * ratio), pos.y))
.to_i32_round();
}
if mapped == old_mapped {
sticky_layer.unmap(&mapped);
}
(
initial_window_location,
ManagedLayer::Sticky,
state.common.shell.active_space(&output).handle,
)
} else {
return;
};
state
.common
.shell
.toplevel_info_state
.toplevel_leave_workspace(&window, &workspace_handle);
state
.common
.shell
.toplevel_info_state
.toplevel_leave_output(&window, &output);
if move_out_of_stack {
old_mapped.stack_ref_mut().unwrap().remove_window(&window);
state
.common
.shell
.workspaces
.space_for_handle_mut(&workspace_handle)
.unwrap()
.refresh(&state.common.shell.xdg_activation_state);
}
let grab = MoveGrab::new(
start_data,
mapped,
seat,
pos,
initial_window_location,
active_hint as u8,
layer,
release,
state.common.event_loop_handle.clone(),
);
if grab.is_tiling_grab() {
state.common.shell.set_overview_mode(
Some(Trigger::Pointer(button)),
state.common.event_loop_handle.clone(),
);
}
seat.get_pointer().unwrap().set_grab(
state,
grab,
serial.unwrap_or_else(|| SERIAL_COUNTER.next_serial()),
Focus::Clear,
);
}
}
}
pub fn next_focus<'a>(&mut self, direction: FocusDirection, seat: &Seat<State>) -> FocusResult {
let overview = self.overview_mode().0;
let output = seat.active_output();
let workspace = self.active_space_mut(&output);
if workspace.fullscreen.is_some() {
return FocusResult::None;
}
let Some(target) = seat.get_keyboard().unwrap().current_focus() else {
return FocusResult::None
};
let set = self.workspaces.sets.get_mut(&output).unwrap();
let sticky_layer = &mut set.sticky_layer;
let workspace = &mut set.workspaces[set.active];
let Some(focused) = (match target {
KeyboardFocusTarget::Popup(popup) => {
let Some(toplevel_surface) = (match popup {
PopupKind::Xdg(xdg) => get_popup_toplevel(&xdg),
PopupKind::InputMethod(_) => unreachable!(),
}) else {
return FocusResult::None
};
sticky_layer.space.elements().chain(workspace.mapped()).find(|elem| elem.wl_surface().as_ref() == Some(&toplevel_surface))
},
KeyboardFocusTarget::Element(elem) => sticky_layer.space.elements().chain(workspace.mapped()).find(|e| *e == &elem),
_ => None,
}).cloned() else {
return FocusResult::None
};
if focused.handle_focus(direction, None) {
return FocusResult::Handled;
}
if workspace.is_tiled(&focused) {
let focus_stack = workspace.focus_stack.get(seat);
let swap_desc = match overview {
OverviewMode::Started(Trigger::KeyboardSwap(_, desc), _) => Some(desc),
_ => None,
};
workspace
.tiling_layer
.next_focus(direction, seat, focus_stack.iter(), swap_desc)
} else {
let floating_layer = &mut set.workspaces[set.active].floating_layer;
let geometry = sticky_layer
.space
.element_geometry(&focused)
.or_else(|| floating_layer.space.element_geometry(&focused))
.unwrap();
let elements = sticky_layer
.space
.elements()
.chain(floating_layer.space.elements())
.filter(|elem| *elem != &focused)
.map(|elem| {
(
elem,
sticky_layer
.space
.element_geometry(elem)
.or_else(|| floating_layer.space.element_geometry(elem))
.unwrap(),
)
});
let next = match direction {
FocusDirection::Up => elements
.filter(|(_, other_geo)| other_geo.loc.y <= geometry.loc.y)
.min_by_key(|(_, other_geo)| {
let res = geometry.loc.y - other_geo.loc.y;
if res.is_positive() {
res
} else {
i32::MAX
}
}),
FocusDirection::Down => elements
.filter(|(_, other_geo)| other_geo.loc.y > geometry.loc.y)
.max_by_key(|(_, other_geo)| {
let res = geometry.loc.y - other_geo.loc.y;
if res.is_negative() {
res
} else {
i32::MIN
}
}),
FocusDirection::Left => elements
.filter(|(_, other_geo)| other_geo.loc.x <= geometry.loc.x)
.min_by_key(|(_, other_geo)| {
let res = geometry.loc.x - other_geo.loc.x;
if res.is_positive() {
res
} else {
i32::MAX
}
}),
FocusDirection::Right => elements
.filter(|(_, other_geo)| other_geo.loc.x > geometry.loc.x)
.max_by_key(|(_, other_geo)| {
let res = geometry.loc.x - other_geo.loc.x;
if res.is_negative() {
res
} else {
i32::MIN
}
}),
_ => return FocusResult::None,
}
.map(|(other, _)| other);
next.map(|elem| FocusResult::Some(KeyboardFocusTarget::Element(elem.clone())))
.unwrap_or(FocusResult::None)
}
}
pub fn move_current_element<'a>(
&mut self,
direction: Direction,
seat: &Seat<State>,
) -> MoveResult {
let output = seat.active_output();
let workspace = self.active_space(&output);
let focus_stack = workspace.focus_stack.get(seat);
let Some(last) = focus_stack.last().cloned() else {
return MoveResult::None
};
let fullscreen = workspace.fullscreen.as_ref().map(|f| f.surface.clone());
if let Some(surface) = fullscreen {
MoveResult::MoveFurther(KeyboardFocusTarget::Fullscreen(surface))
} else if let Some(set) = self
.workspaces
.sets
.values_mut()
.find(|set| set.sticky_layer.mapped().any(|m| m == &last))
{
set.sticky_layer
.move_current_element(direction, seat, self.theme.clone())
} else {
let theme = self.theme.clone();
let workspace = self.active_space_mut(&output);
workspace
.floating_layer
.move_current_element(direction, seat, theme)
.or_else(|| workspace.tiling_layer.move_current_node(direction, seat))
}
}
pub fn menu_resize_request(
state: &mut State,
mapped: &CosmicMapped,
seat: &Seat<State>,
edge: ResizeEdge,
) {
let Some(surface) = mapped.active_window().wl_surface() else { return };
if let Some(start_data) =
check_grab_preconditions(&seat, &surface, None, ReleaseMode::Click)
{
if let Some(ws) = state.common.shell.space_for_mut(mapped) {
let geometry = ws.element_geometry(mapped).unwrap().to_global(ws.output());
let new_loc = if edge.contains(ResizeEdge::LEFT) {
Point::<i32, Global>::from((
geometry.loc.x,
geometry.loc.y + (geometry.size.h / 2),
))
} else if edge.contains(ResizeEdge::RIGHT) {
Point::<i32, Global>::from((
geometry.loc.x + geometry.size.w,
geometry.loc.y + (geometry.size.h / 2),
))
} else if edge.contains(ResizeEdge::TOP) {
Point::<i32, Global>::from((
geometry.loc.x + (geometry.size.w / 2),
geometry.loc.y,
))
} else if edge.contains(ResizeEdge::BOTTOM) {
Point::<i32, Global>::from((
geometry.loc.x + (geometry.size.w / 2),
geometry.loc.y + geometry.size.h,
))
} else {
return;
};
let grab: ResizeGrab = if ws.is_floating(mapped) {
let Some(grab) = ws.floating_layer.resize_request(mapped, seat, start_data, edge, ReleaseMode::Click) else {
return
};
grab.into()
} else {
let Some(node_id) = mapped.tiling_node_id.lock().unwrap().clone() else { return };
let Some((node, left_up_idx, orientation)) =
ws.tiling_layer.menu_resize(node_id, edge) else { return };
ResizeForkGrab::new(
start_data,
new_loc.to_f64(),
node,
left_up_idx,
orientation,
ws.output.downgrade(),
ReleaseMode::Click,
)
.into()
};
let ptr = seat.get_pointer().unwrap();
let serial = SERIAL_COUNTER.next_serial();
ptr.motion(
state,
Some((mapped.clone().into(), (new_loc - geometry.loc).as_logical())),
&MotionEvent {
location: new_loc.as_logical().to_f64(),
serial,
time: 0,
},
);
ptr.frame(state);
ptr.set_grab(state, grab, serial, Focus::Keep);
}
}
}
pub fn maximize_toggle(&mut self, window: &CosmicMapped) {
if window.is_maximized(true) {
self.unmaximize_request(window);
} else {
self.maximize_request(window);
}
}
pub fn maximize_request(&mut self, mapped: &CosmicMapped) {
let (original_layer, floating_layer, original_geometry) = if let Some(set) = self
.workspaces
.sets
.values_mut()
.find(|set| set.sticky_layer.mapped().any(|m| m == mapped))
{
let geometry = set.sticky_layer.element_geometry(mapped).unwrap();
(ManagedLayer::Sticky, &mut set.sticky_layer, geometry)
} else if let Some(workspace) = self.space_for_mut(&mapped) {
let layer = if workspace.is_floating(&mapped) {
ManagedLayer::Floating
} else {
ManagedLayer::Tiling
};
let geometry = workspace.element_geometry(mapped).unwrap();
(layer, &mut workspace.floating_layer, geometry)
} else {
return;
};
let mut state = mapped.maximized_state.lock().unwrap();
if state.is_none() {
*state = Some(MaximizedState {
original_geometry,
original_layer,
});
std::mem::drop(state);
floating_layer.map_maximized(mapped.clone());
}
}
pub fn unmaximize_request(&mut self, mapped: &CosmicMapped) -> Option<Size<i32, Logical>> {
if let Some(set) = self
.workspaces
.sets
.values_mut()
.find(|set| set.sticky_layer.mapped().any(|m| m == mapped))
{
let mut state = mapped.maximized_state.lock().unwrap();
if let Some(state) = state.take() {
assert_eq!(state.original_layer, ManagedLayer::Sticky);
mapped.set_maximized(false);
set.sticky_layer.map_internal(
mapped.clone(),
Some(state.original_geometry.loc),
Some(state.original_geometry.size.as_logical()),
);
Some(state.original_geometry.size.as_logical())
} else {
None
}
} else if let Some(workspace) = self.space_for_mut(mapped) {
workspace.unmaximize_request(mapped)
} else {
None
}
}
pub fn resize_request(
state: &mut State,
surface: &WlSurface,
seat: &Seat<State>,
serial: impl Into<Option<Serial>>,
edges: ResizeEdge,
) {
let serial = serial.into();
if let Some(start_data) =
check_grab_preconditions(&seat, surface, serial, ReleaseMode::NoMouseButtons)
{
if let Some(mapped) = state.common.shell.element_for_wl_surface(surface).cloned() {
if mapped.is_fullscreen(true) || mapped.is_maximized(true) {
return;
}
let floating_layer = if let Some(set) = state
.common
.shell
.workspaces
.sets
.values_mut()
.find(|set| set.sticky_layer.mapped().any(|m| m == &mapped))
{
&mut set.sticky_layer
} else if let Some(workspace) = state.common.shell.space_for_mut(&mapped) {
&mut workspace.floating_layer
} else {
return;
};
if let Some(grab) = floating_layer.resize_request(
&mapped,
seat,
start_data.clone(),
edges,
ReleaseMode::NoMouseButtons,
) {
seat.get_pointer().unwrap().set_grab(
state,
grab,
serial.unwrap_or_else(|| SERIAL_COUNTER.next_serial()),
Focus::Clear,
);
}
}
}
}
pub fn resize(&mut self, seat: &Seat<State>, direction: ResizeDirection, edge: ResizeEdge) {
let output = seat.active_output();
let (_, idx) = self.workspaces.active_num(&output);
let Some(focused) = seat.get_keyboard().unwrap().current_focus() else {
return;
};
let amount = (self
.resize_state
.take()
.map(|(_, _, _, amount, _, _)| amount)
.unwrap_or(10)
+ 2)
.min(20);
if self
.workspaces
.sets
.get_mut(&output)
.unwrap()
.sticky_layer
.resize(&focused, direction, edge, amount)
{
self.resize_state = Some((focused, direction, edge, amount, idx, output));
} else if let Some(workspace) = self.workspaces.get_mut(idx, &output) {
if workspace.resize(&focused, direction, edge, amount) {
self.resize_state = Some((focused, direction, edge, amount, idx, output));
}
}
}
pub fn finish_resize(&mut self, direction: ResizeDirection, edge: ResizeEdge) {
if let Some((old_focused, old_direction, old_edge, _, idx, output)) =
self.resize_state.take()
{
if old_direction == direction && old_edge == edge {
let Some(toplevel) = old_focused.toplevel() else {
return;
};
let Some(mapped) = self.workspaces.sets.values()
.find_map(|set| set.sticky_layer.mapped()
.find(|m| m.has_surface(&toplevel, WindowSurfaceType::TOPLEVEL))
).cloned()
.or_else(|| {
let workspace = self.workspaces.get(idx, &output).unwrap();
workspace
.mapped()
.find(|m| m.has_surface(&toplevel, WindowSurfaceType::TOPLEVEL))
.cloned()
})
else {
return
};
let mut resize_state = mapped.resize_state.lock().unwrap();
if let Some(ResizeState::Resizing(data)) = *resize_state {
*resize_state = Some(ResizeState::WaitingForCommit(data));
}
}
}
}
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>>,
seat: &Seat<State>,
mapped: &CosmicMapped,
) {
// clean from focus-stacks
let seats = seats.collect::<Vec<_>>();
for workspace in self.workspaces.spaces_mut() {
for seat in seats.iter() {
let mut stack = workspace.focus_stack.get_mut(seat);
stack.remove(mapped);
}
}
if let Some(workspace) = self.space_for_mut(mapped) {
if workspace.is_fullscreen(mapped) {
// we are making it sticky, we don't need to move it to it's previous workspace
let _ = workspace.remove_fullscreen();
}
let previous_layer = if workspace.is_tiled(mapped) {
workspace.toggle_floating_window(seat, mapped);
ManagedLayer::Tiling
} else {
ManagedLayer::Floating
};
let geometry = workspace.element_geometry(mapped).unwrap();
workspace.unmap(mapped);
*mapped.previous_layer.lock().unwrap() = Some(previous_layer);
let output = workspace.output().clone();
let handle = workspace.handle;
for (window, _) in mapped.windows() {
self.toplevel_info_state
.toplevel_leave_workspace(&window, &handle);
}
self.workspaces
.sets
.get_mut(&output)
.unwrap()
.sticky_layer
.map(mapped.clone(), geometry.loc);
} else if let Some(set) = self
.workspaces
.sets
.values_mut()
.find(|set| set.sticky_layer.mapped().any(|m| m == mapped))
{
let geometry = set.sticky_layer.element_geometry(mapped).unwrap();
set.sticky_layer.unmap(mapped);
let workspace = &mut set.workspaces[set.active];
for (window, _) in mapped.windows() {
self.toplevel_info_state
.toplevel_enter_workspace(&window, &workspace.handle);
}
match mapped
.previous_layer
.lock()
.unwrap()
.take()
.unwrap_or(ManagedLayer::Floating)
{
ManagedLayer::Floating => {
workspace.floating_layer.map(mapped.clone(), geometry.loc)
}
ManagedLayer::Tiling => {
let focus_stack = workspace.focus_stack.get(seat);
workspace
.tiling_layer
.map(mapped.clone(), Some(focus_stack.iter()), None);
}
ManagedLayer::Sticky => unreachable!(),
}
}
}
pub fn toggle_sticky_current<'a>(
&mut self,
seats: impl Iterator<Item = &'a Seat<State>>,
seat: &Seat<State>,
) {
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(mapped) = maybe_window {
self.toggle_sticky(seats, seat, &mapped);
}
}
pub(crate) fn set_theme(&mut self, theme: cosmic::Theme) {
self.theme = theme.clone();
self.refresh();
self.workspaces
.set_theme(theme.clone(), &self.xdg_activation_state);
}
pub fn set_urgent(&mut self, workspace: &WorkspaceHandle) {
let mut workspace_guard = self.workspace_state.update();
workspace_guard.add_workspace_state(workspace, WState::Urgent);
}
}
fn workspace_set_idx<'a>(
state: &mut WorkspaceUpdateGuard<'a, State>,
idx: u8,
output_pos: usize,
handle: &WorkspaceHandle,
) {
state.set_workspace_name(&handle, format!("{}", idx));
state.set_workspace_coordinates(&handle, [Some(idx as u32), Some(output_pos as u32), None]);
}
pub fn check_grab_preconditions(
seat: &Seat<State>,
surface: &WlSurface,
serial: Option<Serial>,
release: ReleaseMode,
) -> Option<PointerGrabStartData<State>> {
use smithay::reexports::wayland_server::Resource;
// TODO: touch resize.
let pointer = seat.get_pointer().unwrap();
let start_data = pointer
.grab_start_data()
.unwrap_or_else(|| PointerGrabStartData {
focus: pointer.current_focus().map(|f| (f, Point::from((0, 0)))),
button: 0x110,
location: pointer.current_location(),
});
if release == ReleaseMode::NoMouseButtons {
// Check that this surface has a click grab.
if !match serial {
Some(serial) => pointer.has_grab(serial),
None => pointer.is_grabbed(),
} {
return None;
}
// If the focus was for a different surface, ignore the request.
if start_data.focus.is_none()
|| !start_data
.focus
.as_ref()
.unwrap()
.0
.same_client_as(&surface.id())
{
return None;
}
}
Some(start_data)
}
Reference in a new issue View git blame Copy permalink