fix(windows): calculate accurate window insets for undecorated shadows (tauri-apps#1052)

ref: https://github.com/zed-industries/zed/blob/7bddb390cabefb177d9996dc580749d64e6ca3b6/crates/gpui/src/platform/windows/events.rs#L1418-L1454

closes tauri-apps#905

Author: amrbashir

.changes/windows-undecorated-insets.md

@@ -0,0 +1,5 @@
+---
+"tao": patch
+---
+
+On Windows, fix regression `Window::inner_size` reporting larger size than what's visible for undecorated window.

.changes/windows-undecorated-resizing.md

@@ -0,0 +1,5 @@
+---
+"tao": patch
+---
+
+On Windows, undecorated window with shadows, now have native resize handles outside of the window client area.

src/platform_impl/windows/dark_mode.rs

@@ -20,25 +20,16 @@ use std::ffi::c_void;
 
 use crate::window::Theme;
 
+use super::util;
+
 static HUXTHEME: Lazy<isize> =
   Lazy::new(|| unsafe { LoadLibraryA(s!("uxtheme.dll")).unwrap_or_default().0 as _ });
 
-static WIN10_BUILD_VERSION: Lazy<Option<u32>> = Lazy::new(|| {
-  let version = windows_version::OsVersion::current();
-  if version.major == 10 && version.minor == 0 {
-    Some(version.build)
-  } else {
-    None
-  }
-});
-
 static DARK_MODE_SUPPORTED: Lazy<bool> = Lazy::new(|| {
   // We won't try to do anything for windows versions < 17763
   // (Windows 10 October 2018 update)
-  match *WIN10_BUILD_VERSION {
-    Some(v) => v >= 17763,
-    None => false,
-  }
+  let v = *util::WIN_VERSION;
+  v.major == 10 && v.minor == 0 && v.build >= 17763
 });
 
 pub fn allow_dark_mode_for_app(is_dark_mode: bool) {
@@ -79,19 +70,17 @@ pub fn allow_dark_mode_for_app(is_dark_mode: bool) {
       .map(|handle| std::mem::transmute(handle))
     });
 
-    if let Some(ver) = *WIN10_BUILD_VERSION {
-      if ver < 18362 {
-        if let Some(_allow_dark_mode_for_app) = *ALLOW_DARK_MODE_FOR_APP {
-          unsafe { _allow_dark_mode_for_app(is_dark_mode) };
-        }
-      } else if let Some(_set_preferred_app_mode) = *SET_PREFERRED_APP_MODE {
-        let mode = if is_dark_mode {
-          PreferredAppMode::AllowDark
-        } else {
-          PreferredAppMode::Default
-        };
-        unsafe { _set_preferred_app_mode(mode) };
+    if util::WIN_VERSION.build < 18362 {
+      if let Some(_allow_dark_mode_for_app) = *ALLOW_DARK_MODE_FOR_APP {
+        unsafe { _allow_dark_mode_for_app(is_dark_mode) };
       }
+    } else if let Some(_set_preferred_app_mode) = *SET_PREFERRED_APP_MODE {
+      let mode = if is_dark_mode {
+        PreferredAppMode::AllowDark
+      } else {
+        PreferredAppMode::Default
+      };
+      unsafe { _set_preferred_app_mode(mode) };
     }
 
     refresh_immersive_color_policy_state();
@@ -168,39 +157,37 @@ pub fn allow_dark_mode_for_window(hwnd: HWND, is_dark_mode: bool) {
 }
 
 fn refresh_titlebar_theme_color(hwnd: HWND, is_dark_mode: bool, redraw_title_bar: bool) {
-  if let Some(ver) = *WIN10_BUILD_VERSION {
-    if ver < 17763 {
-      let mut is_dark_mode_bigbool: i32 = is_dark_mode.into();
-      unsafe {
-        let _ = SetPropW(
-          hwnd,
-          w!("UseImmersiveDarkModeColors"),
-          Some(HANDLE(&mut is_dark_mode_bigbool as *mut _ as _)),
-        );
-      }
+  if util::WIN_VERSION.build < 17763 {
+    let mut is_dark_mode_bigbool: i32 = is_dark_mode.into();
+    unsafe {
+      let _ = SetPropW(
+        hwnd,
+        w!("UseImmersiveDarkModeColors"),
+        Some(HANDLE(&mut is_dark_mode_bigbool as *mut _ as _)),
+      );
+    }
+  } else {
+    // https://github.com/MicrosoftDocs/sdk-api/pull/966/files
+    let dwmwa_use_immersive_dark_mode = if util::WIN_VERSION.build > 18985 {
+      DWMWINDOWATTRIBUTE(20)
     } else {
-      // https://github.com/MicrosoftDocs/sdk-api/pull/966/files
-      let dwmwa_use_immersive_dark_mode = if ver > 18985 {
-        DWMWINDOWATTRIBUTE(20)
-      } else {
-        DWMWINDOWATTRIBUTE(19)
-      };
-      let dark_mode = BOOL::from(is_dark_mode);
-      unsafe {
-        let _ = DwmSetWindowAttribute(
-          hwnd,
-          dwmwa_use_immersive_dark_mode,
-          &dark_mode as *const BOOL as *const c_void,
-          std::mem::size_of::<BOOL>() as u32,
-        );
-        if redraw_title_bar {
-          if GetActiveWindow() == hwnd {
-            DefWindowProcW(hwnd, WM_NCACTIVATE, WPARAM::default(), LPARAM::default());
-            DefWindowProcW(hwnd, WM_NCACTIVATE, WPARAM(true.into()), LPARAM::default());
-          } else {
-            DefWindowProcW(hwnd, WM_NCACTIVATE, WPARAM(true.into()), LPARAM::default());
-            DefWindowProcW(hwnd, WM_NCACTIVATE, WPARAM::default(), LPARAM::default());
-          }
+      DWMWINDOWATTRIBUTE(19)
+    };
+    let dark_mode = BOOL::from(is_dark_mode);
+    unsafe {
+      let _ = DwmSetWindowAttribute(
+        hwnd,
+        dwmwa_use_immersive_dark_mode,
+        &dark_mode as *const BOOL as *const c_void,
+        std::mem::size_of::<BOOL>() as u32,
+      );
+      if redraw_title_bar {
+        if GetActiveWindow() == hwnd {
+          DefWindowProcW(hwnd, WM_NCACTIVATE, WPARAM::default(), LPARAM::default());
+          DefWindowProcW(hwnd, WM_NCACTIVATE, WPARAM(true.into()), LPARAM::default());
+        } else {
+          DefWindowProcW(hwnd, WM_NCACTIVATE, WPARAM(true.into()), LPARAM::default());
+          DefWindowProcW(hwnd, WM_NCACTIVATE, WPARAM::default(), LPARAM::default());
         }
       }
     }

src/platform_impl/windows/dpi.rs

@@ -64,9 +64,8 @@ pub fn get_monitor_dpi(hmonitor: HMONITOR) -> Option<u32> {
   None
 }
 
-pub const BASE_DPI: u32 = 96;
 pub fn dpi_to_scale_factor(dpi: u32) -> f64 {
-  dpi as f64 / BASE_DPI as f64
+  dpi as f64 / USER_DEFAULT_SCREEN_DPI as f64
 }
 
 pub unsafe fn hwnd_dpi(hwnd: HWND) -> u32 {
@@ -77,22 +76,22 @@ pub unsafe fn hwnd_dpi(hwnd: HWND) -> u32 {
   if let Some(GetDpiForWindow) = *GET_DPI_FOR_WINDOW {
     // We are on Windows 10 Anniversary Update (1607) or later.
     match GetDpiForWindow(hwnd) {
-      0 => BASE_DPI, // 0 is returned if hwnd is invalid
+      0 => USER_DEFAULT_SCREEN_DPI, // 0 is returned if hwnd is invalid
       dpi => dpi as u32,
     }
   } else if let Some(GetDpiForMonitor) = *GET_DPI_FOR_MONITOR {
     // We are on Windows 8.1 or later.
     let monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
     if monitor.is_invalid() {
-      return BASE_DPI;
+      return USER_DEFAULT_SCREEN_DPI;
     }
 
     let mut dpi_x = 0;
     let mut dpi_y = 0;
     if GetDpiForMonitor(monitor, MDT_EFFECTIVE_DPI, &mut dpi_x, &mut dpi_y).is_ok() {
       dpi_x as u32
     } else {
-      BASE_DPI
+      USER_DEFAULT_SCREEN_DPI
     }
   } else {
     // We are on Vista or later.
@@ -104,7 +103,7 @@ pub unsafe fn hwnd_dpi(hwnd: HWND) -> u32 {
       // If the process is DPI unaware, then scaling is performed by the OS; we thus return
       // 96 (scale factor 1.0) to prevent the window from being re-scaled by both the
       // application and the WM.
-      BASE_DPI
+      USER_DEFAULT_SCREEN_DPI
     }
   }
 }

src/platform_impl/windows/event_loop.rs

@@ -33,6 +33,7 @@ use windows::{
     },
     UI::{
       Controls::{self as win32c, HOVER_DEFAULT},
+      HiDpi::GetSystemMetricsForDpi,
       Input::{KeyboardAndMouse::*, Pointer::*, Touch::*, *},
       Shell::{
         DefSubclassProc, RemoveWindowSubclass, SHAppBarMessage, SetWindowSubclass, ABE_BOTTOM,
@@ -66,6 +67,8 @@ use crate::{
 };
 use runner::{EventLoopRunner, EventLoopRunnerShared};
 
+use super::dpi::hwnd_dpi;
+
 type GetPointerFrameInfoHistory = unsafe extern "system" fn(
   pointerId: u32,
   entriesCount: *mut u32,
@@ -2151,10 +2154,13 @@ unsafe fn public_window_callback_inner<T: 'static>(
           }
         } else if window_flags.contains(WindowFlags::MARKER_UNDECORATED_SHADOW) && !is_fullscreen {
           let params = &mut *(lparam.0 as *mut NCCALCSIZE_PARAMS);
-          params.rgrc[0].top += 1;
-          params.rgrc[0].bottom += 1;
-          params.rgrc[0].left += 1;
-          params.rgrc[0].right += 1;
+
+          let insets = util::calculate_window_insets(window);
+
+          params.rgrc[0].left += insets.left;
+          params.rgrc[0].top += insets.top;
+          params.rgrc[0].right -= insets.right;
+          params.rgrc[0].bottom -= insets.bottom;
         }
         result = ProcResult::Value(LRESULT(0)); // return 0 here to make the window borderless
       }
@@ -2176,25 +2182,38 @@ unsafe fn public_window_callback_inner<T: 'static>(
           util::GET_Y_LPARAM(lparam) as i32,
         );
 
-        let mut rect = RECT::default();
-        let _ = GetWindowRect(window, &mut rect);
-
-        let padded_border = GetSystemMetrics(SM_CXPADDEDBORDER);
-        let border_x = GetSystemMetrics(SM_CXFRAME) + padded_border;
-        let border_y = GetSystemMetrics(SM_CYFRAME) + padded_border;
-
-        let hit_result = crate::window::hit_test(
-          (rect.left, rect.top, rect.right, rect.bottom),
-          cx,
-          cy,
-          border_x,
-          border_y,
-        )
-        .map(|d| d.to_win32());
+        let dpi = hwnd_dpi(window);
+        let border_y = GetSystemMetricsForDpi(SM_CYFRAME, dpi);
 
-        result = hit_result
-          .map(|r| ProcResult::Value(LRESULT(r as _)))
-          .unwrap_or(ProcResult::DefSubclassProc);
+        // if we have undecorated shadows, we only need to handle the top edge
+        if window_flags.contains(WindowFlags::MARKER_UNDECORATED_SHADOW) {
+          let mut cursor_pt = POINT { x: cx, y: cy };
+          if ScreenToClient(window, &mut cursor_pt).as_bool()
+            && cursor_pt.y >= 0
+            && cursor_pt.y <= border_y
+          {
+            result = ProcResult::Value(LRESULT(HTTOP as _));
+          }
+        } else {
+          //otherwise do full hit testing
+          let border_x = GetSystemMetricsForDpi(SM_CXFRAME, dpi);
+
+          let mut rect = RECT::default();
+          let _ = GetWindowRect(window, &mut rect);
+
+          let hit_result = crate::window::hit_test(
+            (rect.left, rect.top, rect.right, rect.bottom),
+            cx,
+            cy,
+            border_x,
+            border_y,
+          )
+          .map(|d| d.to_win32());
+
+          result = hit_result
+            .map(|r| ProcResult::Value(LRESULT(r as _)))
+            .unwrap_or(ProcResult::DefSubclassProc);
+        }
       } else {
         result = ProcResult::DefSubclassProc;
       }

src/platform_impl/windows/monitor.rs

@@ -7,6 +7,7 @@ use windows::{
   Win32::{
     Foundation::{BOOL, HWND, LPARAM, POINT, RECT},
     Graphics::Gdi::*,
+    UI::WindowsAndMessaging::USER_DEFAULT_SCREEN_DPI,
   },
 };
 
@@ -216,7 +217,7 @@ impl MonitorHandle {
 
   #[inline]
   pub fn scale_factor(&self) -> f64 {
-    dpi_to_scale_factor(get_monitor_dpi(self.hmonitor()).unwrap_or(96))
+    dpi_to_scale_factor(get_monitor_dpi(self.hmonitor()).unwrap_or(USER_DEFAULT_SCREEN_DPI))
   }
 
   #[inline]

src/platform_impl/windows/util.rs

@@ -17,6 +17,7 @@ use crate::{
   window::CursorIcon,
 };
 
+use once_cell::sync::Lazy;
 use windows::{
   core::{HRESULT, PCSTR, PCWSTR},
   Win32::{
@@ -425,3 +426,72 @@ pub fn get_instance_handle() -> windows::Win32::Foundation::HMODULE {
 
   windows::Win32::Foundation::HMODULE(unsafe { &__ImageBase as *const _ as _ })
 }
+
+pub static WIN_VERSION: Lazy<windows_version::OsVersion> =
+  Lazy::new(windows_version::OsVersion::current);
+
+pub fn get_frame_thickness(dpi: u32) -> i32 {
+  let resize_frame_thickness = unsafe { GetSystemMetricsForDpi(SM_CXSIZEFRAME, dpi) };
+  let padding_thickness = unsafe { GetSystemMetricsForDpi(SM_CXPADDEDBORDER, dpi) };
+  resize_frame_thickness + padding_thickness
+}
+
+pub fn calculate_insets_for_dpi(dpi: u32) -> RECT {
+  // - On Windows 10
+  // The top inset must be zero, since if there is any nonclient area, Windows will draw
+  // a full native titlebar outside the client area. (This doesn't occur in the maximized
+  // case.)
+  //
+  // - On Windows 11
+  // The top inset is calculated using an empirical formula that I derived through various
+  // tests. Without this, the top 1-2 rows of pixels in our window would be obscured.
+
+  let frame_thickness = get_frame_thickness(dpi);
+
+  let top_inset = match WIN_VERSION.build {
+    v if v >= 22000 => (dpi as f32 / USER_DEFAULT_SCREEN_DPI as f32).round() as i32,
+    _ => 0,
+  };
+
+  RECT {
+    left: frame_thickness,
+    top: top_inset,
+    right: frame_thickness,
+    bottom: frame_thickness,
+  }
+}
+
+/// Calcuclate window insets, used in WM_NCCALCSIZE
+///
+/// Derived of GPUI implementation
+/// see <https://github.com/zed-industries/zed/blob/7bddb390cabefb177d9996dc580749d64e6ca3b6/crates/gpui/src/platform/windows/events.rs#L1418-L1454>
+pub fn calculate_window_insets(window: HWND) -> RECT {
+  let dpi = unsafe { super::dpi::hwnd_dpi(window) };
+  calculate_insets_for_dpi(dpi)
+}
+
+pub fn window_rect(hwnd: HWND) -> RECT {
+  unsafe {
+    let mut rect = RECT::default();
+    if GetWindowRect(hwnd, &mut rect).is_err() {
+      panic!(
+        "Unexpected GetWindowRect failure: please report this error to \
+               tauri-apps/tao"
+      )
+    }
+    rect
+  }
+}
+
+pub fn client_rect(hwnd: HWND) -> RECT {
+  unsafe {
+    let mut rect = RECT::default();
+    if GetClientRect(hwnd, &mut rect).is_err() {
+      panic!(
+        "Unexpected GetClientRect failure: please report this error to \
+               tauri-apps/tao"
+      )
+    }
+    rect
+  }
+}