xwm: More fixes

src/shell/layout/floating/grabs/moving.rs

@@ -23,7 +23,7 @@ use smithay::{
         Seat,
     },
     output::Output,
-    utils::{IsAlive, Logical, Point, Serial},
+    utils::{IsAlive, Logical, Point, Rectangle, Serial},
 };
 use std::cell::RefCell;
 
@@ -183,6 +183,10 @@ impl MoveSurfaceGrab {
                     .output_geometry(&output)
                     .unwrap()
                     .loc;
+                grab_state.window.set_geometry(Rectangle::from_loc_and_size(
+                    window_location + offset,
+                    grab_state.window.geometry().size,
+                ));
                 state
                     .common
                     .shell

src/shell/layout/floating/grabs/resize.rs

@@ -12,7 +12,7 @@ use smithay::{
         AxisFrame, ButtonEvent, GrabStartData as PointerGrabStartData, MotionEvent, PointerGrab,
         PointerInnerHandle,
     },
-    utils::{IsAlive, Logical, Point, Size},
+    utils::{IsAlive, Logical, Point, Rectangle, Size},
 };
 
 /// Information about the resize operation.
@@ -97,7 +97,10 @@ impl PointerGrab<State> for ResizeSurfaceGrab {
         self.last_window_size = (new_window_width, new_window_height).into();
 
         self.window.set_resizing(true);
-        self.window.set_size(self.last_window_size);
+        self.window.set_geometry(Rectangle::from_loc_and_size(
+            self.window.geometry().loc,
+            self.last_window_size,
+        ));
         self.window.configure();
     }
 
@@ -118,7 +121,10 @@ impl PointerGrab<State> for ResizeSurfaceGrab {
             }
 
             self.window.set_resizing(false);
-            self.window.set_size(self.last_window_size);
+            self.window.set_geometry(Rectangle::from_loc_and_size(
+                self.window.geometry().loc,
+                self.last_window_size,
+            ));
             self.window.configure();
 
             let mut resize_state = self.window.resize_state.lock().unwrap();
@@ -220,6 +226,9 @@ impl ResizeSurfaceGrab {
                         );
                     }
                 }
+                let mut geometry = window.geometry();
+                geometry.loc = new_location;
+                let _ = window.set_geometry(geometry);
                 space
                     .floating_layer
                     .space

src/shell/layout/floating/mod.rs

@@ -75,9 +75,7 @@ impl FloatingLayout {
         let geometry = layers.non_exclusive_zone();
         let last_geometry = mapped.last_geometry.lock().unwrap().clone();
 
-        let mut geo_updated = false;
         if let Some(size) = last_geometry.map(|g| g.size) {
-            geo_updated = win_geo.size != size;
             win_geo.size = size;
         }
         {
@@ -98,7 +96,6 @@ impl FloatingLayout {
                 }
                 // but no matter the supported sizes, don't be larger than our non-exclusive-zone
                 win_geo.size.w = std::cmp::min(width, geometry.size.w);
-                geo_updated = true;
             }
             if win_geo.size.h > geometry.size.h / 3 * 2 {
                 // try a more reasonable size
@@ -113,7 +110,6 @@ impl FloatingLayout {
                 }
                 // but no matter the supported sizes, don't be larger than our non-exclusive-zone
                 win_geo.size.h = std::cmp::min(height, geometry.size.h);
-                geo_updated = true;
             }
         }
 
@@ -128,11 +124,8 @@ impl FloatingLayout {
             });
 
         mapped.set_tiled(false);
-        if geo_updated {
-            mapped.set_size(win_geo.size);
-        }
+        mapped.set_geometry(Rectangle::from_loc_and_size(position, win_geo.size));
         mapped.configure();
-
         self.space.map_element(mapped, position, false);
     }
 
@@ -183,8 +176,8 @@ impl FloatingLayout {
         if let Some(mapped) = maybe_mapped {
             let last_geometry = mapped.last_geometry.lock().unwrap().clone();
             let last_size = last_geometry.map(|g| g.size).expect("No previous size?");
-            mapped.set_size(last_size);
             let last_location = last_geometry.map(|g| g.loc).expect("No previous location?");
+            mapped.set_geometry(Rectangle::from_loc_and_size(last_location, last_size));
             self.space.map_element(mapped, last_location, true);
             Some(last_size)
         } else {
@@ -293,6 +286,7 @@ impl FloatingLayout {
                 .get(&output)
                 .copied()
                 .unwrap_or_else(|| (0, 0).into());
+            element.set_geometry(elem_geo);
             self.space.map_element(element.clone(), elem_geo.loc, false);
         }
         self.refresh(); //fixup any out of bounds elements

src/shell/layout/mod.rs

@@ -44,6 +44,7 @@ lazy_static::lazy_static! {
         r"update-manager",
         r"Solaar",
         r"Steam",
+        r"",
         r"TelegramDesktop",
         r"Zotero",
         r"gjs",
@@ -77,6 +78,7 @@ lazy_static::lazy_static! {
         r"Software Updater",
         r".*",
         r"^.*?(Guard|Login).*",
+        r"Steam",
         r"Media viewer",
         r"Quick Format Citation",
         r".*",

src/shell/layout/tiling/mod.rs

@@ -1129,14 +1129,17 @@ impl TilingLayout {
                                 data.update_geometry(geo);
                             }
                             Data::Mapped { mapped, .. } => {
+                                geo.loc += (inner, inner).into();
                                 if !(mapped.is_fullscreen() || mapped.is_maximized()) {
                                     mapped.set_tiled(true);
-                                    mapped.set_size(
-                                        (geo.size.w - inner * 2, geo.size.h - inner * 2).into(),
-                                    );
-                                    mapped.configure();
+                                    let size = (geo.size.w - inner * 2, geo.size.h - inner * 2);
+                                    let internal_geometry =
+                                        Rectangle::from_loc_and_size(geo.loc, size);
+                                    if mapped.geometry() != internal_geometry {
+                                        mapped.set_geometry(internal_geometry);
+                                        mapped.configure();
+                                    }
                                 }
-                                geo.loc += (inner, inner).into();
                                 data.update_geometry(geo);
                             }
                         }