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

shell: Don't consider animation geometry when remapping fullscreen surfaces

Browse source
This commit is contained in:
Victoria Brekenfeld 2025-07-03 16:12:41 +02:00 • committed by Victoria Brekenfeld
parent d63f1abcdd
commit 54e76d5ad2
1 changed files with 28 additions and 34 deletions
Download patch file Download diff file Expand all files Collapse all files

62
src/shell/mod.rs
View file

@ -2419,7 +2419,6 @@ impl Shell {
&mut self, &mut self,
surface: CosmicSurface, surface: CosmicSurface,
state: Option<FullscreenRestoreState>, state: Option<FullscreenRestoreState>,
original_geometry: Option<Rectangle<i32, Local>>,
loop_handle: &LoopHandle<'static, State>, loop_handle: &LoopHandle<'static, State>,
) { ) {
let window = CosmicMapped::from(CosmicWindow::new( let window = CosmicMapped::from(CosmicWindow::new(
@ -2428,7 +2427,7 @@ impl Shell {
self.theme.clone(), self.theme.clone(),
)); ));
if let Some(FullscreenRestoreState::Sticky { output, .. }) = &state { if let Some(FullscreenRestoreState::Sticky { output, state, .. }) = &state {
let output = output let output = output
.upgrade() .upgrade()
.unwrap_or_else(|| self.seats.last_active().active_output()); .unwrap_or_else(|| self.seats.last_active().active_output());
@ -2441,8 +2440,8 @@ impl Shell {
.unwrap(); .unwrap();
set.sticky_layer.map_internal( set.sticky_layer.map_internal(
window, window,
original_geometry.map(|rect| rect.loc), Some(state.geometry.loc),
original_geometry.map(|rect| rect.size.as_logical()), Some(state.geometry.size.as_logical()),
Some(set.output.geometry().to_local(&set.output)), Some(set.output.geometry().to_local(&set.output)),
); );
return; return;
@ -2489,17 +2488,21 @@ impl Shell {
} }
} }
Some(FullscreenRestoreState::Floating { Some(FullscreenRestoreState::Floating {
state: FloatingRestoreData { was_maximized, .. }, state:
FloatingRestoreData {
was_maximized,
geometry,
..
},
.. ..
}) => { }) => {
workspace.floating_layer.map_internal( workspace.floating_layer.map_internal(
window.clone(), window.clone(),
original_geometry.map(|geo| geo.loc), Some(geometry.loc),
original_geometry.map(|geo| geo.size.as_logical()), Some(geometry.size.as_logical()),
Some(fullscreen_geometry), Some(fullscreen_geometry),
); );
if was_maximized { if was_maximized {
let geometry = workspace.floating_layer.element_geometry(&window).unwrap();
let mut state = window.maximized_state.lock().unwrap(); let mut state = window.maximized_state.lock().unwrap();
*state = Some(MaximizedState { *state = Some(MaximizedState {
original_geometry: geometry, original_geometry: geometry,
@ -2657,12 +2660,11 @@ impl Shell {
let floating_exception = layout::has_floating_exception(&self.tiling_exceptions, &window); let floating_exception = layout::has_floating_exception(&self.tiling_exceptions, &window);
if should_be_fullscreen { if should_be_fullscreen {
if let Some((surface, state, geometry)) = if let Some((surface, state, _)) = workspace.map_fullscreen(&window, &seat, None, None)
workspace.map_fullscreen(&window, &seat, None, None)
{ {
toplevel_leave_output(&surface, &workspace.output); toplevel_leave_output(&surface, &workspace.output);
toplevel_leave_workspace(&surface, &workspace.handle); toplevel_leave_workspace(&surface, &workspace.handle);
self.remap_unfullscreened_window(surface, state, geometry, loop_handle); self.remap_unfullscreened_window(surface, state, loop_handle);
} }
if was_activated { if was_activated {
workspace_state.add_workspace_state(&workspace_handle, WState::Urgent); workspace_state.add_workspace_state(&workspace_handle, WState::Urgent);
@ -3130,20 +3132,13 @@ impl Shell {
); );
mapped.into() mapped.into()
} else if let WorkspaceRestoreData::Fullscreen(previous) = window_state { } else if let WorkspaceRestoreData::Fullscreen(previous) = window_state {
if let Some((old_surface, previous_state, previous_geometry)) = to_workspace if let Some((old_surface, previous_state, _)) = to_workspace.map_fullscreen(
.map_fullscreen( window,
window, None,
None, previous.clone().map(|p| p.previous_state),
previous.clone().map(|p| p.previous_state), previous.map(|p| p.previous_geometry),
previous.map(|p| p.previous_geometry), ) {
) self.remap_unfullscreened_window(old_surface, previous_state, evlh);
{
self.remap_unfullscreened_window(
old_surface,
previous_state,
previous_geometry,
evlh,
);
} }
window.clone().into() window.clone().into()
} else { } else {
@ -3421,8 +3416,8 @@ impl Shell {
.find(|w| w.get_fullscreen().is_some_and(|s| s == surface)); .find(|w| w.get_fullscreen().is_some_and(|s| s == surface));
if let Some(workspace) = maybe_fullscreen_workspace { if let Some(workspace) = maybe_fullscreen_workspace {
element_geo = Some(workspace.fullscreen_geometry().unwrap()); element_geo = Some(workspace.fullscreen_geometry().unwrap());
let (surface, state, original_geometry) = workspace.remove_fullscreen().unwrap(); let (surface, state, _) = workspace.remove_fullscreen().unwrap();
self.remap_unfullscreened_window(surface, state, original_geometry, evlh); self.remap_unfullscreened_window(surface, state, evlh);
}; };
let old_mapped = self.element_for_surface(surface).cloned()?; let old_mapped = self.element_for_surface(surface).cloned()?;
@ -4060,11 +4055,10 @@ impl Shell {
window.mapped().unwrap().set_active(surface); window.mapped().unwrap().set_active(surface);
} }
let from = minimize_rectangle(workspace.output(), &window.active_window()); let from = minimize_rectangle(workspace.output(), &window.active_window());
if let Some((surface, restore, previous_geo)) = workspace.unminimize(window, from, seat) if let Some((surface, restore, _)) = workspace.unminimize(window, from, seat) {
{
toplevel_leave_output(&surface, &workspace.output); toplevel_leave_output(&surface, &workspace.output);
toplevel_leave_workspace(&surface, &workspace.handle); toplevel_leave_workspace(&surface, &workspace.handle);
self.remap_unfullscreened_window(surface, restore, previous_geo, loop_handle); self.remap_unfullscreened_window(surface, restore, loop_handle);
} }
} }
} }
@ -4579,8 +4573,8 @@ impl Shell {
return None; return None;
}; };
if let Some((old_fullscreen, restore, previous_geo)) = old_fullscreen { if let Some((old_fullscreen, restore, _)) = old_fullscreen {
self.remap_unfullscreened_window(old_fullscreen, restore, previous_geo, &loop_handle); self.remap_unfullscreened_window(old_fullscreen, restore, &loop_handle);
} }
Some(KeyboardFocusTarget::Fullscreen(window)) Some(KeyboardFocusTarget::Fullscreen(window))
@ -4601,11 +4595,11 @@ impl Shell {
}); });
if let Some(workspace) = maybe_workspace { if let Some(workspace) = maybe_workspace {
let (old_fullscreen, restore, previous_geo) = workspace.remove_fullscreen().unwrap(); let (old_fullscreen, restore, _) = workspace.remove_fullscreen().unwrap();
toplevel_leave_output(&old_fullscreen, &workspace.output); toplevel_leave_output(&old_fullscreen, &workspace.output);
toplevel_leave_workspace(&old_fullscreen, &workspace.handle); toplevel_leave_workspace(&old_fullscreen, &workspace.handle);
self.remap_unfullscreened_window(old_fullscreen, restore, previous_geo, loop_handle); self.remap_unfullscreened_window(old_fullscreen, restore, loop_handle);
true true
} else { } else {