wip (halp)

Author: prokopyl

src/platform/win/error.rs

@@ -1,12 +1,14 @@
 use crate::HandlerError;
+use dpi::PhysicalSize;
 use std::fmt::Display;
 
 pub type Result<T> = std::result::Result<T, PlatformError>;
 
 #[derive(Debug)]
 pub enum PlatformError {
     Win32(windows_core::Error),
-    ResizeFailed,
+    UnexpectedResizeResult { new_actual_size: PhysicalSize<u32> },
+    InvalidScaleFactor,
     Handler(HandlerError),
 }
 
@@ -27,7 +29,14 @@ impl Display for PlatformError {
         match self {
             PlatformError::Win32(e) => Display::fmt(e, f),
             PlatformError::Handler(e) => Display::fmt(e, f),
-            PlatformError::ResizeFailed => f.write_str("Window resize request failed."),
+            PlatformError::UnexpectedResizeResult { new_actual_size } => {
+                write!(
+                    f,
+                    "Resize operation did not result in expected size, got {:?} instead.",
+                    new_actual_size
+                )
+            }
+            PlatformError::InvalidScaleFactor => f.write_str("Invalid window scale factor."),
         }
     }
 }

src/platform/win/window.rs

@@ -69,7 +69,9 @@ impl WindowHandle {
     }
 
     pub fn resize(&self, new_size: Size) -> Result<()> {
+        crate::debug!("Resizing to {:?}", new_size);
         let new_size = self.state.sizing_strategy.adjust_size(new_size, self.size()).physical;
+        crate::debug!("Size adjusted to {:?}", new_size);
 
         if new_size == self.state.current_size.get() {
             return Ok(());
@@ -86,12 +88,15 @@ impl WindowHandle {
         let _guard = self.state.originate_host_resize();
         let dpi_ctx =
             DpiAwarenessGuard::new(&self.state.user32, self.state.dpi_scaling_strategy.get())?;
+        crate::debug!("DPI: {:?}", hwnd.get_dpi(&self.state.user32));
         hwnd.resize_and_activate(new_size, self.state.current_dpi.get(), &dpi_ctx)?;
 
         if self.state.current_size.get() == new_size {
             Ok(())
         } else {
-            Err(PlatformError::ResizeFailed)
+            Err(PlatformError::UnexpectedResizeResult {
+                new_actual_size: self.state.current_size.get(),
+            })
         }
     }
 
@@ -100,6 +105,9 @@ impl WindowHandle {
     }
 
     pub fn suggest_scale_factor(&self, new_host_scale_factor: f64) -> Result<()> {
+        let new_dpi = Dpi::from_scale_factor(new_host_scale_factor)
+            .ok_or(PlatformError::InvalidScaleFactor)?;
+
         let current_scale_factor = self.state.scale_factor();
         self.state.fallback_scale_factor.set(Some(new_host_scale_factor));
 
@@ -109,6 +117,8 @@ impl WindowHandle {
             return Ok(());
         }
 
+        self.state.current_dpi.set(Some(new_dpi));
+
         let Some(hwnd) = self.hwnd.get() else { return Ok(()) };
 
         let current_size = self.state.current_size.get();
@@ -127,12 +137,14 @@ impl WindowHandle {
         let _guard = self.state.originate_host_resize();
         let dpi_ctx = DpiAwarenessGuard::new(&self.state.user32, dpi_scaling_strategy)?;
 
-        hwnd.resize_and_activate(new_size, None, &dpi_ctx)?;
+        hwnd.resize_and_activate(new_size, Some(new_dpi), &dpi_ctx)?;
 
         if self.state.current_size.get() == new_size {
             Ok(())
         } else {
-            Err(PlatformError::ResizeFailed)
+            Err(PlatformError::UnexpectedResizeResult {
+                new_actual_size: self.state.current_size.get(),
+            })
         }
     }
 
@@ -620,6 +632,8 @@ unsafe fn wnd_proc_inner(
             let new_size = PhysicalSize { width, height };
             let current_size = window_state.shared.current_size.get();
 
+            crate::debug!("WM_SIZE: new {new_size:?}, old {current_size:?}");
+
             // Only send the event if anything changed
             if current_size == new_size {
                 return None;

src/platform/win/window_state.rs

@@ -175,7 +175,7 @@ impl WindowSharedState {
         Self {
             parented: (settings.parent.is_some() || settings.wait_for_parent).into(),
             is_alive: true.into(),
-            current_dpi: None.into(),
+            current_dpi: Some(Dpi::default()).into(),
             current_size: settings.size.to_physical(1.0).into(),
             fallback_scale_factor: settings.fallback_scale_factor.into(),
             resize_host_originated: false.into(),
@@ -216,6 +216,10 @@ impl WindowSharedState {
     }
 
     pub fn scale_factor(&self) -> f64 {
+        if self.dpi_scaling_strategy.get().assume_96_dpi {
+            return 1.0;
+        }
+
         if let Some(dpi) = self.current_dpi.get() {
             dpi.scale_factor()
         } else {

src/wrappers/win32/dpi.rs

@@ -3,7 +3,7 @@ use crate::platform::DpiScalingStrategy;
 use crate::wrappers::win32::user32::ExtendedUser32;
 use crate::wrappers::win32::DpiAwarenessContextType::*;
 use std::ffi::c_void;
-use std::fmt::Debug;
+use std::fmt::{Debug, Formatter};
 use std::num::NonZeroU32;
 use std::ptr::NonNull;
 use windows_core::{Error, Result};
@@ -20,6 +20,10 @@ impl Dpi {
         self.0.get() as f64 / USER_DEFAULT_SCREEN_DPI as f64
     }
 
+    pub fn from_scale_factor(scale_factor: f64) -> Option<Dpi> {
+        Some(Dpi(NonZeroU32::new((scale_factor * USER_DEFAULT_SCREEN_DPI as f64) as u32)?))
+    }
+
     /// Windows 10, version 1607.
     pub fn get_system(user32: &ExtendedUser32) -> Option<Self> {
         if let Some(get_dpi_for_system) = user32.get_dpi_for_system {
@@ -333,6 +337,14 @@ impl<'a> DpiAwarenessGuard<'a> {
     }
 }
 
+impl Debug for DpiAwarenessGuard<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("DpiAwarenessGuard")
+            .field("context_type", &self.inner.map(|(c, u)| c.get_type(u)))
+            .finish()
+    }
+}
+
 impl Drop for DpiAwarenessGuard<'_> {
     fn drop(&mut self) {
         if let Some(inner) = self.inner {

src/wrappers/win32/window/handle.rs

@@ -184,8 +184,12 @@ impl HWnd {
         let style = self.get_style()?;
 
         let rect = Rect::from(client_size);
+        crate::debug!("Resize_and_activate rect: {rect:?} (dpi: {window_dpi:?}");
         let rect = dpi_ctx.client_area_to_nc_area(rect, style, window_dpi)?;
 
+        crate::debug!("Resize_and_activate rect after adjust: {rect:?}");
+        crate::debug!("CTX: {dpi_ctx:?}");
+
         self.resize_nc_and_activate(rect.size())
     }