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

niri-visual-tests/src/cases/layout.rs

@@ -163,6 +163,7 @@ impl Layout {
         window.request_size(
             ws.new_window_size(width, None, false, window.rules(), (min_size, max_size)),
             false,
+            false,
             None,
         );
         window.communicate();
@@ -191,6 +192,7 @@ impl Layout {
         window.request_size(
             ws.new_window_size(width, None, false, window.rules(), (min_size, max_size)),
             false,
+            false,
             None,
         );
         window.communicate();

niri-visual-tests/src/cases/window.rs

@@ -14,14 +14,14 @@ pub struct Window {
 impl Window {
     pub fn freeform(args: Args) -> Self {
         let mut window = TestWindow::freeform(0);
-        window.request_size(args.size, false, None);
+        window.request_size(args.size, false, false, None);
         window.communicate();
         Self { window }
     }
 
     pub fn fixed_size(args: Args) -> Self {
         let mut window = TestWindow::fixed_size(0);
-        window.request_size(args.size, false, None);
+        window.request_size(args.size, false, false, None);
         window.communicate();
         Self { window }
     }
@@ -29,7 +29,7 @@ impl Window {
     pub fn fixed_size_with_csd_shadow(args: Args) -> Self {
         let mut window = TestWindow::fixed_size(0);
         window.set_csd_shadow_width(64);
-        window.request_size(args.size, false, None);
+        window.request_size(args.size, false, false, None);
         window.communicate();
         Self { window }
     }
@@ -38,7 +38,7 @@ impl Window {
 impl TestCase for Window {
     fn resize(&mut self, width: i32, height: i32) {
         self.window
-            .request_size(Size::from((width, height)), false, None);
+            .request_size(Size::from((width, height)), false, false, None);
         self.window.communicate();
     }
 

niri-visual-tests/src/test_window.rs

@@ -182,15 +182,12 @@ impl LayoutElement for TestWindow {
     fn request_size(
         &mut self,
         size: Size<i32, Logical>,
+        is_fullscreen: bool,
         _animate: bool,
         _transaction: Option<Transaction>,
     ) {
         self.inner.borrow_mut().requested_size = Some(size);
-        self.inner.borrow_mut().pending_fullscreen = false;
-    }
-
-    fn request_fullscreen(&mut self, _size: Size<i32, Logical>) {
-        self.inner.borrow_mut().pending_fullscreen = true;
+        self.inner.borrow_mut().pending_fullscreen = is_fullscreen;
     }
 
     fn min_size(&self) -> Size<i32, Logical> {

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()`].

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;
         }

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> {

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> {

src/window/mapped.rs

@@ -604,13 +604,18 @@ impl LayoutElement for Mapped {
     fn request_size(
         &mut self,
         size: Size<i32, Logical>,
+        is_fullscreen: bool,
         animate: bool,
         transaction: Option<Transaction>,
     ) {
         let changed = self.toplevel().with_pending_state(|state| {
             let changed = state.size != Some(size);
             state.size = Some(size);
-            state.states.unset(xdg_toplevel::State::Fullscreen);
+            if is_fullscreen {
+                state.states.set(xdg_toplevel::State::Fullscreen);
+            } else {
+                state.states.unset(xdg_toplevel::State::Fullscreen);
+            }
             changed
         });
 
@@ -693,15 +698,6 @@ impl LayoutElement for Mapped {
         self.request_size_once = Some(RequestSizeOnce::WaitingForConfigure);
     }
 
-    fn request_fullscreen(&mut self, size: Size<i32, Logical>) {
-        self.toplevel().with_pending_state(|state| {
-            state.size = Some(size);
-            state.states.set(xdg_toplevel::State::Fullscreen);
-        });
-
-        self.request_size_once = None;
-    }
-
     fn min_size(&self) -> Size<i32, Logical> {
         let min_size = with_states(self.toplevel().wl_surface(), |state| {
             let mut guard = state.cached_state.get::<SurfaceCachedState>();