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

chore: clippy

Browse source
This commit is contained in:
Vukašin Vojinović 2025-10-16 13:50:32 +02:00 • committed by Victoria Brekenfeld
parent 3b70bc0265
commit 0847247c33
77 changed files with 865 additions and 1029 deletions
Download patch file Download diff file Expand all files Collapse all files

28
src/backend/kms/device.rs
View file

@ -186,8 +186,7 @@ impl State {
if let Ok(node) = DrmNode::from_dev_id(dev) {
let node = node
.node_with_type(NodeType::Render)
.map(|res| res.ok())
.flatten()
.and_then(|res| res.ok())
.unwrap_or(node);
for ident in allowlist {
if ident.matches(&node) {
@ -208,8 +207,7 @@ impl State {
if let Ok(node) = DrmNode::from_dev_id(dev) {
let node = node
.node_with_type(NodeType::Render)
.map(|res| res.ok())
.flatten()
.and_then(|res| res.ok())
.unwrap_or(node);
for ident in blocklist {
if ident.matches(&node) {
@ -228,7 +226,7 @@ impl State {
.kms()
.session
.open(
&path,
path,
OFlags::RDWR | OFlags::CLOEXEC | OFlags::NOCTTY | OFlags::NONBLOCK,
)
.with_context(|| {
@ -595,7 +593,7 @@ impl Device {
let added = config
.iter()
.filter(|(conn, maybe)| match (surfaces.get(&conn), maybe) {
.filter(|(conn, maybe)| match (surfaces.get(conn), maybe) {
(Some(current_crtc), Some(new_crtc)) => current_crtc != new_crtc,
// see `removed`
(Some(_), None) => true,
@ -610,10 +608,10 @@ impl Device {
.outputs
.iter()
.filter(|(conn, _)| match config.get(conn) {
Some(Some(c)) => surfaces.get(&conn).is_some_and(|crtc| c != crtc),
Some(Some(c)) => surfaces.get(conn).is_some_and(|crtc| c != crtc),
// if don't have a crtc, we need to drop the surface if it exists.
// so it needs to be in both `removed` AND `added`.
Some(None) => surfaces.get(&conn).is_some(),
Some(None) => surfaces.get(conn).is_some(),
_ => true,
})
.map(|(conn, _)| *conn)
@ -630,7 +628,7 @@ impl Device {
}
}
impl<'a> LockedDevice<'a> {
impl LockedDevice<'_> {
fn allow_frame_flags(
&mut self,
flag: bool,
@ -660,7 +658,7 @@ impl<'a> LockedDevice<'a> {
renderer,
shell,
now,
&output,
output,
CursorMode::All,
None,
)
@ -759,7 +757,7 @@ impl InnerDevice {
.outputs
.get(&conn)
.cloned()
.map(|output| Ok(output))
.map(Ok)
.unwrap_or_else(|| create_output_for_conn(drm, conn))
.context("Failed to create `Output`")?;
@ -895,7 +893,7 @@ impl InnerDevice {
{
for surface in self.surfaces.values_mut() {
let known_nodes = surface.known_nodes().clone();
for gone_device in known_nodes.difference(&used_devices) {
for gone_device in known_nodes.difference(used_devices) {
surface.remove_node(*gone_device);
}
for new_device in used_devices.difference(&known_nodes) {
@ -993,7 +991,7 @@ fn populate_modes(
.iter()
.find(|mode| mode.mode_type().contains(ModeTypeFlags::PREFERRED))
.copied()
.or(conn_info.modes().get(0).copied())
.or(conn_info.modes().first().copied())
else {
anyhow::bail!("No mode found");
};
@ -1011,13 +1009,13 @@ fn populate_modes(
size: (mode.size().0 as i32, mode.size().1 as i32).into(),
refresh: refresh_rate as i32,
};
modes.push(mode.clone());
modes.push(mode);
output.add_mode(mode);
}
for mode in output
.modes()
.into_iter()
.filter(|mode| !modes.contains(&mode))
.filter(|mode| !modes.contains(mode))
{
output.delete_mode(mode);
}

2
src/backend/kms/drm_helpers.rs
View file

@ -82,7 +82,7 @@ pub fn display_configuration(
.flat_map(|conn| device.get_connector(*conn, false).ok())
.filter(|conn| {
if let Some(enc) = conn.current_encoder() {
if let Some(enc) = device.get_encoder(enc).ok() {
if let Ok(enc) = device.get_encoder(enc) {
if let Some(crtc) = enc.crtc() {
return cleanup.contains(&crtc);
}

28
src/backend/kms/mod.rs
View file

@ -135,7 +135,7 @@ pub fn init_backend(
// manually add already present gpus
let mut outputs = Vec::new();
for (dev, path) in udev_dispatcher.as_source_ref().device_list() {
match state.device_added(dev, path.into(), dh) {
match state.device_added(dev, path, dh) {
Ok(added) => outputs.extend(added),
Err(err) => warn!("Failed to add device {}: {:?}", path.display(), err),
}
@ -169,7 +169,7 @@ pub fn init_backend(
}
// start x11
let primary = state.backend.kms().primary_node.read().unwrap().clone();
let primary = *state.backend.kms().primary_node.read().unwrap();
state.launch_xwayland(primary);
Ok(())
@ -209,7 +209,7 @@ fn init_libinput(
.context("Failed to initialize libinput event source")?;
// Create relative pointer global
RelativePointerManagerState::new::<State>(&dh);
RelativePointerManagerState::new::<State>(dh);
Ok(libinput_context)
}
@ -239,7 +239,7 @@ fn determine_primary_gpu(
// try to find builtin display
for dev in drm_devices.values() {
if dev.inner.surfaces.values().any(|s| {
if let Some(conn_info) = dev.drm.device().get_connector(s.connector, false).ok() {
if let Ok(conn_info) = dev.drm.device().get_connector(s.connector, false) {
let i = conn_info.interface();
i == Interface::EmbeddedDisplayPort || i == Interface::LVDS || i == Interface::DSI
} else {
@ -392,7 +392,7 @@ impl State {
}
} else {
let dh = state.common.display_handle.clone();
match state.device_added(dev, path.into(), &dh) {
match state.device_added(dev, path, &dh) {
Ok(outputs) => added.extend(outputs),
Err(err) => error!(?err, "Failed to add drm device {}.", path.display(),),
}
@ -465,7 +465,7 @@ impl KmsState {
if let Some(state) = self.syncobj_state.as_mut() {
state.update_device(import_device);
} else {
let syncobj_state = DrmSyncobjState::new::<State>(&dh, import_device);
let syncobj_state = DrmSyncobjState::new::<State>(dh, import_device);
self.syncobj_state = Some(syncobj_state);
}
return Ok(());
@ -646,7 +646,7 @@ impl KmsState {
}
}
impl<'a> KmsGuard<'a> {
impl KmsGuard<'_> {
pub fn schedule_render(&mut self, output: &Output) {
for surface in self
.drm_devices
@ -755,7 +755,7 @@ impl<'a> KmsGuard<'a> {
.crtcs()
.iter()
.filter(|crtc| {
!device.inner.surfaces.get(crtc).is_some()
device.inner.surfaces.get(crtc).is_none()
// TODO: We can't do this. See https://github.com/Smithay/smithay/pull/1820
//.is_some_and(|surface| surface.output.is_enabled())
})
@ -915,7 +915,7 @@ impl<'a> KmsGuard<'a> {
&mut renderer,
&shell,
now,
&output,
output,
CursorMode::All,
None,
)
@ -1024,7 +1024,7 @@ impl<'a> KmsGuard<'a> {
&mut renderer,
&shell,
now,
&output,
output,
CursorMode::All,
None,
)
@ -1068,7 +1068,7 @@ impl<'a> KmsGuard<'a> {
&mut renderer,
&shell,
now,
&output,
output,
CursorMode::All,
None,
)
@ -1103,10 +1103,8 @@ impl<'a> KmsGuard<'a> {
None
};
if !test_only {
if mirrored_output != surface.output.mirroring() {
surface.set_mirroring(mirrored_output.clone());
}
if !test_only && mirrored_output != surface.output.mirroring() {
surface.set_mirroring(mirrored_output.clone());
}
}
}

6
src/backend/kms/render/pixman.rs
View file

@ -42,6 +42,12 @@ impl fmt::Debug for GbmPixmanDevice {
}
}
impl<A: AsFd + 'static> Default for GbmPixmanBackend<A> {
fn default() -> Self {
Self::new()
}
}
impl<A: AsFd + 'static> GbmPixmanBackend<A> {
pub fn new() -> Self {
GbmPixmanBackend {

37
src/backend/kms/surface/mod.rs
View file

@ -181,15 +181,14 @@ pub type GbmDrmOutput = DrmOutput<
DrmDeviceFd,
>;
#[derive(Debug)]
#[derive(Debug, Default)]
pub enum QueueState {
#[default]
Idle,
/// A redraw is queued.
Queued(RegistrationToken),
/// We submitted a frame to the KMS and waiting for it to be presented.
WaitingForVBlank {
redraw_needed: bool,
},
WaitingForVBlank { redraw_needed: bool },
/// We did not submit anything to KMS and made a timer to fire at the estimated VBlank.
WaitingForEstimatedVBlank(RegistrationToken),
/// A redraw is queued on top of the above.
@ -199,12 +198,6 @@ pub enum QueueState {
},
}
impl Default for QueueState {
fn default() -> Self {
QueueState::Idle
}
}
#[derive(Debug)]
pub enum ThreadCommand {
Suspend(SyncSender<()>),
@ -760,7 +753,7 @@ impl SurfaceThreadState {
let now = self.clock.now();
let presentation_time = match metadata.as_ref().map(|data| &data.time) {
Some(DrmEventTime::Monotonic(tp)) => Some(tp.clone()),
Some(DrmEventTime::Monotonic(tp)) => Some(*tp),
_ => None,
};
let sequence = metadata.as_ref().map(|data| data.sequence).unwrap_or(0);
@ -944,7 +937,7 @@ impl SurfaceThreadState {
warn!(?name, "Failed to submit rendering: {:?}", err);
state.queue_redraw(true);
}
return TimeoutAction::Drop;
TimeoutAction::Drop
})
.expect("Failed to schedule render");
@ -954,7 +947,7 @@ impl SurfaceThreadState {
}
QueueState::WaitingForEstimatedVBlank(estimated_vblank) => {
self.state = QueueState::WaitingForEstimatedVBlankAndQueued {
estimated_vblank: estimated_vblank.clone(),
estimated_vblank: *estimated_vblank,
queued_render: token,
};
}
@ -968,7 +961,7 @@ impl SurfaceThreadState {
} if force => {
self.loop_handle.remove(*queued_render);
self.state = QueueState::WaitingForEstimatedVBlankAndQueued {
estimated_vblank: estimated_vblank.clone(),
estimated_vblank: *estimated_vblank,
queued_render: token,
};
}
@ -990,7 +983,7 @@ impl SurfaceThreadState {
.as_ref()
.unwrap_or(&self.target_node),
&self.target_node,
&*self.shell.read(),
&self.shell.read(),
);
let mut renderer = if render_node != self.target_node {
@ -1016,7 +1009,7 @@ impl SurfaceThreadState {
(
true,
fullscreen_surface.wl_surface().is_some_and(|surface| {
recursive_frame_time_estimation(&self.clock, &*surface)
recursive_frame_time_estimation(&self.clock, &surface)
.is_some_and(|dur| dur <= _30_FPS)
}),
animations_going,
@ -1079,7 +1072,7 @@ impl SurfaceThreadState {
let source_output = self
.mirroring
.as_ref()
.or((!self.screen_filter.is_noop()).then(|| &self.output))
.or((!self.screen_filter.is_noop()).then_some(&self.output))
.filter(|output| {
PostprocessOutputConfig::for_output_untransformed(output)
!= PostprocessOutputConfig::for_output(&self.output)
@ -1258,7 +1251,7 @@ impl SurfaceThreadState {
&mut renderer,
&self.output,
&pre_postprocess_data,
&postprocess_state,
postprocess_state,
&self.screen_filter,
);
@ -1507,7 +1500,7 @@ fn render_node_for_output(
.flat_map(|w| w.wl_surface().and_then(|s| source_node_for_surface(&s)))
.collect::<Vec<_>>();
if nodes.contains(&target_node) || nodes.is_empty() {
if nodes.contains(target_node) || nodes.is_empty() {
*target_node
} else {
*primary_node
@ -1575,7 +1568,7 @@ fn get_surface_dmabuf_feedback(
FormatSet::from_iter(
primary_plane_formats
.into_iter()
.chain(overlay_plane_formats.into_iter()),
.chain(overlay_plane_formats),
),
)
.build()
@ -1648,7 +1641,7 @@ fn take_screencopy_frames(
} else {
damage_tracking.age_for_buffer(&buffer)
};
let res = damage_tracking.dt.damage_output(age, &elements);
let res = damage_tracking.dt.damage_output(age, elements);
if let Some(old_len) = old_len {
elements.truncate(old_len);
@ -1708,7 +1701,7 @@ fn send_screencopy_result<'a>(
.texture
.as_ref()
.is_some_and(|tex| tex.format() == Some(format))
&& (session.draw_cursor() == false || pre_postprocess_data.cursor_texture.is_none())
&& (!session.draw_cursor() || pre_postprocess_data.cursor_texture.is_none())
{
None
} else {

3
src/backend/kms/surface/timings.rs
View file

@ -143,7 +143,6 @@ impl Timings {
Time::elapsed(&frame.render_start, clock.now())
- frame
.render_duration_elements
.clone()
.unwrap_or(Duration::ZERO),
);
}
@ -271,7 +270,7 @@ impl Timings {
}
let secs = match (self.previous_frames.front(), self.previous_frames.back()) {
(Some(Frame { render_start, .. }), Some(end_frame)) => {
Time::elapsed(render_start, end_frame.render_start.clone()) + end_frame.frame_time()
Time::elapsed(render_start, end_frame.render_start) + end_frame.frame_time()
}
_ => {
return 0.0;

2
src/backend/mod.rs
View file

@ -155,7 +155,7 @@ pub fn init_backend_auto(
.startup_done
.store(true, std::sync::atomic::Ordering::SeqCst);
for output in state.common.shell.read().outputs() {
state.backend.schedule_render(&output);
state.backend.schedule_render(output);
}
}
}

6
src/backend/render/cursor.rs
View file

@ -134,7 +134,7 @@ where
R::TextureId: Clone + 'static,
{
let scale = scale.into();
let h = with_states(&surface, |states| {
let h = with_states(surface, |states| {
states
.data_map
.get::<Mutex<CursorImageAttributes>>()
@ -169,7 +169,7 @@ where
R: Renderer + ImportAll,
R::TextureId: Clone + 'static,
{
if get_role(&surface) != Some("dnd_icon") {
if get_role(surface) != Some("dnd_icon") {
warn!(
?surface,
"Trying to display as a dnd icon a surface that does not have the DndIcon role."
@ -320,7 +320,7 @@ where
MemoryRenderBufferRenderElement::from_buffer(
renderer,
location.to_physical(scale),
&pointer_image,
pointer_image,
None,
None,
None,

4
src/backend/render/element.rs
View file

@ -348,7 +348,7 @@ impl AsGlowRenderer for GlowRenderer {
}
}
impl<'a> AsGlowRenderer for GlMultiRenderer<'a> {
impl AsGlowRenderer for GlMultiRenderer<'_> {
fn glow_renderer(&self) -> &GlowRenderer {
self.as_ref()
}
@ -403,7 +403,7 @@ impl Element for DamageElement {
scale: Scale<f64>,
_commit: Option<CommitCounter>,
) -> DamageSet<i32, Physical> {
DamageSet::from_slice(&[Rectangle::from_size(self.geometry(scale).size).into()])
DamageSet::from_slice(&[Rectangle::from_size(self.geometry(scale).size)])
}
}

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

@ -93,7 +93,7 @@ pub enum RendererRef<'a> {
GlMulti(GlMultiRenderer<'a>),
}
impl<'a> AsRef<GlowRenderer> for RendererRef<'a> {
impl AsRef<GlowRenderer> for RendererRef<'_> {
fn as_ref(&self) -> &GlowRenderer {
match self {
Self::Glow(renderer) => renderer,
@ -102,7 +102,7 @@ impl<'a> AsRef<GlowRenderer> for RendererRef<'a> {
}
}
impl<'a> AsMut<GlowRenderer> for RendererRef<'a> {
impl AsMut<GlowRenderer> for RendererRef<'_> {
fn as_mut(&mut self) -> &mut GlowRenderer {
match self {
Self::Glow(renderer) => renderer,
@ -442,8 +442,8 @@ where
let (focal_point, zoom_scale) = zoom_state
.map(|state| {
(
state.animating_focal_point(Some(&output)).to_local(&output),
state.animating_level(&output),
state.animating_focal_point(Some(output)).to_local(output),
state.animating_level(output),
)
})
.unwrap_or_else(|| ((0., 0.).into(), 1.));
@ -460,7 +460,7 @@ where
elements.extend(
cursor::draw_cursor(
renderer,
&seat,
seat,
location,
scale.into(),
zoom_scale,
@ -486,7 +486,7 @@ where
}
if !exclude_dnd_icon {
if let Some(dnd_icon) = get_dnd_icon(&seat) {
if let Some(dnd_icon) = get_dnd_icon(seat) {
elements.extend(
cursor::draw_dnd_icon(
renderer,
@ -620,7 +620,7 @@ where
return Ok(debug_elements);
};
let (previous_idx, idx) = shell_guard.workspaces.active_num(&output);
let (previous_idx, idx) = shell_guard.workspaces.active_num(output);
let previous_workspace = previous_workspace
.zip(previous_idx)
.map(|((w, start), idx)| (w.handle, idx, start));
@ -694,7 +694,7 @@ where
elements.extend(cursor_elements(
renderer,
seats.iter(),
zoom_level.clone(),
zoom_level,
&theme,
now,
output,
@ -752,8 +752,8 @@ where
let (focal_point, zoom_scale) = zoom_level
.map(|state| {
(
state.animating_focal_point(Some(&output)).to_local(&output),
state.animating_level(&output),
state.animating_focal_point(Some(output)).to_local(output),
state.animating_level(output),
)
})
.unwrap_or_else(|| ((0., 0.).into(), 1.));
@ -761,7 +761,7 @@ where
let crop_to_output = |element: WorkspaceRenderElement<R>| {
CropRenderElement::from_element(
RescaleRenderElement::from_element(
element.into(),
element,
focal_point
.as_logical()
.to_physical(output.current_scale().fractional_scale())
@ -774,7 +774,7 @@ where
};
render_input_order::<()>(
&*shell,
&shell,
output,
previous,
current,
@ -817,7 +817,7 @@ where
elements.extend(
render_elements_from_surface_tree::<_, WorkspaceRenderElement<_>>(
renderer,
&layer.wl_surface(),
layer.wl_surface(),
location
.to_local(output)
.as_logical()
@ -917,7 +917,7 @@ where
resize_indicator.clone(),
active_hint,
alpha,
&theme.cosmic(),
theme.cosmic(),
)
.into_iter()
.map(Into::into)
@ -932,7 +932,7 @@ where
last_active_seat,
!move_active && is_active_space,
overview.clone(),
&theme.cosmic(),
theme.cosmic(),
) {
Ok(elements) => {
elements
@ -963,7 +963,7 @@ where
overview.clone(),
resize_indicator.clone(),
active_hint,
&theme.cosmic(),
theme.cosmic(),
) {
Ok(elements) => {
elements
@ -1344,7 +1344,7 @@ where
for (session, frame) in output.take_pending_frames() {
if let Some(pending_image_copy_data) = render_session::<_, _, GlesTexture>(
renderer,
&session.user_data().get::<SessionData>().unwrap(),
session.user_data().get::<SessionData>().unwrap(),
frame,
output.current_transform(),
|buffer, renderer, offscreen, dt, age, additional_damage| {
@ -1496,7 +1496,7 @@ where
)?;
if let Some(additional_damage) = additional_damage {
let output_geo = output.geometry().to_local(&output).as_logical();
let output_geo = output.geometry().to_local(output).as_logical();
elements.extend(
additional_damage
.into_iter()

2
src/backend/winit.rs
View file

@ -143,7 +143,7 @@ pub fn init_backend(
init_egl_client_side(dh, state, &mut backend)?;
let name = format!("WINIT-0");
let name = "WINIT-0".to_string();
let size = backend.window_size();
let props = PhysicalProperties {
size: (0, 0).into(),

35
src/backend/x11.rs
View file

@ -512,29 +512,26 @@ where
impl State {
pub fn process_x11_event(&mut self, event: InputEvent<X11Input>) {
// here we can handle special cases for x11 inputs, like mapping them to windows
match &event {
InputEvent::PointerMotionAbsolute { event } => {
if let Some(window) = event.window() {
let output = self
.backend
.x11()
.surfaces
.iter()
.find(|surface| &surface.window == window.as_ref())
.map(|surface| surface.output.clone())
.unwrap();
if let InputEvent::PointerMotionAbsolute { event } = &event {
if let Some(window) = event.window() {
let output = self
.backend
.x11()
.surfaces
.iter()
.find(|surface| &surface.window == window.as_ref())
.map(|surface| surface.output.clone())
.unwrap();
let device = event.device();
for seat in self.common.shell.read().seats.iter() {
let devices = seat.user_data().get::<Devices>().unwrap();
if devices.has_device(&device) {
seat.set_active_output(&output);
break;
}
let device = event.device();
for seat in self.common.shell.read().seats.iter() {
let devices = seat.user_data().get::<Devices>().unwrap();
if devices.has_device(&device) {
seat.set_active_output(&output);
break;
}
}
}
_ => {}
};
self.process_input_event(event);