Run cargo format

src/backend/kms/device.rs

@@ -307,7 +307,9 @@ impl State {
                         let surface = device.surfaces.remove(&crtc).unwrap();
                         if surface.output.mirroring().is_none() {
                             // TODO: move up later outputs?
-                            w = w.saturating_sub(surface.output.config().transformed_size().w as u32);
+                            w = w.saturating_sub(
+                                surface.output.config().transformed_size().w as u32,
+                            );
                         }
                     }
 

src/shell/grabs/moving.rs

@@ -864,9 +864,10 @@ impl Drop for MoveGrab {
                     let pointer = seat.get_pointer().unwrap();
                     let current_location = pointer.current_location();
 
-                    if let Some((target, offset)) =
+                    if let Some((target, offset)) = mapped.focus_under(
-                        mapped.focus_under(current_location - position.as_logical().to_f64(), WindowSurfaceType::ALL)
+                        current_location - position.as_logical().to_f64(),
-                    {
+                        WindowSurfaceType::ALL,
+                    ) {
                         pointer.motion(
                             state,
                             Some((

src/shell/layout/floating/mod.rs

@@ -732,18 +732,26 @@ impl FloatingLayout {
         self.space
             .elements()
             .rev()
-            .map(|e| (e, self.space.element_location(e).unwrap() - e.geometry().loc))
+            .map(|e| {
+                (
+                    e,
+                    self.space.element_location(e).unwrap() - e.geometry().loc,
+                )
+            })
             .filter(|(e, render_location)| {
                 let mut bbox = e.bbox();
                 bbox.loc += *render_location;
                 bbox.to_f64().contains(location.as_logical())
             })
             .find_map(|(e, render_location)| {
-                let render_location = render_location
+                let render_location = render_location.as_local().to_f64();
-                    .as_local()
-                    .to_f64();
                 let point = location - render_location;
-                if e.focus_under(point.as_logical(), WindowSurfaceType::POPUP | WindowSurfaceType::SUBSURFACE).is_some() {
+                if e.focus_under(
+                    point.as_logical(),
+                    WindowSurfaceType::POPUP | WindowSurfaceType::SUBSURFACE,
+                )
+                .is_some()
+                {
                     Some(e.clone().into())
                 } else {
                     None
@@ -751,22 +759,33 @@ impl FloatingLayout {
             })
     }
 
-    pub fn toplevel_element_under(&self, location: Point<f64, Local>) -> Option<KeyboardFocusTarget> {
+    pub fn toplevel_element_under(
+        &self,
+        location: Point<f64, Local>,
+    ) -> Option<KeyboardFocusTarget> {
         self.space
             .elements()
             .rev()
-            .map(|e| (e, self.space.element_location(e).unwrap() - e.geometry().loc))
+            .map(|e| {
+                (
+                    e,
+                    self.space.element_location(e).unwrap() - e.geometry().loc,
+                )
+            })
             .filter(|(e, render_location)| {
                 let mut bbox = e.bbox();
                 bbox.loc += *render_location;
                 bbox.to_f64().contains(location.as_logical())
             })
             .find_map(|(e, render_location)| {
-                let render_location = render_location
+                let render_location = render_location.as_local().to_f64();
-                    .as_local()
-                    .to_f64();
                 let point = location - render_location;
-                if e.focus_under(point.as_logical(), WindowSurfaceType::TOPLEVEL | WindowSurfaceType::SUBSURFACE).is_some() {
+                if e.focus_under(
+                    point.as_logical(),
+                    WindowSurfaceType::TOPLEVEL | WindowSurfaceType::SUBSURFACE,
+                )
+                .is_some()
+                {
                     Some(e.clone().into())
                 } else {
                     None
@@ -781,16 +800,19 @@ impl FloatingLayout {
         self.space
             .elements()
             .rev()
-            .map(|e| (e, self.space.element_location(e).unwrap() - e.geometry().loc))
+            .map(|e| {
+                (
+                    e,
+                    self.space.element_location(e).unwrap() - e.geometry().loc,
+                )
+            })
             .filter(|(e, render_location)| {
                 let mut bbox = e.bbox();
                 bbox.loc += *render_location;
                 bbox.to_f64().contains(location.as_logical())
             })
             .find_map(|(e, render_location)| {
-                let render_location = render_location
+                let render_location = render_location.as_local().to_f64();
-                    .as_local()
-                    .to_f64();
                 let point = location - render_location;
                 e.focus_under(
                     point.as_logical(),
@@ -809,7 +831,12 @@ impl FloatingLayout {
         self.space
             .elements()
             .rev()
-            .map(|e| (e, self.space.element_location(e).unwrap() - e.geometry().loc))
+            .map(|e| {
+                (
+                    e,
+                    self.space.element_location(e).unwrap() - e.geometry().loc,
+                )
+            })
             .filter(|(e, render_location)| {
                 let mut bbox = e.bbox();
                 bbox.loc += *render_location;
@@ -823,10 +850,7 @@ impl FloatingLayout {
                     WindowSurfaceType::TOPLEVEL | WindowSurfaceType::SUBSURFACE,
                 )
                 .map(|(surface, surface_offset)| {
-                    (
+                    (surface, render_location + surface_offset.as_local())
-                        surface,
-                        render_location + surface_offset.as_local(),
-                    )
                 })
             })
     }

src/shell/layout/tiling/mod.rs

@@ -3105,7 +3105,10 @@ impl TilingLayout {
         None
     }
 
-    pub fn popup_element_under(&self, location_f64: Point<f64, Local>) -> Option<KeyboardFocusTarget> {
+    pub fn popup_element_under(
+        &self,
+        location_f64: Point<f64, Local>,
+    ) -> Option<KeyboardFocusTarget> {
         let location = location_f64.to_i32_round();
 
         for (mapped, geo) in self.mapped() {
@@ -3113,10 +3116,13 @@ impl TilingLayout {
                 continue;
             }
 
-            if mapped.focus_under(
+            if mapped
-                (location_f64 - geo.loc.to_f64()).as_logical() + mapped.geometry().loc.to_f64(),
+                .focus_under(
-                WindowSurfaceType::POPUP | WindowSurfaceType::SUBSURFACE,
+                    (location_f64 - geo.loc.to_f64()).as_logical() + mapped.geometry().loc.to_f64(),
-            ).is_some() {
+                    WindowSurfaceType::POPUP | WindowSurfaceType::SUBSURFACE,
+                )
+                .is_some()
+            {
                 return Some(mapped.clone().into());
             }
         }
@@ -3124,7 +3130,10 @@ impl TilingLayout {
         None
     }
 
-    pub fn toplevel_element_under(&self, location_f64: Point<f64, Local>) -> Option<KeyboardFocusTarget> {
+    pub fn toplevel_element_under(
+        &self,
+        location_f64: Point<f64, Local>,
+    ) -> Option<KeyboardFocusTarget> {
         let location = location_f64.to_i32_round();
 
         for (mapped, geo) in self.mapped() {
@@ -3132,10 +3141,13 @@ impl TilingLayout {
                 continue;
             }
 
-            if mapped.focus_under(
+            if mapped
-                (location_f64 - geo.loc.to_f64()).as_logical() + mapped.geometry().loc.to_f64(),
+                .focus_under(
-                WindowSurfaceType::TOPLEVEL | WindowSurfaceType::SUBSURFACE,
+                    (location_f64 - geo.loc.to_f64()).as_logical() + mapped.geometry().loc.to_f64(),
-            ).is_some() {
+                    WindowSurfaceType::TOPLEVEL | WindowSurfaceType::SUBSURFACE,
+                )
+                .is_some()
+            {
                 return Some(mapped.clone().into());
             }
         }

src/shell/mod.rs

@@ -1966,7 +1966,8 @@ impl Shell {
                 set.sticky_layer.update_pointer_position(Some(location));
                 for (i, workspace) in set.workspaces.iter_mut().enumerate() {
                     if i == set.active {
-                        workspace.update_pointer_position(Some(location), self.overview_mode.clone());
+                        workspace
+                            .update_pointer_position(Some(location), self.overview_mode.clone());
                     } else {
                         workspace.update_pointer_position(None, self.overview_mode.clone());
                     }

src/wayland/protocols/toplevel_info.rs

@@ -200,10 +200,7 @@ where
                         .instances
                         .push(instance);
                 } else {
-                    let _ = data_init.init(
+                    let _ = data_init.init(cosmic_toplevel, ToplevelHandleStateInner::empty());
-                        cosmic_toplevel,
-                        ToplevelHandleStateInner::empty(),
-                    );
                     error!(?foreign_toplevel, "Toplevel for foreign-toplevel-list not registered for cosmic-toplevel-info.");
                 }
             }