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

shell: Rework fullscreen/maximize

Browse source
This commit is contained in:
Victoria Brekenfeld 2023-09-13 20:14:54 +02:00
parent 716728560a
commit abf430f956
6 changed files with 208 additions and 142 deletions
Download patch file Download diff file Expand all files Collapse all files

73
src/backend/render/mod.rs
View file

@ -528,7 +528,7 @@ where
.space_for_handle(&current.0) .space_for_handle(&current.0)
.ok_or(OutputNoMode)?; .ok_or(OutputNoMode)?;
let has_fullscreen = workspace.fullscreen.contains_key(output); let has_fullscreen = workspace.fullscreen.get(output).map(|f| f.exclusive);
let (overlay_elements, overlay_popups) = let (overlay_elements, overlay_popups) =
split_layer_elements(renderer, output, Layer::Overlay, exclude_workspace_overview); split_layer_elements(renderer, output, Layer::Overlay, exclude_workspace_overview);
@ -536,7 +536,7 @@ where
elements.extend(overlay_popups.into_iter().map(Into::into)); elements.extend(overlay_popups.into_iter().map(Into::into));
elements.extend(overlay_elements.into_iter().map(Into::into)); elements.extend(overlay_elements.into_iter().map(Into::into));
let mut window_elements = if !has_fullscreen { let mut window_elements = if !has_fullscreen.unwrap_or(false) {
let (top_elements, top_popups) = let (top_elements, top_popups) =
split_layer_elements(renderer, output, Layer::Top, exclude_workspace_overview); split_layer_elements(renderer, output, Layer::Top, exclude_workspace_overview);
elements.extend(top_popups.into_iter().map(Into::into)); elements.extend(top_popups.into_iter().map(Into::into));
@ -553,6 +553,7 @@ where
.shell .shell
.space_for_handle(&previous) .space_for_handle(&previous)
.ok_or(OutputNoMode)?; .ok_or(OutputNoMode)?;
let has_fullscreen = workspace.fullscreen.contains_key(output);
let is_active_space = workspace.outputs().any(|o| o == &active_output); let is_active_space = workspace.outputs().any(|o| o == &active_output);
let percentage = { let percentage = {
@ -602,22 +603,24 @@ where
)) ))
})); }));
let (w_elements, p_elements) = if !has_fullscreen {
background_layer_elements(renderer, output, exclude_workspace_overview); let (w_elements, p_elements) =
elements.extend(p_elements.into_iter().map(|p_element| { background_layer_elements(renderer, output, exclude_workspace_overview);
CosmicElement::Workspace(RelocateRenderElement::from_element( elements.extend(p_elements.into_iter().map(|p_element| {
p_element, CosmicElement::Workspace(RelocateRenderElement::from_element(
offset.to_physical_precise_round(output_scale), p_element,
Relocate::Relative, offset.to_physical_precise_round(output_scale),
)) Relocate::Relative,
})); ))
window_elements.extend(w_elements.into_iter().map(|w_element| { }));
CosmicElement::Workspace(RelocateRenderElement::from_element( window_elements.extend(w_elements.into_iter().map(|w_element| {
w_element, CosmicElement::Workspace(RelocateRenderElement::from_element(
offset.to_physical_precise_round(output_scale), w_element,
Relocate::Relative, offset.to_physical_precise_round(output_scale),
)) Relocate::Relative,
})); ))
}));
}
Point::<i32, Logical>::from(match (layout, *previous_idx < current.1) { Point::<i32, Logical>::from(match (layout, *previous_idx < current.1) {
(WorkspaceLayout::Vertical, true) => (0, output_size.h + offset.y), (WorkspaceLayout::Vertical, true) => (0, output_size.h + offset.y),
@ -658,24 +661,26 @@ where
)) ))
})); }));
let (w_elements, p_elements) = if has_fullscreen.is_none() {
background_layer_elements(renderer, output, exclude_workspace_overview); let (w_elements, p_elements) =
background_layer_elements(renderer, output, exclude_workspace_overview);
elements.extend(p_elements.into_iter().map(|p_element| { elements.extend(p_elements.into_iter().map(|p_element| {
CosmicElement::Workspace(RelocateRenderElement::from_element( CosmicElement::Workspace(RelocateRenderElement::from_element(
p_element, p_element,
offset.to_physical_precise_round(output_scale), offset.to_physical_precise_round(output_scale),
Relocate::Relative, Relocate::Relative,
)) ))
})); }));
window_elements.extend(w_elements.into_iter().map(|w_element| { window_elements.extend(w_elements.into_iter().map(|w_element| {
CosmicElement::Workspace(RelocateRenderElement::from_element( CosmicElement::Workspace(RelocateRenderElement::from_element(
w_element, w_element,
offset.to_physical_precise_round(output_scale), offset.to_physical_precise_round(output_scale),
Relocate::Relative, Relocate::Relative,
)) ))
})); }));
}
elements.extend(window_elements); elements.extend(window_elements);

81
src/input/mod.rs
View file

@ -733,30 +733,35 @@ impl State {
} }
}; };
if !done { if !done {
if let Some((target, _)) = if let Some(surface) = workspace.get_maximized(&output) {
workspace.element_under(relative_pos, overview.0) under = Some(surface.clone().into());
{
under = Some(target);
} else { } else {
let layers = layer_map_for_output(&output); if let Some((target, _)) =
if let Some(layer) = workspace.element_under(relative_pos, overview.0)
layers.layer_under(WlrLayer::Bottom, pos).or_else(
|| layers.layer_under(WlrLayer::Background, pos),
)
{ {
let layer_loc = under = Some(target);
layers.layer_geometry(layer).unwrap().loc; } else {
if layer.can_receive_keyboard_focus() let layers = layer_map_for_output(&output);
&& layer if let Some(layer) = layers
.surface_under( .layer_under(WlrLayer::Bottom, pos)
relative_pos - layer_loc.to_f64(), .or_else(|| {
WindowSurfaceType::ALL, layers.layer_under(WlrLayer::Background, pos)
) })
.is_some()
{ {
under = Some(layer.clone().into()); let layer_loc =
} layers.layer_geometry(layer).unwrap().loc;
}; if layer.can_receive_keyboard_focus()
&& layer
.surface_under(
relative_pos - layer_loc.to_f64(),
WindowSurfaceType::ALL,
)
.is_some()
{
under = Some(layer.clone().into());
}
};
}
} }
} }
} }
@ -1579,21 +1584,29 @@ impl State {
{ {
return Some((or.clone().into(), or.geometry().loc)); return Some((or.clone().into(), or.geometry().loc));
} }
if let Some((target, loc)) = workspace.element_under(relative_pos, overview) { if let Some(surface) = workspace.get_maximized(output) {
return Some((target, loc + (global_pos - relative_pos).to_i32_round())); let offset = layer_map_for_output(output).non_exclusive_zone().loc;
} return Some((surface.clone().into(), output_geo.loc + offset));
{ } else {
let layers = layer_map_for_output(output); if let Some((target, loc)) = workspace.element_under(relative_pos, overview) {
if let Some(layer) = layers return Some((target, loc + (global_pos - relative_pos).to_i32_round()));
.layer_under(WlrLayer::Bottom, relative_pos) }
.or_else(|| layers.layer_under(WlrLayer::Background, relative_pos))
{ {
let layer_loc = layers.layer_geometry(layer).unwrap().loc; let layers = layer_map_for_output(output);
if layer if let Some(layer) = layers
.surface_under(relative_pos - layer_loc.to_f64(), WindowSurfaceType::ALL) .layer_under(WlrLayer::Bottom, relative_pos)
.is_some() .or_else(|| layers.layer_under(WlrLayer::Background, relative_pos))
{ {
return Some((layer.clone().into(), output_geo.loc + layer_loc)); let layer_loc = layers.layer_geometry(layer).unwrap().loc;
if layer
.surface_under(
relative_pos - layer_loc.to_f64(),
WindowSurfaceType::ALL,
)
.is_some()
{
return Some((layer.clone().into(), output_geo.loc + layer_loc));
}
} }
} }
} }

2
src/shell/mod.rs
View file

@ -1334,7 +1334,7 @@ impl Shell {
let (window, seat) = state.common.shell.pending_windows.remove(pos); let (window, seat) = state.common.shell.pending_windows.remove(pos);
let workspace = state.common.shell.workspaces.active_mut(output); let workspace = state.common.shell.workspaces.active_mut(output);
workspace.set_fullscreen(None, output); workspace.remove_fullscreen(output);
state.common.shell.toplevel_info_state.new_toplevel(&window); state.common.shell.toplevel_info_state.new_toplevel(&window);
state state
.common .common

190
src/shell/workspace.rs
View file

@ -67,7 +67,7 @@ pub struct Workspace {
pub tiling_layer: TilingLayout, pub tiling_layer: TilingLayout,
pub floating_layer: FloatingLayout, pub floating_layer: FloatingLayout,
pub tiling_enabled: bool, pub tiling_enabled: bool,
pub fullscreen: HashMap<Output, CosmicSurface>, pub fullscreen: HashMap<Output, FullscreenSurface>,
pub handle: WorkspaceHandle, pub handle: WorkspaceHandle,
pub focus_stack: FocusStacks, pub focus_stack: FocusStacks,
pub pending_buffers: Vec<(ScreencopySession, BufferParams)>, pub pending_buffers: Vec<(ScreencopySession, BufferParams)>,
@ -75,6 +75,18 @@ pub struct Workspace {
pub(super) backdrop_id: Id, pub(super) backdrop_id: Id,
} }
#[derive(Debug, Clone)]
pub struct FullscreenSurface {
pub surface: CosmicSurface,
pub exclusive: bool,
}
impl IsAlive for FullscreenSurface {
fn alive(&self) -> bool {
self.surface.alive()
}
}
#[derive(Debug, Default)] #[derive(Debug, Default)]
pub struct FocusStacks(HashMap<Seat<State>, IndexSet<CosmicMapped>>); pub struct FocusStacks(HashMap<Seat<State>, IndexSet<CosmicMapped>>);
@ -145,7 +157,7 @@ impl Workspace {
toplevel_info: &mut ToplevelInfoState<State, CosmicSurface>, toplevel_info: &mut ToplevelInfoState<State, CosmicSurface>,
) { ) {
if let Some(dead_output_window) = self.fullscreen.remove(output) { if let Some(dead_output_window) = self.fullscreen.remove(output) {
self.unfullscreen_request(&dead_output_window); self.unfullscreen_request(&dead_output_window.surface);
} }
self.tiling_layer.unmap_output(output, toplevel_info); self.tiling_layer.unmap_output(output, toplevel_info);
self.floating_layer.unmap_output(output, toplevel_info); self.floating_layer.unmap_output(output, toplevel_info);
@ -243,6 +255,16 @@ impl Workspace {
}) })
} }
pub fn recalculate(&mut self, output: &Output) {
if let Some(f) = self.fullscreen.get(output) {
if !f.exclusive {
f.surface
.set_geometry(layer_map_for_output(output).non_exclusive_zone());
}
}
self.tiling_layer.recalculate(output);
}
pub fn maximize_request(&mut self, window: &CosmicSurface, output: &Output) { pub fn maximize_request(&mut self, window: &CosmicSurface, output: &Output) {
if self.fullscreen.contains_key(output) { if self.fullscreen.contains_key(output) {
return; return;
@ -252,10 +274,10 @@ impl Workspace {
window.set_fullscreen(false); window.set_fullscreen(false);
window.set_maximized(true); window.set_maximized(true);
self.set_fullscreen(window, output) self.set_fullscreen(window, output, false)
} }
pub fn unmaximize_request(&mut self, window: &CosmicSurface) -> Option<Size<i32, Logical>> { pub fn unmaximize_request(&mut self, window: &CosmicSurface) -> Option<Size<i32, Logical>> {
if self.fullscreen.values().any(|w| w == window) { if self.fullscreen.values().any(|w| &w.surface == window) {
self.unfullscreen_request(window); self.unfullscreen_request(window);
self.floating_layer.unmaximize_request(window) self.floating_layer.unmaximize_request(window)
} else { } else {
@ -264,50 +286,69 @@ impl Workspace {
} }
pub fn fullscreen_request(&mut self, window: &CosmicSurface, output: &Output) { pub fn fullscreen_request(&mut self, window: &CosmicSurface, output: &Output) {
if self.fullscreen.contains_key(output) { if self
.fullscreen
.get(output)
.map(|w| &w.surface != window)
.unwrap_or(false)
{
return; return;
} }
if !window.is_maximized(true) {
self.floating_layer.maximize_request(window);
}
window.set_maximized(false); window.set_maximized(false);
window.set_fullscreen(true); window.set_fullscreen(true);
self.set_fullscreen(window, output) self.set_fullscreen(window, output, true)
} }
pub(super) fn set_fullscreen<'a>( fn set_fullscreen<'a>(&mut self, window: &'a CosmicSurface, output: &Output, exclusive: bool) {
&mut self, if let Some(mapped) = self
window: impl Into<Option<&'a CosmicSurface>>, .mapped()
output: &Output, .find(|m| m.windows().any(|(w, _)| &w == window))
) { {
match window.into() { mapped.set_active(window);
Some(window) => {
if let Some(mapped) = self
.mapped()
.find(|m| m.windows().any(|(w, _)| &w == window))
{
mapped.set_active(window);
}
window.set_geometry(output.geometry());
window.send_configure();
self.fullscreen.insert(output.clone(), window.clone());
}
None => {
if let Some(surface) = self.fullscreen.get(output).cloned() {
self.unfullscreen_request(&surface);
}
}
} }
window.set_geometry(if exclusive {
output.geometry()
} else {
layer_map_for_output(output).non_exclusive_zone()
});
window.send_configure();
self.fullscreen.insert(
output.clone(),
FullscreenSurface {
surface: window.clone(),
exclusive,
},
);
} }
pub fn unfullscreen_request(&mut self, window: &CosmicSurface) { pub fn unfullscreen_request(&mut self, window: &CosmicSurface) {
if let Some((output, _)) = self.fullscreen.iter().find(|(_, w)| *w == window) { if let Some((output, _)) = self.fullscreen.iter().find(|(_, w)| &w.surface == window) {
window.set_maximized(false); window.set_maximized(false);
window.set_fullscreen(false); window.set_fullscreen(false);
self.floating_layer.unmaximize_request(window);
self.floating_layer.refresh(); self.floating_layer.refresh();
self.tiling_layer.recalculate(output); self.tiling_layer.recalculate(output);
self.tiling_layer.refresh(); self.tiling_layer.refresh();
window.send_configure(); window.send_configure();
self.fullscreen.retain(|_, w| w != window); self.fullscreen.retain(|_, w| &w.surface != window);
}
}
pub fn remove_fullscreen(&mut self, output: &Output) {
if let Some(FullscreenSurface { surface, .. }) = self.fullscreen.remove(output) {
surface.set_maximized(false);
surface.set_fullscreen(false);
self.floating_layer.unmaximize_request(&surface);
self.floating_layer.refresh();
self.tiling_layer.recalculate(output);
self.tiling_layer.refresh();
surface.send_configure();
} }
} }
@ -320,7 +361,17 @@ impl Workspace {
} }
pub fn get_fullscreen(&self, output: &Output) -> Option<&CosmicSurface> { pub fn get_fullscreen(&self, output: &Output) -> Option<&CosmicSurface> {
self.fullscreen.get(output).filter(|w| w.alive()) self.fullscreen
.get(output)
.filter(|w| w.alive() && w.exclusive)
.map(|w| &w.surface)
}
pub fn get_maximized(&self, output: &Output) -> Option<&CosmicSurface> {
self.fullscreen
.get(output)
.filter(|w| w.alive() && !w.exclusive)
.map(|w| &w.surface)
} }
pub fn resize_request( pub fn resize_request(
@ -354,7 +405,7 @@ impl Workspace {
if self if self
.fullscreen .fullscreen
.values() .values()
.any(|surface| surface.wl_surface().as_ref() == Some(&toplevel)) .any(|f| f.surface.wl_surface().as_ref() == Some(&toplevel))
{ {
return false; return false;
} }
@ -472,14 +523,20 @@ impl Workspace {
pub fn is_fullscreen(&self, mapped: &CosmicMapped) -> bool { pub fn is_fullscreen(&self, mapped: &CosmicMapped) -> bool {
self.fullscreen self.fullscreen
.values() .values()
.any(|s| s == &mapped.active_window()) .any(|f| f.exclusive && f.surface == mapped.active_window())
}
pub fn is_maximized(&self, mapped: &CosmicMapped) -> bool {
self.fullscreen
.values()
.any(|f| !f.exclusive && f.surface == mapped.active_window())
} }
pub fn is_floating(&self, mapped: &CosmicMapped) -> bool { pub fn is_floating(&self, mapped: &CosmicMapped) -> bool {
!self !self
.fullscreen .fullscreen
.values() .values()
.any(|s| s == &mapped.active_window()) .any(|f| f.surface == mapped.active_window())
&& self.floating_layer.mapped().any(|m| m == mapped) && self.floating_layer.mapped().any(|m| m == mapped)
} }
@ -487,7 +544,7 @@ impl Workspace {
!self !self
.fullscreen .fullscreen
.values() .values()
.any(|s| s == &mapped.active_window()) .any(|f| f.surface == mapped.active_window())
&& self.tiling_layer.mapped().any(|(_, m, _)| m == mapped) && self.tiling_layer.mapped().any(|(_, m, _)| m == mapped)
} }
@ -563,30 +620,38 @@ impl Workspace {
let layer_map = layer_map_for_output(output); let layer_map = layer_map_for_output(output);
let zone = layer_map.non_exclusive_zone(); let zone = layer_map.non_exclusive_zone();
if let Some(fullscreen) = self.fullscreen.get(output) { // OR windows above all
popup_elements.extend( popup_elements.extend(
override_redirect_windows override_redirect_windows
.iter() .iter()
.filter(|or| (*or).geometry().intersection(output.geometry()).is_some()) .filter(|or| (*or).geometry().intersection(output.geometry()).is_some())
.flat_map(|or| { .flat_map(|or| {
AsRenderElements::<R>::render_elements::<WorkspaceRenderElement<R>>( AsRenderElements::<R>::render_elements::<WorkspaceRenderElement<R>>(
or, or,
renderer, renderer,
(or.geometry().loc - output.geometry().loc) (or.geometry().loc - output.geometry().loc)
.to_physical_precise_round(output_scale), .to_physical_precise_round(output_scale),
Scale::from(output_scale), Scale::from(output_scale),
1.0, 1.0,
) )
}), }),
); );
if let Some(fullscreen) = self.fullscreen.get(output) {
// fullscreen window // fullscreen window
window_elements.extend(AsRenderElements::<R>::render_elements::< window_elements.extend(AsRenderElements::<R>::render_elements::<
WorkspaceRenderElement<R>, WorkspaceRenderElement<R>,
>( >(
fullscreen, &fullscreen.surface,
renderer, renderer,
(0, 0).into(), if fullscreen.exclusive {
(0, 0).into()
} else {
layer_map
.non_exclusive_zone()
.loc
.to_physical_precise_round(output_scale)
},
output_scale.into(), output_scale.into(),
1.0, 1.0,
)); ));
@ -603,23 +668,6 @@ impl Workspace {
} }
} }
} else { } else {
// OR windows above all
popup_elements.extend(
override_redirect_windows
.iter()
.filter(|or| (*or).geometry().intersection(output.geometry()).is_some())
.flat_map(|or| {
AsRenderElements::<R>::render_elements::<WorkspaceRenderElement<R>>(
or,
renderer,
(or.geometry().loc - output.geometry().loc)
.to_physical_precise_round(output_scale),
Scale::from(output_scale),
1.0,
)
}),
);
let focused = let focused =
draw_focus_indicator.and_then(|seat| self.focus_stack.get(seat).last().cloned()); draw_focus_indicator.and_then(|seat| self.focus_stack.get(seat).last().cloned());

2
src/wayland/handlers/compositor.rs
View file

@ -251,7 +251,7 @@ impl CompositorHandler for State {
let changed = layer_map_for_output(&output).arrange(); let changed = layer_map_for_output(&output).arrange();
if changed { if changed {
for workspace in self.common.shell.workspaces.spaces_mut() { for workspace in self.common.shell.workspaces.spaces_mut() {
workspace.tiling_layer.recalculate(&output); workspace.recalculate(&output);
} }
} }
} }

2
src/wayland/handlers/layer_shell.rs
View file

@ -76,7 +76,7 @@ impl WlrLayerShellHandler for State {
} }
for workspace in self.common.shell.workspaces.spaces_mut() { for workspace in self.common.shell.workspaces.spaces_mut() {
workspace.tiling_layer.recalculate(&output); workspace.recalculate(&output);
} }
// collect screencopy sessions needing an update // collect screencopy sessions needing an update