wip

Author: prokopyl

src/platform/win/window.rs

@@ -81,8 +81,36 @@ impl WindowHandle {
         }
     }
 
-    pub fn suggest_scale_factor(&self, _scale_factor: f64) -> Result<()> {
-        todo!()
+    pub fn suggest_scale_factor(&self, scale_factor: f64) -> Result<()> {
+        let Some(hwnd) = self.hwnd.get() else { return Ok(()) };
+
+        let current_scale_factor = self.state.scale_factor();
+        self.state.fallback_scale_factor.set(Some(scale_factor));
+
+        if self.state.current_dpi.get().is_some() {
+            return Ok(());
+        }
+
+        let current_size = self.state.current_size.get();
+        let new_size = self
+            .state
+            .current_size
+            .get()
+            .to_logical::<f64>(current_scale_factor)
+            .to_physical(self.state.scale_factor());
+
+        // This call doesn't meaningfully change the scaling factor, ignore the result
+        if current_size == new_size {
+            return Ok(());
+        }
+
+        hwnd.resize_and_activate(new_size, None, &self.state.user32)?;
+
+        if self.state.current_size.get() == new_size {
+            Ok(())
+        } else {
+            Err(Error::ResizeFailed)
+        }
     }
 }
 
@@ -125,19 +153,21 @@ impl WindowImpl for BaseviewWindow {
         // Now we can get the actual dpi of the window.
         let dpi = window.get_dpi(&self.window_state.user32)?;
 
-        if dpi != window_state.shared.current_dpi.get() {
-            window_state.shared.current_dpi.set(dpi);
+        if let Some(dpi) = dpi {
+            if Some(dpi) != window_state.shared.current_dpi.get() {
+                window_state.shared.current_dpi.set(Some(dpi));
 
-            // We cannot create a window in "logical" pixels, and we can't DPI-scale to physical pixels because we
-            // have no way to know where the window will end up.
-            // So, at window creation, we assume a DPI=96, and if it ends up wrong, we resize the window
-            // to the actual logical size the user desired.
-            let new_size = self.initial_size.to_physical(dpi.scale_factor());
+                // We cannot create a window in "logical" pixels, and we can't DPI-scale to physical pixels because we
+                // have no way to know where the window will end up.
+                // So, at window creation, we assume a DPI=96, and if it ends up wrong, we resize the window
+                // to the actual logical size the user desired.
+                let new_size = self.initial_size.to_physical(dpi.scale_factor());
 
-            // Preemptively update so a synchronous WM_SIZE from SetWindowPos below
-            // doesn't also emit Resized.
-            window_state.shared.current_size.set(new_size);
-            window.resize_and_activate(new_size, dpi, &window_state.user32)?;
+                // Preemptively update so a synchronous WM_SIZE from SetWindowPos below
+                // doesn't also emit Resized.
+                window_state.shared.current_size.set(new_size);
+                window.resize_and_activate(new_size, Some(dpi), &window_state.user32)?;
+            }
         }
 
         let drop_target = ComObject::new(DropTarget::new(Rc::downgrade(window_state), window));
@@ -377,14 +407,14 @@ unsafe fn wnd_proc_inner(
             let dpi_ctx = DpiAwarenessContext::new(&window_state.user32).unwrap();
             let style = window.get_style().unwrap();
             let suggested_rect =
-                dpi_ctx.nc_area_to_client_area(suggested_nc_rect, style, dpi).unwrap();
+                dpi_ctx.nc_area_to_client_area(suggested_nc_rect, style, Some(dpi)).unwrap();
 
             let new_size = suggested_rect.size();
 
             let changed = window_state.shared.current_size.get() != new_size
-                || window_state.shared.current_dpi.get() != dpi;
+                || window_state.shared.current_dpi.get() != Some(dpi);
 
-            window_state.shared.current_dpi.replace(dpi);
+            window_state.shared.current_dpi.replace(Some(dpi));
             let previous_size = window_state.shared.current_size.replace(new_size);
 
             // Windows makes us resize the window manually. This however will not send a WM_SIZE event,
@@ -476,7 +506,7 @@ impl WindowHandle {
         };
 
         let parent = options.parent.map(|p| p.handle);
-        let rect = dpi_ctx.client_area_to_nc_area(window_size.into(), style, Dpi::default())?;
+        let rect = dpi_ctx.client_area_to_nc_area(window_size.into(), style, None)?;
 
         let window = create_window(&title, style, rect.size(), parent, &dpi_ctx, initializer)?;
 

src/platform/win/window_state.rs

@@ -103,7 +103,7 @@ impl WindowState {
         // `self.window_info` will be modified in response to the `WM_SIZE` event that
         // follows the `SetWindowPos()` call
         let dpi = self.shared.current_dpi.get();
-        let new_size = size.to_physical(dpi.scale_factor());
+        let new_size = size.to_physical(self.shared.scale_factor());
 
         self.hwnd.resize_and_activate(new_size, dpi, &self.user32)?;
         Ok(())
@@ -144,7 +144,8 @@ impl WindowState {
 pub struct WindowSharedState {
     pub is_alive: Cell<bool>,
     pub current_size: Cell<PhysicalSize<u32>>,
-    pub current_dpi: Cell<Dpi>, // None if in non-system scale policy
+    pub current_dpi: Cell<Option<Dpi>>, // None if Win32 HiDPI isn't supported
+    pub fallback_scale_factor: Cell<Option<f64>>,
 
     pub user32: ExtendedUser32,
 }
@@ -153,8 +154,9 @@ impl WindowSharedState {
     pub fn new(current_size: PhysicalSize<u32>, user32: ExtendedUser32) -> Rc<Self> {
         Self {
             is_alive: true.into(),
-            current_dpi: Dpi::default().into(),
+            current_dpi: None.into(),
             current_size: current_size.into(),
+            fallback_scale_factor: None.into(),
             user32,
         }
         .into()
@@ -165,6 +167,10 @@ impl WindowSharedState {
     }
 
     pub fn scale_factor(&self) -> f64 {
-        self.current_dpi.get().scale_factor()
+        if let Some(dpi) = self.current_dpi.get() {
+            dpi.scale_factor()
+        } else {
+            self.fallback_scale_factor.get().unwrap_or(1.0)
+        }
     }
 }

src/wrappers/win32/dpi.rs

@@ -42,9 +42,11 @@ impl<'a> DpiAwarenessContext<'a> {
     }
 
     pub fn client_area_to_nc_area(
-        &self, mut rect: Rect, style: WindowStyle, dpi: Dpi,
+        &self, mut rect: Rect, style: WindowStyle, dpi: Option<Dpi>,
     ) -> Result<Rect> {
-        let Some(adjust_window_rect_ex_for_dpi) = self.user32.adjust_window_rect_ex_for_dpi else {
+        let (Some(adjust_window_rect_ex_for_dpi), Some(dpi)) =
+            (self.user32.adjust_window_rect_ex_for_dpi, dpi)
+        else {
             let result = unsafe { AdjustWindowRectEx(&mut rect.0, style.style, 0, style.style_ex) };
 
             if result == 0 {
@@ -67,7 +69,9 @@ impl<'a> DpiAwarenessContext<'a> {
         Ok(rect)
     }
 
-    pub fn nc_area_to_client_area(&self, rect: Rect, style: WindowStyle, dpi: Dpi) -> Result<Rect> {
+    pub fn nc_area_to_client_area(
+        &self, rect: Rect, style: WindowStyle, dpi: Option<Dpi>,
+    ) -> Result<Rect> {
         let result = self.client_area_to_nc_area(Rect::EMPTY, style, dpi)?;
 
         Ok(Rect(RECT {

src/wrappers/win32/window/handle.rs

@@ -87,15 +87,15 @@ impl HWnd {
         })
     }
 
-    pub fn get_dpi(&self, extended_user32: &ExtendedUser32) -> Result<Dpi> {
+    pub fn get_dpi(&self, extended_user32: &ExtendedUser32) -> Result<Option<Dpi>> {
         let Some(get_dpi_for_window) = extended_user32.get_dpi_for_window else {
-            return Ok(Dpi::default());
+            return Ok(None);
         };
 
         // SAFETY: This type guarantees the HWND is safe to use.
         match unsafe { get_dpi_for_window(self.as_raw()) } {
             0 => Err(Error::from_thread()),
-            dpi => Ok(Dpi(dpi)),
+            dpi => Ok(Some(Dpi(dpi))),
         }
     }
 
@@ -140,7 +140,7 @@ impl HWnd {
     }
 
     pub fn resize_and_activate(
-        &self, client_size: PhysicalSize<u32>, window_dpi: Dpi, user32: &ExtendedUser32,
+        &self, client_size: PhysicalSize<u32>, window_dpi: Option<Dpi>, user32: &ExtendedUser32,
     ) -> Result<()> {
         let dpi_ctx = DpiAwarenessContext::new(user32)?;
         let style = self.get_style()?;