workspace: Re-maximize windows when changing tile mode

src/shell/layout/floating/mod.rs

@@ -307,6 +307,7 @@ impl FloatingLayout {
         &mut self,
         mapped: CosmicMapped,
         previous_geometry: Rectangle<i32, Local>,
+        animate: bool,
     ) {
         let output = self.space.outputs().next().unwrap().clone();
         let layers = layer_map_for_output(&output);
@@ -324,13 +325,15 @@ impl FloatingLayout {
 
         mapped.moved_since_mapped.store(true, Ordering::SeqCst);
 
-        self.animations.insert(
+        if animate {
-            mapped.clone(),
+            self.animations.insert(
-            Animation::Tiled {
+                mapped.clone(),
-                start: Instant::now(),
+                Animation::Tiled {
-                previous_geometry,
+                    start: Instant::now(),
-            },
+                    previous_geometry,
-        );
+                },
+            );
+        }
         if mapped.floating_tiled.lock().unwrap().take().is_some() {
             if let Some(state) = mapped.maximized_state.lock().unwrap().as_mut() {
                 if let Some(real_old_geo) = mapped.last_geometry.lock().unwrap().clone() {
@@ -1010,7 +1013,7 @@ impl FloatingLayout {
                         });
                         std::mem::drop(maximized_state);
 
-                        self.map_maximized(focused.clone(), start_rectangle);
+                        self.map_maximized(focused.clone(), start_rectangle, true);
                         return MoveResult::Done;
                     }
 

src/shell/mod.rs

@@ -2779,7 +2779,7 @@ impl Shell {
                 original_layer,
             });
             std::mem::drop(state);
-            floating_layer.map_maximized(mapped.clone(), original_geometry);
+            floating_layer.map_maximized(mapped.clone(), original_geometry, true);
         }
     }
 

src/shell/workspace.rs

@@ -60,6 +60,7 @@ use super::{
     element::{
         resize_indicator::ResizeIndicator, stack::CosmicStackRenderElement,
         swap_indicator::SwapIndicator, window::CosmicWindowRenderElement, CosmicMapped,
+        MaximizedState,
     },
     focus::{
         target::{KeyboardFocusTarget, PointerFocusTarget, WindowGroup},
@@ -669,11 +670,11 @@ impl Workspace {
                         let previous_geometry =
                             self.tiling_layer.element_geometry(&window.window).unwrap();
                         self.floating_layer
-                            .map_maximized(window.window, previous_geometry);
+                            .map_maximized(window.window, previous_geometry, true);
                     }
                 } else {
                     if was_maximized {
-                        self.floating_layer.map_maximized(window.window, from);
+                        self.floating_layer.map_maximized(window.window, from, true);
                     } else {
                         self.floating_layer.map(window.window.clone(), None);
                         // get the right animation
@@ -890,15 +891,21 @@ impl Workspace {
         seat: &Seat<State>,
         workspace_state: &mut WorkspaceUpdateGuard<'_, State>,
     ) {
+        let mut maximized_windows = Vec::new();
         if tiling {
+            let floating_windows = self.floating_layer.mapped().cloned().collect::<Vec<_>>();
+
+            for window in floating_windows.iter().filter(|w| w.is_maximized(false)) {
+                let original_geometry = {
+                    let state = window.maximized_state.lock().unwrap();
+                    state.as_ref().unwrap().original_geometry.clone()
+                };
+                self.unmaximize_request(&window);
+                maximized_windows.push((window.clone(), ManagedLayer::Tiling, original_geometry));
+            }
+
             let focus_stack = self.focus_stack.get(seat);
-            for window in self
+            for window in floating_windows.into_iter() {
-                .floating_layer
-                .mapped()
-                .cloned()
-                .collect::<Vec<_>>()
-                .into_iter()
-            {
                 self.floating_layer.unmap(&window);
                 self.tiling_layer
                     .map(window, Some(focus_stack.iter()), None)
@@ -913,12 +920,35 @@ impl Workspace {
                 .collect::<Vec<_>>()
                 .into_iter()
             {
+                if window.is_maximized(false) {
+                    let original_geometry = {
+                        let state = window.maximized_state.lock().unwrap();
+                        state.as_ref().unwrap().original_geometry.clone()
+                    };
+                    self.unmaximize_request(&window);
+                    maximized_windows.push((
+                        window.clone(),
+                        ManagedLayer::Floating,
+                        original_geometry,
+                    ));
+                }
                 self.tiling_layer.unmap(&window);
                 self.floating_layer.map(window, None);
             }
             workspace_state.set_workspace_tiling_state(&self.handle, TilingState::FloatingOnly);
             self.tiling_enabled = false;
         }
+        for (window, original_layer, original_geometry) in maximized_windows {
+            let mut state = window.maximized_state.lock().unwrap();
+            *state = Some(MaximizedState {
+                original_geometry,
+                original_layer,
+            });
+            std::mem::drop(state);
+
+            self.floating_layer
+                .map_maximized(window, original_geometry, false);
+        }
     }
 
     pub fn toggle_floating_window(&mut self, seat: &Seat<State>, window: &CosmicMapped) {