Refactor request_fullscreen() to be an argument on request_size()

4 files changed, 19 insertions, 15 deletions

diff --git a/src/layout/mod.rs b/src/layout/mod.rs
index 432a1d41..42474e8c 100644
--- a/src/layout/mod.rs
+++ b/src/layout/mod.rs
@@ -176,17 +176,16 @@ pub trait LayoutElement {
     fn request_size(
         &mut self,
         size: Size<i32, Logical>,
+        is_fullscreen: bool,
         animate: bool,
         transaction: Option<Transaction>,
     );
 
     /// Requests the element to change size once, clearing the request afterwards.
     fn request_size_once(&mut self, size: Size<i32, Logical>, animate: bool) {
-        self.request_size(size, animate, None);
+        self.request_size(size, false, animate, None);
     }
 
-    fn request_fullscreen(&mut self, size: Size<i32, Logical>);
-
     fn min_size(&self) -> Size<i32, Logical>;
     fn max_size(&self) -> Size<i32, Logical>;
     fn is_wl_surface(&self, wl_surface: &WlSurface) -> bool;
@@ -206,12 +205,12 @@ pub trait LayoutElement {
 
     /// Whether the element is currently fullscreen.
     ///
-    /// This will *not* switch immediately after a [`LayoutElement::request_fullscreen()`] call.
+    /// This will *not* switch immediately after a [`LayoutElement::request_size()`] call.
     fn is_fullscreen(&self) -> bool;
 
     /// Whether we're requesting the element to be fullscreen.
     ///
-    /// This *will* switch immediately after a [`LayoutElement::request_fullscreen()`] call.
+    /// This *will* switch immediately after a [`LayoutElement::request_size()`] call.
     fn is_pending_fullscreen(&self) -> bool;
 
     /// Size previously requested through [`LayoutElement::request_size()`].
diff --git a/src/layout/scrolling.rs b/src/layout/scrolling.rs
index 8659b8f8..e8ee6195 100644
--- a/src/layout/scrolling.rs
+++ b/src/layout/scrolling.rs
@@ -3999,8 +3999,16 @@ impl<W: LayoutElement> Column<W> {
 
     fn update_tile_sizes_with_transaction(&mut self, animate: bool, transaction: Transaction) {
         if self.is_fullscreen {
-            for tile in &mut self.tiles {
-                tile.request_fullscreen();
+            for (tile_idx, tile) in self.tiles.iter_mut().enumerate() {
+                // In tabbed mode, only the visible window participates in the transaction.
+                let is_active = tile_idx == self.active_tile_idx;
+                let transaction = if self.display_mode == ColumnDisplay::Tabbed && !is_active {
+                    None
+                } else {
+                    Some(transaction.clone())
+                };
+
+                tile.request_fullscreen(animate, transaction);
             }
             return;
         }
diff --git a/src/layout/tests.rs b/src/layout/tests.rs
index 29a44877..da2eecbb 100644
--- a/src/layout/tests.rs
+++ b/src/layout/tests.rs
@@ -129,15 +129,12 @@ impl LayoutElement for TestWindow {
     fn request_size(
         &mut self,
         size: Size<i32, Logical>,
+        is_fullscreen: bool,
         _animate: bool,
         _transaction: Option<Transaction>,
     ) {
         self.0.requested_size.set(Some(size));
-        self.0.pending_fullscreen.set(false);
-    }
-
-    fn request_fullscreen(&mut self, _size: Size<i32, Logical>) {
-        self.0.pending_fullscreen.set(true);
+        self.0.pending_fullscreen.set(is_fullscreen);
     }
 
     fn min_size(&self) -> Size<i32, Logical> {
diff --git a/src/layout/tile.rs b/src/layout/tile.rs
index 89f0e6ab..518d08cc 100644
--- a/src/layout/tile.rs
+++ b/src/layout/tile.rs
@@ -718,7 +718,7 @@ impl<W: LayoutElement> Tile<W> {
         // round to avoid situations where proportionally-sized columns don't fit on the screen
         // exactly.
         self.window
-            .request_size(size.to_i32_floor(), animate, transaction);
+            .request_size(size.to_i32_floor(), false, animate, transaction);
     }
 
     pub fn tile_width_for_window_width(&self, size: f64) -> f64 {
@@ -753,9 +753,9 @@ impl<W: LayoutElement> Tile<W> {
         }
     }
 
-    pub fn request_fullscreen(&mut self) {
+    pub fn request_fullscreen(&mut self, animate: bool, transaction: Option<Transaction>) {
         self.window
-            .request_fullscreen(self.view_size.to_i32_round());
+            .request_size(self.view_size.to_i32_round(), true, animate, transaction);
     }
 
     pub fn min_size(&self) -> Size<f64, Logical> {