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

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