floating: restore size and loc on unmaximize

src/shell/layout/floating/mod.rs

@@ -136,13 +136,22 @@ impl FloatingLayout {
     }
 
     pub fn unmap_window(&mut self, space: &mut Space, window: &Window) {
-        if let Some(location) = space.window_location(window) {
+        #[allow(irrefutable_let_patterns)]
-            let user_data = window.user_data();
+        let is_maximized = match &window.toplevel() {
-            user_data.insert_if_missing(|| WindowUserData::default());
+            Kind::Xdg(surface) => surface.with_pending_state(|state| {
-            user_data.get::<WindowUserData>().unwrap().lock().unwrap().last_geometry = Rectangle::from_loc_and_size(
+                state.states.contains(XdgState::Maximized)
-                location,
+            })
-                window.geometry().size,
+        };
-            );
+
+        if !is_maximized {
+            if let Some(location) = space.window_location(window) {
+                let user_data = window.user_data();
+                user_data.insert_if_missing(|| WindowUserData::default());
+                user_data.get::<WindowUserData>().unwrap().lock().unwrap().last_geometry = Rectangle::from_loc_and_size(
+                    location,
+                    window.geometry().size,
+                );
+            }
         }
 
         space.unmap_window(window);
@@ -154,6 +163,15 @@ impl FloatingLayout {
         let layers = layer_map_for_output(&output);
         let geometry = layers.non_exclusive_zone();
         
+        if let Some(location) = space.window_location(window) {
+            let user_data = window.user_data();
+            user_data.insert_if_missing(|| WindowUserData::default());
+            user_data.get::<WindowUserData>().unwrap().lock().unwrap().last_geometry = Rectangle::from_loc_and_size(
+                location,
+                window.geometry().size,
+            );
+        }
+    
         space.map_window(
             &window,
             (geometry.loc.x, geometry.loc.y),
@@ -170,6 +188,27 @@ impl FloatingLayout {
         }
     }
 
+    pub fn unmaximize_request(&mut self, space: &mut Space, window: &Window) {
+        let last_geometry = window.user_data().get::<WindowUserData>().map(|u| u.lock().unwrap().last_geometry);
+        match window.toplevel() {
+            Kind::Xdg(toplevel) => {
+                toplevel.with_pending_state(|state| {
+                    state.states.unset(XdgState::Maximized);
+                    state.size = last_geometry.map(|g| g.size);
+                });
+                toplevel.send_configure();
+            }
+        }
+        if let Some(last_location) = last_geometry.map(|g| g.loc) {
+            space.map_window(
+                &window,
+                last_location,
+                FLOATING_INDEX,
+                true,
+            );
+        }
+    }
+
     pub fn move_request(
         &mut self,
         space: &mut Space,

src/shell/workspace.rs

@@ -70,6 +70,16 @@ impl Workspace {
         }
     }
     
+    pub fn unmaximize_request(&mut self, window: &Window) {
+        if self.fullscreen.values().any(|w| w == window) {
+            return self.unfullscreen_request(window);
+        }
+        if self.floating_layer.windows.contains(window) {
+            self.floating_layer
+                .unmaximize_request(&mut self.space, window);
+        }
+    }
+
     pub fn move_request(
         &mut self,
         window: &Window,

src/wayland/handlers/xdg_shell/mod.rs

@@ -226,11 +226,16 @@ impl XdgShellHandler for State {
     }
 
     fn unmaximize_request(&mut self, _dh: &DisplayHandle, surface: ToplevelSurface) {
-        surface.with_pending_state(|state| {
+        let surface = surface.wl_surface();
-            state.states.unset(xdg_toplevel::State::Maximized);
+
-            state.size = None;
+        if let Some(workspace) = self.common.shell.space_for_surface_mut(surface) {
-        });
+            let window = workspace
-        surface.send_configure();
+                .space
+                .window_for_surface(surface, WindowSurfaceType::TOPLEVEL)
+                .unwrap()
+                .clone();
+            workspace.unmaximize_request(&window)
+        }
     }
 
     fn fullscreen_request(