layout: Pass and store view_size on a Tile

1 files changed, 48 insertions, 23 deletions

diff --git a/src/layout/tile.rs b/src/layout/tile.rs
index fac2c5c4..96936d26 100644
--- a/src/layout/tile.rs
+++ b/src/layout/tile.rs
@@ -48,9 +48,6 @@ pub struct Tile<W: LayoutElement> {
     /// The black backdrop for fullscreen windows.
     fullscreen_backdrop: SolidColorBuffer,
 
-    /// The size we were requested to fullscreen into.
-    fullscreen_size: Size<f64, Logical>,
-
     /// Whether the tile should float upon unfullscreening.
     pub(super) unfullscreen_to_floating: bool,
 
@@ -94,6 +91,11 @@ pub struct Tile<W: LayoutElement> {
     /// Extra damage for clipped surface corner radius changes.
     rounded_corner_damage: RoundedCornerDamage,
 
+    /// The view size for the tile's workspace.
+    ///
+    /// Used as the fullscreen target size.
+    view_size: Size<f64, Logical>,
+
     /// Scale of the output the tile is on (and rounds its sizes to).
     scale: f64,
 
@@ -134,18 +136,24 @@ struct MoveAnimation {
 }
 
 impl<W: LayoutElement> Tile<W> {
-    pub fn new(window: W, scale: f64, clock: Clock, options: Rc<Options>) -> Self {
+    pub fn new(
+        window: W,
+        view_size: Size<f64, Logical>,
+        scale: f64,
+        clock: Clock,
+        options: Rc<Options>,
+    ) -> Self {
         let rules = window.rules();
         let border_config = rules.border.resolve_against(options.border);
         let focus_ring_config = rules.focus_ring.resolve_against(options.focus_ring.into());
+        let is_fullscreen = window.is_fullscreen();
 
         Self {
             window,
             border: FocusRing::new(border_config.into()),
             focus_ring: FocusRing::new(focus_ring_config.into()),
-            is_fullscreen: false, // FIXME: up-to-date fullscreen right away, but we need size.
-            fullscreen_backdrop: SolidColorBuffer::new((0., 0.), [0., 0., 0., 1.]),
-            fullscreen_size: Default::default(),
+            is_fullscreen,
+            fullscreen_backdrop: SolidColorBuffer::new(view_size, [0., 0., 0., 1.]),
             unfullscreen_to_floating: false,
             floating_window_size: None,
             floating_pos: None,
@@ -158,13 +166,19 @@ impl<W: LayoutElement> Tile<W> {
             interactive_move_offset: Point::from((0., 0.)),
             unmap_snapshot: None,
             rounded_corner_damage: Default::default(),
+            view_size,
             scale,
             clock,
             options,
         }
     }
 
-    pub fn update_config(&mut self, scale: f64, options: Rc<Options>) {
+    pub fn update_config(
+        &mut self,
+        view_size: Size<f64, Logical>,
+        scale: f64,
+        options: Rc<Options>,
+    ) {
         // If preset widths or heights changed, clear our stored preset index.
         if self.options.preset_column_widths != options.preset_column_widths {
             self.floating_preset_width_idx = None;
@@ -173,6 +187,7 @@ impl<W: LayoutElement> Tile<W> {
             self.floating_preset_height_idx = None;
         }
 
+        self.view_size = view_size;
         self.scale = scale;
         self.options = options;
 
@@ -185,6 +200,8 @@ impl<W: LayoutElement> Tile<W> {
             .focus_ring
             .resolve_against(self.options.focus_ring.into());
         self.focus_ring.update_config(focus_ring_config.into());
+
+        self.fullscreen_backdrop.resize(view_size);
     }
 
     pub fn update_shaders(&mut self) {
@@ -193,10 +210,7 @@ impl<W: LayoutElement> Tile<W> {
     }
 
     pub fn update_window(&mut self) {
-        // FIXME: remove when we can get a fullscreen size right away.
-        if self.fullscreen_size != Size::from((0., 0.)) {
-            self.is_fullscreen = self.window.is_fullscreen();
-        }
+        self.is_fullscreen = self.window.is_fullscreen();
 
         if let Some(animate_from) = self.window.take_animation_snapshot() {
             let size_from = if let Some(resize) = self.resize_animation.take() {
@@ -448,7 +462,7 @@ impl<W: LayoutElement> Tile<W> {
         // In fullscreen, center the window in the given size.
         if self.is_fullscreen {
             let window_size = self.window_size();
-            let target_size = self.fullscreen_size;
+            let target_size = self.view_size;
 
             // Windows aren't supposed to be larger than the fullscreen size, but in case we get
             // one, leave it at the top-left as usual.
@@ -478,8 +492,8 @@ impl<W: LayoutElement> Tile<W> {
         if self.is_fullscreen {
             // Normally we'd just return the fullscreen size here, but this makes things a bit
             // nicer if a fullscreen window is bigger than the fullscreen size for some reason.
-            size.w = f64::max(size.w, self.fullscreen_size.w);
-            size.h = f64::max(size.h, self.fullscreen_size.h);
+            size.w = f64::max(size.w, self.view_size.w);
+            size.h = f64::max(size.h, self.view_size.h);
             return size;
         }
 
@@ -497,8 +511,8 @@ impl<W: LayoutElement> Tile<W> {
         if self.is_fullscreen {
             // Normally we'd just return the fullscreen size here, but this makes things a bit
             // nicer if a fullscreen window is bigger than the fullscreen size for some reason.
-            size.w = f64::max(size.w, self.fullscreen_size.w);
-            size.h = f64::max(size.h, self.fullscreen_size.h);
+            size.w = f64::max(size.w, self.view_size.w);
+            size.h = f64::max(size.h, self.view_size.h);
             return size;
         }
 
@@ -550,8 +564,8 @@ impl<W: LayoutElement> Tile<W> {
         if self.is_fullscreen {
             // Normally we'd just return the fullscreen size here, but this makes things a bit
             // nicer if a fullscreen window is bigger than the fullscreen size for some reason.
-            size.w = f64::max(size.w, self.fullscreen_size.w);
-            size.h = f64::max(size.h, self.fullscreen_size.h);
+            size.w = f64::max(size.w, self.view_size.w);
+            size.h = f64::max(size.h, self.view_size.h);
             return size;
         }
 
@@ -632,10 +646,9 @@ impl<W: LayoutElement> Tile<W> {
         }
     }
 
-    pub fn request_fullscreen(&mut self, size: Size<f64, Logical>) {
-        self.fullscreen_backdrop.resize(size);
-        self.fullscreen_size = size;
-        self.window.request_fullscreen(size.to_i32_round());
+    pub fn request_fullscreen(&mut self) {
+        self.window
+            .request_fullscreen(self.view_size.to_i32_round());
     }
 
     pub fn min_size(&self) -> Size<f64, Logical> {
@@ -982,10 +995,22 @@ impl<W: LayoutElement> Tile<W> {
         self.unmap_snapshot.take()
     }
 
+    pub fn options(&self) -> &Rc<Options> {
+        &self.options
+    }
+
+    #[cfg(test)]
+    pub fn view_size(&self) -> Size<f64, Logical> {
+        self.view_size
+    }
+
     #[cfg(test)]
     pub fn verify_invariants(&self) {
         use approx::assert_abs_diff_eq;
 
+        assert_eq!(self.is_fullscreen, self.window.is_fullscreen());
+        assert_eq!(self.fullscreen_backdrop.size(), self.view_size);
+
         let scale = self.scale;
         let size = self.tile_size();
         let rounded = size.to_physical_precise_round(scale).to_logical(scale);