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

chore: manual clippy

Browse source
This commit is contained in:
Vukašin Vojinović 2025-10-16 15:46:54 +02:00 • committed by Victoria Brekenfeld
parent 0847247c33
commit 5e9ea93819
20 changed files with 253 additions and 291 deletions
Download patch file Download diff file Expand all files Collapse all files

14
src/shell/element/mod.rs
View file

@ -241,7 +241,9 @@ impl CosmicMapped {
}
pub fn focus_window(&self, window: &CosmicSurface) {
if let CosmicMappedInternal::Stack(stack) = &self.element { stack.set_active(window) }
if let CosmicMappedInternal::Stack(stack) = &self.element {
stack.set_active(window)
}
}
pub fn has_surface(&self, surface: &WlSurface, surface_type: WindowSurfaceType) -> bool {
@ -480,17 +482,11 @@ impl CosmicMapped {
}
pub fn is_window(&self) -> bool {
match &self.element {
CosmicMappedInternal::Window(_) => true,
_ => false,
}
matches!(&self.element, CosmicMappedInternal::Window(_))
}
pub fn is_stack(&self) -> bool {
match &self.element {
CosmicMappedInternal::Stack(_) => true,
_ => false,
}
matches!(&self.element, CosmicMappedInternal::Stack(_))
}
pub fn stack_ref(&self) -> Option<&CosmicStack> {

16
src/shell/element/stack.rs
View file

@ -544,12 +544,8 @@ impl CosmicStack {
}
pub fn pending_size(&self) -> Option<Size<i32, Logical>> {
self.0.with_program(|p| {
(*p.geometry
.lock()
.unwrap())
.map(|geo| geo.size.as_logical())
})
self.0
.with_program(|p| (*p.geometry.lock().unwrap()).map(|geo| geo.size.as_logical()))
}
pub fn set_geometry(&self, geo: Rectangle<i32, Global>) {
@ -1465,11 +1461,15 @@ impl PointerTarget<State> for CosmicStack {
}
fn axis(&self, seat: &Seat<State>, data: &mut State, frame: AxisFrame) {
if let Some(Focus::Header) = self.0.with_program(|p| p.current_focus()) { PointerTarget::axis(&self.0, seat, data, frame) }
if let Some(Focus::Header) = self.0.with_program(|p| p.current_focus()) {
PointerTarget::axis(&self.0, seat, data, frame)
}
}
fn frame(&self, seat: &Seat<State>, data: &mut State) {
if let Some(Focus::Header) = self.0.with_program(|p| p.current_focus()) { PointerTarget::frame(&self.0, seat, data) }
if let Some(Focus::Header) = self.0.with_program(|p| p.current_focus()) {
PointerTarget::frame(&self.0, seat, data)
}
}
fn leave(&self, seat: &Seat<State>, data: &mut State, serial: Serial, time: u32) {

5
src/shell/element/surface.rs
View file

@ -93,7 +93,7 @@ impl PartialEq<ToplevelSurface> for CosmicSurface {
impl PartialEq<X11Surface> for CosmicSurface {
fn eq(&self, other: &X11Surface) -> bool {
self.x11_surface().map_or(false, |s| s == other)
self.x11_surface() == Some(other)
}
}
@ -278,8 +278,7 @@ impl CosmicSurface {
match self.0.underlying_surface() {
WindowSurface::Wayland(toplevel) => {
if enable {
let previous_decoration_state =
toplevel.current_state().decoration_mode;
let previous_decoration_state = toplevel.current_state().decoration_mode;
if PreferredDecorationMode::is_unset(&self.0) {
PreferredDecorationMode::update(&self.0, previous_decoration_state);
}

21
src/shell/focus/mod.rs
View file

@ -200,14 +200,12 @@ impl Shell {
let workspace = target
.wl_surface()
.and_then(|surface| self.workspace_for_surface(&surface));
let workspace = if workspace.is_none() {
let workspace = if let Some(workspace) = workspace {
self.workspaces.space_for_handle_mut(&workspace.0).unwrap()
} else {
//should this be the active output or the focused output?
self.active_space_mut(&seat.focused_or_active_output())
.unwrap()
} else {
self.workspaces
.space_for_handle_mut(&workspace.unwrap().0)
.unwrap()
};
let mut focus_stack = workspace.focus_stack.get_mut(seat);
@ -329,7 +327,10 @@ fn update_focus_state(
) {
// update keyboard focus
if let Some(keyboard) = seat.get_keyboard() {
if should_update_cursor && state.common.config.cosmic_conf.cursor_follows_focus && target.is_some() {
if should_update_cursor
&& state.common.config.cosmic_conf.cursor_follows_focus
&& target.is_some()
{
//need to borrow mutably for surface under
let shell = state.common.shell.read();
// get the top left corner of the target element
@ -681,8 +682,8 @@ fn update_pointer_focus(state: &mut State, seat: &Seat<State>) {
let output = seat.active_output();
let position = pointer.current_location().as_global();
let mut shell = state.common.shell.write();
let under = State::surface_under(position, &output, &mut shell)
let shell = state.common.shell.write();
let under = State::surface_under(position, &output, &shell)
.map(|(target, pos)| (target, pos.as_logical()));
drop(shell);
@ -707,7 +708,9 @@ fn exclusive_layer_surface_layer(shell: &Shell) -> Option<Layer> {
for output in shell.outputs() {
for layer_surface in layer_map_for_output(output).layers() {
let data = layer_surface.cached_state();
if data.keyboard_interactivity == KeyboardInteractivity::Exclusive && data.layer as u32 >= layer.unwrap_or(Layer::Top) as u32 {
if data.keyboard_interactivity == KeyboardInteractivity::Exclusive
&& data.layer as u32 >= layer.unwrap_or(Layer::Top) as u32
{
layer = Some(data.layer);
}
}

16
src/shell/layout/floating/grabs/resize.rs
View file

@ -108,7 +108,9 @@ impl ResizeSurfaceGrab {
+ self.initial_window_location.x;
}
} else if (self.initial_window_location.x + self.initial_window_size.w + dx as i32
- output_geom.loc.x - output_geom.size.w).unsigned_abs()
- output_geom.loc.x
- output_geom.size.w)
.unsigned_abs()
< self.edge_snap_threshold
{
new_window_width =
@ -134,7 +136,9 @@ impl ResizeSurfaceGrab {
+ self.initial_window_location.y;
}
} else if (self.initial_window_location.y + self.initial_window_size.h + dy as i32
- output_geom.loc.y - output_geom.size.h).unsigned_abs()
- output_geom.loc.y
- output_geom.size.h)
.unsigned_abs()
< self.edge_snap_threshold
{
new_window_height =
@ -146,8 +150,8 @@ impl ResizeSurfaceGrab {
let min_width = min_size.map(|s| s.w).unwrap_or(360);
let min_height = min_size.map(|s| s.h).unwrap_or(240);
let max_width = max_size.map(|s| s.w).unwrap_or(i32::max_value());
let max_height = max_size.map(|s| s.h).unwrap_or(i32::max_value());
let max_width = max_size.map(|s| s.w).unwrap_or(i32::MAX);
let max_height = max_size.map(|s| s.h).unwrap_or(i32::MAX);
new_window_width = new_window_width.max(min_width).min(max_width);
new_window_height = new_window_height.max(min_height).min(max_height);
@ -353,7 +357,9 @@ impl TouchGrab<State> for ResizeSurfaceGrab {
event: &TouchMotionEvent,
seq: Serial,
) {
if event.slot == <Self as TouchGrab<State>>::start_data(self).slot && self.update_location(event.location.as_global()) {
if event.slot == <Self as TouchGrab<State>>::start_data(self).slot
&& self.update_location(event.location.as_global())
{
handle.unset_grab(self, data);
}

58
src/shell/layout/floating/mod.rs
View file

@ -650,10 +650,7 @@ impl FloatingLayout {
window: &CosmicMapped,
to: Option<Rectangle<i32, Local>>,
) -> Option<Rectangle<i32, Local>> {
let Some(mut mapped_geometry) = self.space.element_geometry(window).map(RectExt::as_local)
else {
return None;
};
let mut mapped_geometry = self.space.element_geometry(window).map(RectExt::as_local)?;
let _ = self.animations.remove(window);
if let Some(to) = to {
@ -673,7 +670,7 @@ impl FloatingLayout {
);
}
if let Some(_) = window.floating_tiled.lock().unwrap().take() {
if window.floating_tiled.lock().unwrap().take().is_some() {
if let Some(last_size) = window.last_geometry.lock().unwrap().map(|geo| geo.size) {
let geometry = Rectangle::new(mapped_geometry.loc, last_size);
window.set_tiled(false);
@ -972,8 +969,8 @@ impl FloatingLayout {
let (min_size, max_size) = (mapped.min_size(), mapped.max_size());
let min_width = min_size.map(|s| s.w).unwrap_or(360);
let min_height = min_size.map(|s| s.h).unwrap_or(240);
let max_width = max_size.map(|s| s.w).unwrap_or(i32::max_value());
let max_height = max_size.map(|s| s.h).unwrap_or(i32::max_value());
let max_width = max_size.map(|s| s.w).unwrap_or(i32::MAX);
let max_height = max_size.map(|s| s.h).unwrap_or(i32::MAX);
geo.size.w = min_width.max(geo.size.w).min(max_width);
geo.size.h = min_height.max(geo.size.h).min(max_height);
@ -1313,29 +1310,26 @@ impl FloatingLayout {
let window_geometry = if mapped.is_maximized(false) {
geometry
} else {
prev
.map(|mut rect| {
if let Some(old_size) = old_output_size {
rect = Rectangle::new(
Point::new(
(rect.loc.x as f64 + rect.size.w as f64 / 2.)
/ old_size.w as f64
* output_size.w as f64
- rect.size.w as f64 / 2.,
(rect.loc.y as f64 + rect.size.h as f64 / 2.)
/ old_size.h as f64
* output_size.h as f64
- rect.size.h as f64 / 2.,
),
rect.size.to_f64(),
)
.to_i32_round();
}
Rectangle::new(rect.loc.constrain(geometry), rect.size)
})
.unwrap_or_else(|| {
Rectangle::new(Point::from((0, 0)), mapped.geometry().size.as_local())
})
prev.map(|mut rect| {
if let Some(old_size) = old_output_size {
rect = Rectangle::new(
Point::new(
(rect.loc.x as f64 + rect.size.w as f64 / 2.) / old_size.w as f64
* output_size.w as f64
- rect.size.w as f64 / 2.,
(rect.loc.y as f64 + rect.size.h as f64 / 2.) / old_size.h as f64
* output_size.h as f64
- rect.size.h as f64 / 2.,
),
rect.size.to_f64(),
)
.to_i32_round();
}
Rectangle::new(rect.loc.constrain(geometry), rect.size)
})
.unwrap_or_else(|| {
Rectangle::new(Point::from((0, 0)), mapped.geometry().size.as_local())
})
};
mapped.set_geometry(window_geometry.to_global(&output));
@ -1529,7 +1523,7 @@ impl FloatingLayout {
.to_physical_precise_round(output_scale),
scale,
);
RelocateRenderElement::from_element(
rescaled,
(geometry.loc - original_geo.loc)
@ -1549,7 +1543,7 @@ impl FloatingLayout {
.to_physical_precise_round(output_scale),
scale,
);
RelocateRenderElement::from_element(
rescaled,
(geometry.loc - original_geo.loc)

115
src/shell/layout/tiling/mod.rs
View file

@ -202,10 +202,7 @@ impl Data {
}
}
fn is_placeholder(&self) -> bool {
match self {
Data::Placeholder { .. } => true,
_ => false,
}
matches!(self, Data::Placeholder { .. })
}
fn orientation(&self) -> Orientation {
@ -409,7 +406,7 @@ impl TilingLayout {
let mut tree = self.queue.trees.back().unwrap().0.copy_clone();
let last_active = focus_stack
.and_then(|focus_stack| TilingLayout::last_active_window(&mut tree, focus_stack))
.and_then(|focus_stack| TilingLayout::last_active_window(&tree, focus_stack))
.map(|(node_id, _)| node_id);
let duration = if minimize_rect.is_some() {
MINIMIZE_ANIMATION_DURATION
@ -1502,7 +1499,7 @@ impl TilingLayout {
let Some(target) = seat.get_keyboard().unwrap().current_focus() else {
return MoveResult::None;
};
let Some((node_id, data)) = TilingLayout::currently_focused_node(&mut tree, target) else {
let Some((node_id, data)) = TilingLayout::currently_focused_node(&tree, target) else {
return MoveResult::None;
};
@ -1734,7 +1731,8 @@ impl TilingLayout {
// we move again by making a new fork
let old_id = tree
.children_ids(&next_child_id)
.unwrap().nth(group_len / 2)
.unwrap()
.nth(group_len / 2)
.unwrap()
.clone();
TilingLayout::new_group(
@ -2122,11 +2120,7 @@ impl TilingLayout {
mut focus_stack: FocusStackMut,
) -> Option<KeyboardFocusTarget> {
let gaps = self.gaps();
let Some(node_id) = mapped.tiling_node_id.lock().unwrap().clone() else {
return None;
};
let node_id = mapped.tiling_node_id.lock().unwrap().clone()?;
let mut tree = self.queue.trees.back().unwrap().0.copy_clone();
if tree.get(&node_id).is_err() {
return None;
@ -2239,11 +2233,7 @@ impl TilingLayout {
mut focus_stack: FocusStackMut,
) -> Option<KeyboardFocusTarget> {
let gaps = self.gaps();
let Some(target) = seat.get_keyboard().unwrap().current_focus() else {
return None;
};
let target = seat.get_keyboard().unwrap().current_focus()?;
let mut tree = self.queue.trees.back().unwrap().0.copy_clone();
if let Some((last_active, last_active_data)) =
TilingLayout::currently_focused_node(&tree, target)
@ -2974,9 +2964,7 @@ impl TilingLayout {
let mut configures = Vec::new();
let (outer, inner) = gaps;
let mut geo = layer_map_for_output(output)
.non_exclusive_zone()
.as_local();
let mut geo = layer_map_for_output(output).non_exclusive_zone().as_local();
geo.loc.x += outer;
geo.loc.y += outer;
geo.size.w -= outer * 2;
@ -3308,7 +3296,8 @@ impl TilingLayout {
(last_geometry.loc
+ tree
.children(&id)
.unwrap().nth(idx)
.unwrap()
.nth(idx)
.map(|node| {
let geo = node.data().geometry();
geo.loc + geo.size
@ -3634,12 +3623,14 @@ impl TilingLayout {
None,
tree.traverse_pre_order_ids(root)
.unwrap()
.find(|id| match tree.get(id).unwrap().data() {
Data::Placeholder {
type_: PlaceholderType::GrabbedWindow,
..
} => true,
_ => false,
.find(|id| {
matches!(
tree.get(id).unwrap().data(),
Data::Placeholder {
type_: PlaceholderType::GrabbedWindow,
..
}
)
})
.map(TargetZone::InitialPlaceholder)
.unwrap_or(TargetZone::Initial),
@ -3817,38 +3808,40 @@ impl TilingLayout {
pub fn mapped(&self) -> impl Iterator<Item = (&CosmicMapped, Rectangle<i32, Local>)> {
let tree = &self.queue.trees.back().unwrap().0;
let iter = tree.root_node_id().map(|root| tree.traverse_pre_order(root)
.unwrap()
.filter(|node| node.data().is_mapped(None))
.filter(|node| match node.data() {
Data::Mapped { mapped, .. } => mapped.is_activated(false),
_ => unreachable!(),
})
.map(|node| match node.data() {
Data::Mapped {
mapped,
last_geometry,
..
} => (mapped, *last_geometry),
_ => unreachable!(),
})
.chain(
tree.traverse_pre_order(root)
.unwrap()
.filter(|node| node.data().is_mapped(None))
.filter(|node| match node.data() {
Data::Mapped { mapped, .. } => !mapped.is_activated(false),
_ => unreachable!(),
})
.map(|node| match node.data() {
Data::Mapped {
mapped,
last_geometry,
..
} => (mapped, *last_geometry),
_ => unreachable!(),
}),
));
let iter = tree.root_node_id().map(|root| {
tree.traverse_pre_order(root)
.unwrap()
.filter(|node| node.data().is_mapped(None))
.filter(|node| match node.data() {
Data::Mapped { mapped, .. } => mapped.is_activated(false),
_ => unreachable!(),
})
.map(|node| match node.data() {
Data::Mapped {
mapped,
last_geometry,
..
} => (mapped, *last_geometry),
_ => unreachable!(),
})
.chain(
tree.traverse_pre_order(root)
.unwrap()
.filter(|node| node.data().is_mapped(None))
.filter(|node| match node.data() {
Data::Mapped { mapped, .. } => !mapped.is_activated(false),
_ => unreachable!(),
})
.map(|node| match node.data() {
Data::Mapped {
mapped,
last_geometry,
..
} => (mapped, *last_geometry),
_ => unreachable!(),
}),
)
});
iter.into_iter().flatten()
}
@ -4317,7 +4310,9 @@ where
.and_then(|target| TilingLayout::currently_focused_node(tree, target))
})
.map(|(id, _)| id);
let focused_geo = focused.as_ref().map(|focused_id| *tree.get(focused_id).unwrap().data().geometry());
let focused_geo = focused
.as_ref()
.map(|focused_id| *tree.get(focused_id).unwrap().data().geometry());
let has_potential_groups = if let Some(focused_id) = focused.as_ref() {
let focused_node = tree.get(focused_id).unwrap();

146
src/shell/mod.rs
View file

@ -591,7 +591,8 @@ impl WorkspaceSet {
// add empty at the end, if necessary
if self
.workspaces
.last().is_none_or(|last| !last.is_empty() || last.pinned)
.last()
.is_none_or(|last| !last.is_empty() || last.pinned)
{
self.add_empty_workspace(state);
}
@ -606,7 +607,8 @@ impl WorkspaceSet {
let previous_is_empty = i > 0
&& self
.workspaces
.get(i - 1).is_some_and(|w| w.is_empty() && !w.pinned);
.get(i - 1)
.is_some_and(|w| w.is_empty() && !w.pinned);
let keep = if workspace.can_auto_remove(xdg_activation_state) {
// Keep empty workspace if it's active, or it's the last workspace,
// and the previous worspace is not both active and empty.
@ -1605,32 +1607,21 @@ impl Shell {
) {
set.workspaces[set.active].tiling_layer.cleanup_drag();
}
if let Some((_, workspace_delta)) = set.previously_active {
match workspace_delta {
WorkspaceDelta::Gesture(delta) => {
if (velocity > 0.0 && velocity.abs() >= GESTURE_VELOCITY_THRESHOLD)
|| (velocity.abs() < GESTURE_VELOCITY_THRESHOLD
&& delta.abs() > GESTURE_POSITION_THRESHOLD)
{
set.activate(
set.active,
WorkspaceDelta::new_gesture_end(
delta.abs(),
velocity.abs(),
),
workspace_state,
)?;
} else {
set.activate_previous(
WorkspaceDelta::new_gesture_end(
1.0 - delta.abs(),
velocity.abs(),
),
workspace_state,
)?;
}
}
_ => {} // Do nothing
if let Some((_, WorkspaceDelta::Gesture(delta))) = set.previously_active {
if (velocity > 0.0 && velocity.abs() >= GESTURE_VELOCITY_THRESHOLD)
|| (velocity.abs() < GESTURE_VELOCITY_THRESHOLD
&& delta.abs() > GESTURE_POSITION_THRESHOLD)
{
set.activate(
set.active,
WorkspaceDelta::new_gesture_end(delta.abs(), velocity.abs()),
workspace_state,
)?;
} else {
set.activate_previous(
WorkspaceDelta::new_gesture_end(1.0 - delta.abs(), velocity.abs()),
workspace_state,
)?;
}
}
@ -1645,32 +1636,21 @@ impl Shell {
}
WorkspaceMode::Global => {
for set in self.workspaces.sets.values_mut() {
if let Some((_, workspace_delta)) = set.previously_active {
match workspace_delta {
WorkspaceDelta::Gesture(delta) => {
if (velocity > 0.0 && velocity.abs() >= GESTURE_VELOCITY_THRESHOLD)
|| (velocity.abs() < GESTURE_VELOCITY_THRESHOLD
&& delta.abs() > GESTURE_POSITION_THRESHOLD)
{
set.activate(
set.active,
WorkspaceDelta::new_gesture_end(
delta.abs(),
velocity.abs(),
),
workspace_state,
)?;
} else {
set.activate_previous(
WorkspaceDelta::new_gesture_end(
1.0 - delta.abs(),
velocity.abs(),
),
workspace_state,
)?;
}
}
_ => {} // Do nothing
if let Some((_, WorkspaceDelta::Gesture(delta))) = set.previously_active {
if (velocity > 0.0 && velocity.abs() >= GESTURE_VELOCITY_THRESHOLD)
|| (velocity.abs() < GESTURE_VELOCITY_THRESHOLD
&& delta.abs() > GESTURE_POSITION_THRESHOLD)
{
set.activate(
set.active,
WorkspaceDelta::new_gesture_end(delta.abs(), velocity.abs()),
workspace_state,
)?;
} else {
set.activate_previous(
WorkspaceDelta::new_gesture_end(1.0 - delta.abs(), velocity.abs()),
workspace_state,
)?;
}
}
}
@ -2141,8 +2121,7 @@ impl Shell {
} else {
(Duration::ZERO, self.overview_mode.active_trigger().cloned())
};
self.overview_mode =
OverviewMode::Ended(trigger, Instant::now() - reverse_duration);
self.overview_mode = OverviewMode::Ended(trigger, Instant::now() - reverse_duration);
}
}
@ -2878,7 +2857,6 @@ impl Shell {
}
}
#[must_use]
pub fn move_current(
&mut self,
seat: &Seat<State>,
@ -3061,17 +3039,13 @@ impl Shell {
}
// update fullscreen state to restore to the new workspace
if let WorkspaceRestoreData::Fullscreen(Some(FullscreenRestoreData {
previous_state,
previous_state:
FullscreenRestoreState::Tiling { workspace, .. }
| FullscreenRestoreState::Floating { workspace, .. },
..
})) = &mut window_state
{
match previous_state {
FullscreenRestoreState::Tiling { workspace, .. }
| FullscreenRestoreState::Floating { workspace, .. } => {
*workspace = *to;
}
_ => {}
}
*workspace = *to;
}
for mapped in from_workspace
@ -3531,7 +3505,11 @@ impl Shell {
.tiling_layer
.mapped()
.any(|(m, _)| m == &old_mapped)
} { ManagedLayer::Tiling } else { ManagedLayer::Floating };
} {
ManagedLayer::Tiling
} else {
ManagedLayer::Floating
};
// if this changed the width, the window was tiled in floating mode
if let Some(new_size) = new_size {
@ -3834,11 +3812,7 @@ impl Shell {
}
#[must_use]
pub fn move_current_element<'a>(
&mut self,
direction: Direction,
seat: &Seat<State>,
) -> MoveResult {
pub fn move_current_element(&mut self, direction: Direction, seat: &Seat<State>) -> MoveResult {
let Some(output) = seat.focused_output() else {
return MoveResult::None;
};
@ -4017,17 +3991,19 @@ impl Shell {
was_maximized: false,
},
});
} else if let Some((workspace, window)) = self.workspaces.sets.values_mut().find_map(|set| {
set.workspaces.iter_mut().find_map(|workspace| {
let window = workspace
.get_fullscreen()
.cloned()
.into_iter()
.chain(workspace.mapped().map(|m| m.active_window()))
.find(|s| s == surface);
window.map(|s| (workspace, s))
} else if let Some((workspace, window)) =
self.workspaces.sets.values_mut().find_map(|set| {
set.workspaces.iter_mut().find_map(|workspace| {
let window = workspace
.get_fullscreen()
.cloned()
.into_iter()
.chain(workspace.mapped().map(|m| m.active_window()))
.find(|s| s == surface);
window.map(|s| (workspace, s))
})
})
}) {
{
let to = minimize_rectangle(workspace.output(), &window);
if let Some(minimized) = workspace.minimize(surface, to) {
workspace.minimized_windows.push(minimized);
@ -4333,9 +4309,7 @@ impl Shell {
seat: &Seat<State>,
loop_handle: &LoopHandle<'static, State>,
) -> Option<KeyboardFocusTarget> {
let Some(focused_output) = seat.focused_output() else {
return None;
};
let focused_output = seat.focused_output()?;
let set = self.workspaces.sets.get_mut(&focused_output).unwrap();
let workspace = &mut set.workspaces[set.active];
@ -4507,9 +4481,7 @@ impl Shell {
where
CosmicSurface: PartialEq<S>,
{
let Some(mapped) = self.element_for_surface(surface).cloned() else {
return None;
};
let mapped = self.element_for_surface(surface).cloned()?;
let window;
let old_fullscreen = if let Some((old_output, set)) = self

15
src/shell/workspace.rs
View file

@ -610,8 +610,7 @@ impl Workspace {
// unmaximize_request might have triggered a `floating_layer.refresh()`,
// which may have already removed a non-alive surface.
if let Some(floating_geometry) = self.floating_layer.unmap(mapped, None).or(was_maximized)
{
if let Some(floating_geometry) = self.floating_layer.unmap(mapped, None).or(was_maximized) {
return Some(WorkspaceRestoreData::Floating(Some(FloatingRestoreData {
geometry: floating_geometry,
output_size: self.output.geometry().size.as_logical(),
@ -659,16 +658,16 @@ impl Workspace {
return Some((surface, WorkspaceRestoreData::Fullscreen(previous)));
}
let Some(mapped) = self.element_for_surface(surface) else {
return None;
};
let mapped = self.element_for_surface(surface)?;
let maybe_stack = mapped.stack_ref().filter(|s| s.len() > 1);
if let Some(stack) = maybe_stack {
if stack.len() > 1 {
let idx = stack.surfaces().position(|s| &s == surface);
let layer = if self
.is_tiled(surface) { ManagedLayer::Tiling } else { ManagedLayer::Floating };
let layer = if self.is_tiled(surface) {
ManagedLayer::Tiling
} else {
ManagedLayer::Floating
};
return idx
.and_then(|idx| stack.remove_idx(idx))
.map(|s| (s, layer.into()));