Resize the renderer when a minimized window is restored on Windows

crates/gpui_wgpu/src/wgpu_renderer/surfaces/windows.rs

@@ -41,9 +41,7 @@ pub(super) fn retain_surface_cache(renderer: &WgpuRenderer, surfaces: &[PaintSur
     let active_custom_textures = surfaces
         .iter()
         .filter_map(|surface| match &surface.source {
-            gpui::SurfaceSource::Texture { texture, .. } => {
-                texture.downcast_ref::<wgpu::Texture>()
-            }
+            gpui::SurfaceSource::Texture { texture, .. } => texture.downcast_ref::<wgpu::Texture>(),
             _ => None,
         })
         .collect::<smallvec::SmallVec<[&wgpu::Texture; 4]>>();
@@ -76,16 +74,14 @@ pub(super) fn draw_surfaces(
                 log::error!("surface source is not a WGPU texture");
                 return Err(frame::DrawError::ExternalSurface);
             };
-            let binding = cache.custom_textures.entry(texture.clone()).or_insert_with(|| {
-                let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
-                SurfaceBinding::new(renderer, view.clone(), view)
-            });
-            renderer.draw_surface_binding(
-                surface,
-                SurfaceColorFormat::Rgba,
-                binding,
-                pass,
-            )?;
+            let binding = cache
+                .custom_textures
+                .entry(texture.clone())
+                .or_insert_with(|| {
+                    let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
+                    SurfaceBinding::new(renderer, view.clone(), view)
+                });
+            renderer.draw_surface_binding(surface, SurfaceColorFormat::Rgba, binding, pass)?;
             continue;
         }
         let Some(frame) = capture_frame(surface) else {
@@ -341,7 +337,7 @@ mod tests {
 mod custom_gpu_tests {
     use std::sync::Arc;
 
-    use gpui::{Bounds, Point, Scene, ScaledPixels, Size, SurfaceSource};
+    use gpui::{Bounds, Point, ScaledPixels, Scene, Size, SurfaceSource};
 
     use super::*;
     use crate::{WgpuContext, WgpuRenderer};
@@ -410,14 +406,20 @@ mod custom_gpu_tests {
         let mut scene = Scene::default();
         scene.insert_primitive(gpui::Quad {
             bounds: full.clone(),
-            content_mask: gpui::ContentMask { bounds: full.clone(), ..Default::default() },
+            content_mask: gpui::ContentMask {
+                bounds: full.clone(),
+                ..Default::default()
+            },
             background: gpui::solid_background(gpui::white()),
             ..Default::default()
         });
         scene.insert_primitive(gpui::PaintSurface {
             order: 1,
             bounds: bounds(2.0, 2.0),
-            content_mask: gpui::ContentMask { bounds: full.clone(), ..Default::default() },
+            content_mask: gpui::ContentMask {
+                bounds: full.clone(),
+                ..Default::default()
+            },
             source: SurfaceSource::Texture {
                 texture,
                 size: gpui::size(gpui::DevicePixels(2), gpui::DevicePixels(2)),

crates/gpui_windows/src/directx_renderer.rs

@@ -794,6 +794,15 @@ impl DirectXRenderer {
             .context("failed to build RGBA image from DirectX staging readback")
     }
 
+    /// The size the swap chain was last resized to.
+    #[cfg(test)]
+    pub(crate) fn drawable_size(&self) -> Size<DevicePixels> {
+        Size {
+            width: DevicePixels(self.width as i32),
+            height: DevicePixels(self.height as i32),
+        }
+    }
+
     pub(crate) fn resize(&mut self, new_size: Size<DevicePixels>) -> Result<()> {
         let width = new_size.width.0.max(1) as u32;
         let height = new_size.height.0.max(1) as u32;

crates/gpui_windows/src/events.rs

@@ -237,8 +237,8 @@ impl WindowsWindowInner {
     }
 
     fn handle_size_msg(&self, wparam: WPARAM, lparam: LPARAM) -> Option<isize> {
-        // Don't resize the renderer when the window is minimized, but record that it was minimized so
-        // that on restore the swap chain can be recreated via `update_drawable_size_even_if_unchanged`.
+        // A minimized window has no client area to draw, so stop requesting frames until it is
+        // restored. The renderer keeps its size: `WM_SIZE` reports 0x0 while minimized.
         if wparam.0 == SIZE_MINIMIZED as usize {
             self.state
                 .restore_from_minimized
@@ -251,32 +251,27 @@ impl WindowsWindowInner {
         let new_size = size(DevicePixels(width), DevicePixels(height));
 
         let scale_factor = self.state.scale_factor.get();
-        let mut should_resize_renderer = false;
         if let Some(restore_from_minimized) = self.state.restore_from_minimized.take() {
             self.state
                 .callbacks
                 .request_frame
                 .set(Some(restore_from_minimized));
-        } else {
-            should_resize_renderer = true;
         }
 
-        self.handle_size_change(new_size, scale_factor, should_resize_renderer);
+        // Resize the renderer on restore too. The restored size can differ from the size the
+        // window had when it was minimized (a display, scale or resolution change while it sat in
+        // the taskbar, or restoring to maximized). Layout follows the new size either way, so a
+        // swap chain left at the old size clips the right and bottom of the window. The renderer
+        // returns early when the size is unchanged.
+        self.handle_size_change(new_size, scale_factor);
         Some(0)
     }
 
-    fn handle_size_change(
-        &self,
-        device_size: Size<DevicePixels>,
-        scale_factor: f32,
-        should_resize_renderer: bool,
-    ) {
+    fn handle_size_change(&self, device_size: Size<DevicePixels>, scale_factor: f32) {
         let new_logical_size = device_size.to_pixels(scale_factor);
 
         self.state.logical_size.set(new_logical_size);
-        if should_resize_renderer
-            && let Err(e) = self.state.renderer.borrow_mut().resize(device_size)
-        {
+        if let Err(e) = self.state.renderer.borrow_mut().resize(device_size) {
             log::error!("Failed to resize renderer, invalidating devices: {}", e);
             self.state
                 .invalidate_devices
@@ -924,7 +919,7 @@ impl WindowsWindowInner {
                 // SetWindowPos may not send WM_SIZE for maximized windows in some cases,
                 // so we manually update the size to ensure proper rendering
                 let device_size = size(DevicePixels(width), DevicePixels(height));
-                self.handle_size_change(device_size, new_scale_factor, true);
+                self.handle_size_change(device_size, new_scale_factor);
             }
         } else {
             // For non-maximized windows, use the suggested RECT from the system

crates/gpui_windows/src/platform.rs

@@ -1599,6 +1599,105 @@ mod tests {
         );
     }
 
+    /// A window restored from the taskbar at a different size than it was minimized at (a display,
+    /// scale or resolution change while minimized, or restoring to maximized) must resize its
+    /// renderer. Layout follows the restored size, so a swap chain left at the old size clips the
+    /// right and bottom of the window until the user resizes it.
+    #[test]
+    fn restoring_a_minimized_window_resizes_the_renderer() -> anyhow::Result<()> {
+        use super::WindowsPlatform;
+        use crate::WindowsWindow;
+        use gpui::{
+            AnyWindowHandle, Bounds, DevicePixels, PlatformWindow as _, WindowHandle, WindowId,
+            WindowKind, WindowParams, point, px, size,
+        };
+        use windows::Win32::Foundation::RECT;
+        use windows::Win32::UI::WindowsAndMessaging::{
+            DestroyWindow, GetClientRect, GetWindowPlacement, SW_RESTORE, SW_SHOWMINNOACTIVE,
+            SW_SHOWNOACTIVATE, SetWindowPlacement, ShowWindow, WINDOWPLACEMENT,
+        };
+
+        struct Root;
+        impl gpui::Render for Root {
+            fn render(
+                &mut self,
+                _: &mut gpui::Window,
+                _: &mut gpui::Context<Self>,
+            ) -> impl gpui::IntoElement {
+                gpui::Empty
+            }
+        }
+
+        let platform = WindowsPlatform::new(false)?;
+        let handle: AnyWindowHandle = WindowHandle::<Root>::new(WindowId::from(1)).into();
+        let window = WindowsWindow::new(
+            handle,
+            WindowParams {
+                bounds: Bounds::new(point(px(100.), px(100.)), size(px(400.), px(300.))),
+                titlebar: None,
+                kind: WindowKind::Normal,
+                is_movable: true,
+                app_owns_titlebar_drag: false,
+                is_resizable: true,
+                is_minimizable: true,
+                focus: false,
+                show: false,
+                icon: None,
+                display_id: None,
+                app_id: None,
+                window_min_size: None,
+                windows_renderer: Default::default(),
+            },
+            platform.generate_creation_info(),
+        )?;
+        let hwnd = window.get_raw_handle();
+        let client_size = || -> anyhow::Result<gpui::Size<DevicePixels>> {
+            let mut rect = RECT::default();
+            unsafe { GetClientRect(hwnd, &mut rect)? };
+            Ok(size(
+                DevicePixels(rect.right - rect.left),
+                DevicePixels(rect.bottom - rect.top),
+            ))
+        };
+        let renderer_size = || window.0.state.renderer.borrow().drawable_size();
+        // Every gpui window registers a frame callback, and minimizing stashes it. Without one, the
+        // restore looks like an ordinary resize and the bug never shows.
+        window.on_request_frame(Box::new(|_| {}));
+
+        unsafe {
+            let _ = ShowWindow(hwnd, SW_SHOWNOACTIVATE);
+        }
+        let before = client_size()?;
+        assert_eq!(renderer_size(), before);
+
+        // Minimize, then grow the size the window restores to while it sits in the taskbar, the
+        // way a display or scale change does.
+        unsafe {
+            let _ = ShowWindow(hwnd, SW_SHOWMINNOACTIVE);
+            let mut placement = WINDOWPLACEMENT {
+                length: std::mem::size_of::<WINDOWPLACEMENT>() as u32,
+                ..Default::default()
+            };
+            GetWindowPlacement(hwnd, &mut placement)?;
+            placement.rcNormalPosition.right += 200;
+            placement.rcNormalPosition.bottom += 100;
+            placement.showCmd = SW_SHOWMINNOACTIVE.0 as u32;
+            SetWindowPlacement(hwnd, &placement)?;
+            let _ = ShowWindow(hwnd, SW_RESTORE);
+        }
+
+        let after = client_size()?;
+        assert_ne!(after, before, "the restored window should be larger");
+        assert_eq!(
+            renderer_size(),
+            after,
+            "the renderer must take the restored size, not keep the pre-minimize size"
+        );
+
+        unsafe { DestroyWindow(hwnd)? };
+        Ok(())
+    }
+
     #[test]
     fn test_clipboard() {
         let item = ClipboardItem::new_string("你好，我是张小白".to_string());

crates/gpui_windows/src/wgpu_renderer.rs

@@ -269,6 +269,15 @@ impl WindowRenderer {
         }
     }
 
+    /// The size the renderer was last resized to.
+    #[cfg(test)]
+    pub(crate) fn drawable_size(&self) -> Size<gpui::DevicePixels> {
+        match self {
+            Self::DirectX(r) => r.drawable_size(),
+            Self::Wgpu(r) => r.size,
+        }
+    }
+
     pub fn resize(&mut self, size: Size<gpui::DevicePixels>) -> anyhow::Result<()> {
         match self {
             Self::DirectX(r) => r.resize(size),