From 6a80ec4704b767483866eec41f9f08432991c35a Mon Sep 17 00:00:00 2001
From: Ivan Molodetskikh <yalterz@gmail.com>
Date: Mon, 17 Mar 2025 07:45:26 +0300
Subject: layout/tile: Don't take fullscreen into account in min/max size

They are used strictly for non-fullscreen size computation.
---
 src/layout/scrolling.rs | 12 ++++++++----
 src/layout/tile.rs      | 14 ++++++++++----
 2 files changed, 18 insertions(+), 8 deletions(-)

(limited to 'src')

diff --git a/src/layout/scrolling.rs b/src/layout/scrolling.rs
index e8ee6195..1fd79256 100644
--- a/src/layout/scrolling.rs
+++ b/src/layout/scrolling.rs
@@ -4018,14 +4018,18 @@ impl<W: LayoutElement> Column<W> {
         let min_size: Vec<_> = self
             .tiles
             .iter()
-            .map(Tile::min_size)
+            .map(Tile::min_size_nonfullscreen)
             .map(|mut size| {
                 size.w = size.w.max(1.);
                 size.h = size.h.max(1.);
                 size
             })
             .collect();
-        let max_size: Vec<_> = self.tiles.iter().map(Tile::max_size).collect();
+        let max_size: Vec<_> = self
+            .tiles
+            .iter()
+            .map(Tile::max_size_nonfullscreen)
+            .collect();
 
         // Compute the column width.
         let min_width = min_size
@@ -4517,7 +4521,7 @@ impl<W: LayoutElement> Column<W> {
                 .iter()
                 .enumerate()
                 .filter(|(idx, _)| *idx != tile_idx)
-                .map(|(_, tile)| f64::max(1., tile.min_size().h) + gaps)
+                .map(|(_, tile)| f64::max(1., tile.min_size_nonfullscreen().h) + gaps)
                 .sum::<f64>()
         };
         let height_left = working_size - extra_size - gaps - min_height_taken - gaps;
@@ -4947,7 +4951,7 @@ impl<W: LayoutElement> Column<W> {
             let requested_size = tile.window().requested_size().unwrap();
             let requested_tile_height =
                 tile.tile_height_for_window_height(f64::from(requested_size.h));
-            let min_tile_height = f64::max(1., tile.min_size().h);
+            let min_tile_height = f64::max(1., tile.min_size_nonfullscreen().h);
 
             if !self.is_fullscreen
                 && self.scale.round() == self.scale
diff --git a/src/layout/tile.rs b/src/layout/tile.rs
index 518d08cc..891ac3f6 100644
--- a/src/layout/tile.rs
+++ b/src/layout/tile.rs
@@ -758,10 +758,13 @@ impl<W: LayoutElement> Tile<W> {
             .request_size(self.view_size.to_i32_round(), true, animate, transaction);
     }
 
-    pub fn min_size(&self) -> Size<f64, Logical> {
+    pub fn min_size_nonfullscreen(&self) -> Size<f64, Logical> {
         let mut size = self.window.min_size().to_f64();
 
-        if let Some(width) = self.effective_border_width() {
+        // Can't go through effective_border_width() because we might be fullscreen.
+        if !self.border.is_off() {
+            let width = self.border.width();
+
             size.w = f64::max(1., size.w);
             size.h = f64::max(1., size.h);
 
@@ -772,10 +775,13 @@ impl<W: LayoutElement> Tile<W> {
         size
     }
 
-    pub fn max_size(&self) -> Size<f64, Logical> {
+    pub fn max_size_nonfullscreen(&self) -> Size<f64, Logical> {
         let mut size = self.window.max_size().to_f64();
 
-        if let Some(width) = self.effective_border_width() {
+        // Can't go through effective_border_width() because we might be fullscreen.
+        if !self.border.is_off() {
+            let width = self.border.width();
+
             if size.w > 0. {
                 size.w += width * 2.;
             }
-- 
cgit