WinUIBackend: Get window HWND, fix display scaling support

stackotter · stackotter · commit 53689aef6937 · 2025-04-05T04:55:55.000-07:00
diff --git a/Sources/Gtk3Backend/Gtk3Backend.swift b/Sources/Gtk3Backend/Gtk3Backend.swift
@@ -279,7 +279,7 @@ public final class Gtk3Backend: AppBackend {
         rootEnvironment: EnvironmentValues
     ) -> EnvironmentValues {
         let windowScaleFactor = Int(gtk_widget_get_scale_factor(window.widgetPointer))
-        return rootEnvironment.with(\.windowScaleFactor, windowScaleFactor)
+        return rootEnvironment.with(\.windowScaleFactor, Double(windowScaleFactor))
     }
 
     public func setWindowEnvironmentChangeHandler(
diff --git a/Sources/SwiftCrossUI/Environment/EnvironmentValues.swift b/Sources/SwiftCrossUI/Environment/EnvironmentValues.swift
@@ -36,7 +36,7 @@ public struct EnvironmentValues {
     public var onSubmit: (() -> Void)?
 
     /// The scale factor of the current window.
-    public var windowScaleFactor: Int
+    public var windowScaleFactor: Double
 
     /// Called by view graph nodes when they resize due to an internal state
     /// change and end up changing size. Each view graph node sets its own
@@ -69,7 +69,7 @@ public struct EnvironmentValues {
     /// The backend's representation of the window that the current view is
     /// in, if any. This is a very internal detail that should never get
     /// exposed to users.
-    var window: Any?
+    package var window: Any?
     /// The backend in use. Mustn't change throughout the app's lifecycle.
     let backend: any AppBackend
 
diff --git a/Sources/SwiftCrossUI/Views/Image.swift b/Sources/SwiftCrossUI/Views/Image.swift
@@ -162,7 +162,7 @@ class _ImageChildren: ViewGraphNodeChildren {
     var imageWidget: AnyWidget
     var imageChanged = false
     var isContainerEmpty = true
-    var lastScaleFactor = 1
+    var lastScaleFactor: Double = 1
 
     init<Backend: AppBackend>(backend: Backend) {
         container = AnyWidget(backend.createContainer())
diff --git a/Sources/WinUIBackend/HWNDInterop.swift b/Sources/WinUIBackend/HWNDInterop.swift
@@ -0,0 +1,84 @@
+import CWinRT
+import WinAppSDK
+import WinSDK
+import WinUI
+import WindowsFoundation
+
+public func getWindowIDFromWindow(_ hWnd: HWND?) -> WinAppSDK.WindowId {
+    HWNDInterop.shared.getWindowIDFromWindow(hWnd)
+}
+
+public func getWindowFromWindowId(_ windowID: WinAppSDK.WindowId) -> HWND? {
+    HWNDInterop.shared.getWindowFromWindowId(windowID)
+}
+
+extension WinAppSDK.AppWindow {
+    /// Returns the window handle for the app window.
+    public func getHWND() -> HWND? {
+        HWNDInterop.shared.getWindowFromWindowId(id)
+    }
+}
+
+extension WinUI.Window {
+    /// Returns the window handle for the window.
+    ///
+    /// - Note: This is a relatively expensive operation, particularly due to its use
+    /// of the `appWindow` getter. If an `AppWindow` is already available, prefer to
+    /// use `getHWND()` on that instead; better yet, if the window handle will be used
+    /// frequently, assign it to a stored property, as it will not change during the
+    /// lifetime of the window.
+    public func getHWND() -> HWND? {
+        // The appWindow can become nil when a Window is closed.
+        guard let appWindow else { return nil }
+        return appWindow.getHWND()
+    }
+}
+
+private struct HWNDInterop {
+    private typealias pfnGetWindowIdFromWindow = @convention(c) (
+        HWND?, UnsafeMutablePointer<__x_ABI_CMicrosoft_CUI_CWindowId>?
+    ) -> HRESULT
+    private typealias pfnGetWindowFromWindowId = @convention(c) (
+        __x_ABI_CMicrosoft_CUI_CWindowId, UnsafeMutablePointer<HWND?>?
+    ) -> HRESULT
+    private var hModule: HMODULE!
+    private var getWindowIDFromWindow_impl: pfnGetWindowIdFromWindow!
+    private var getWindowFromWindowID_impl: pfnGetWindowFromWindowId!
+
+    static let shared = HWNDInterop()
+
+    init() {
+        "Microsoft.Internal.FrameworkUdk.dll".withCString(encodedAs: UTF16.self) {
+            hModule = GetModuleHandleW($0)
+            if hModule == nil {
+                hModule = LoadLibraryW($0)
+            }
+        }
+
+        if let pfn = GetProcAddress(hModule, "Windowing_GetWindowIdFromWindow") {
+            getWindowIDFromWindow_impl = unsafeBitCast(pfn, to: pfnGetWindowIdFromWindow.self)
+        }
+
+        if let pfn = GetProcAddress(hModule, "Windowing_GetWindowFromWindowId") {
+            getWindowFromWindowID_impl = unsafeBitCast(pfn, to: pfnGetWindowFromWindowId.self)
+        }
+    }
+
+    fileprivate func getWindowIDFromWindow(_ hWnd: HWND?) -> WinAppSDK.WindowId {
+        var windowID = __x_ABI_CMicrosoft_CUI_CWindowId()
+        let hr: HRESULT = getWindowIDFromWindow_impl(hWnd, &windowID)
+        if hr != S_OK {
+            fatalError("Unable to get window ID")
+        }
+        return .init(value: windowID.Value)
+    }
+
+    fileprivate func getWindowFromWindowId(_ windowID: WinAppSDK.WindowId) -> HWND? {
+        var hWnd: HWND?
+        let hr: HRESULT = getWindowFromWindowID_impl(.from(swift: windowID), &hWnd)
+        if hr != S_OK {
+            fatalError("Unable to get window from window ID")
+        }
+        return hWnd
+    }
+}
diff --git a/Sources/WinUIBackend/WinUIBackend.swift b/Sources/WinUIBackend/WinUIBackend.swift
@@ -5,6 +5,7 @@ import UWP
 import WinAppSDK
 import WinUI
 import WindowsFoundation
+import WinSDK
 
 // Many force tries are required for the WinUI backend but we don't really want them
 // anywhere else so just disable them for this file.
@@ -85,6 +86,9 @@ public final class WinUIBackend: AppBackend {
             // print a warning anyway.
             print("Warning: Failed to attach to parent console: \(error.localizedDescription)")
         }
+        
+        // Ensure that the app's windows adapt to DPI changes at runtime
+        SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2)
 
         WinUIApplication.callback = { application in
             // Toggle Switch has annoying default 'internal margins' (not Control
@@ -112,7 +116,7 @@ public final class WinUIBackend: AppBackend {
         WinUIApplication.main()
     }
 
-    public func createWindow(withDefaultSize size: SIMD2<Int>?) -> Window {
+    public func createWindow(withDefaultSize size: SIMD2<Int>?) -> Window {        
         let window = CustomWindow()
         windows.append(window)
         window.closed.addHandler { _, _ in
@@ -177,9 +181,12 @@ public final class WinUIBackend: AppBackend {
     }
 
     public func setSize(ofWindow window: Window, to newSize: SIMD2<Int>) {
+        let scaleFactor = window.scaleFactor
+        let width = scaleFactor * Double(newSize.x)
+        let height = scaleFactor * Double(newSize.y + CustomWindow.menuBarHeight)
         let size = UWP.SizeInt32(
-            width: Int32(newSize.x),
-            height: Int32(newSize.y + CustomWindow.menuBarHeight)
+            width: Int32(width.rounded(.towardZero)),
+            height: Int32(height.rounded(.towardZero))
         )
         try! window.appWindow.resizeClient(size)
     }
@@ -304,8 +311,9 @@ public final class WinUIBackend: AppBackend {
     public func computeWindowEnvironment(
         window: Window,
         rootEnvironment: EnvironmentValues
-    ) -> EnvironmentValues {
-        // TODO: Record window scale factor in here
+    ) -> EnvironmentValues {        
+        // TODO: Compute window scale factor (easy enough, but we would also have to keep
+        //   it up-to-date then, which is kinda annoying for now)
         rootEnvironment
     }
 
@@ -990,49 +998,49 @@ public final class WinUIBackend: AppBackend {
         }
     }
 
-    // public func showOpenDialog(
-    //     fileDialogOptions: FileDialogOptions,
-    //     openDialogOptions: OpenDialogOptions,
-    //     window: Window?,
-    //     resultHandler handleResult: @escaping (DialogResult<[URL]>) -> Void
-    // ) {
-    //     let picker = FileOpenPicker()
-    //     // TODO: Associate the picker with a window. Requires some janky WinUI
-    //     //   Win32 interop kinda stuff I believe.
-    //     if openDialogOptions.allowMultipleSelections {
-    //         let promise = try! picker.pickMultipleFilesAsync()!
-    //         promise.completed = { operation, status in
-    //             guard
-    //                 status == .completed,
-    //                 let operation,
-    //                 let result = try? operation.getResults()
-    //             else {
-    //                 return
-    //             }
-    //             print(result)
-    //         }
-    //     } else {
-    //         let promise = try! picker.pickSingleFileAsync()!
-    //         promise.completed = { operation, status in
-    //             guard
-    //                 status == .completed,
-    //                 let operation,
-    //                 let result = try? operation.getResults()
-    //             else {
-    //                 return
-    //             }
-    //             print(result)
-    //         }
-    //     }
-    // }
+    public func showOpenDialog(
+        fileDialogOptions: FileDialogOptions,
+        openDialogOptions: OpenDialogOptions,
+        window: Window?,
+        resultHandler handleResult: @escaping (DialogResult<[URL]>) -> Void
+    ) {
+        let picker = FileOpenPicker()
+        // TODO: Associate the picker with a window. Requires some janky WinUI
+        //   Win32 interop kinda stuff I believe.
+        if openDialogOptions.allowMultipleSelections {
+            let promise = try! picker.pickMultipleFilesAsync()!
+            promise.completed = { operation, status in
+                guard
+                    status == .completed,
+                    let operation,
+                    let result = try? operation.getResults()
+                else {
+                    return
+                }
+                print(result)
+            }
+        } else {
+            let promise = try! picker.pickSingleFileAsync()!
+            promise.completed = { operation, status in
+                guard
+                    status == .completed,
+                    let operation,
+                    let result = try? operation.getResults()
+                else {
+                    return
+                }
+                print(result)
+            }
+        }
+    }
 
-    // public func showSaveDialog(
-    //     fileDialogOptions: FileDialogOptions,
-    //     saveDialogOptions: SaveDialogOptions,
-    //     window: Window?,
-    //     resultHandler handleResult: @escaping (DialogResult<URL>) -> Void
-    // ) {
-    // }
+    public func showSaveDialog(
+        fileDialogOptions: FileDialogOptions,
+        saveDialogOptions: SaveDialogOptions,
+        window: Window?,
+        resultHandler handleResult: @escaping (DialogResult<URL>) -> Void
+    ) {
+    }
 
     public func createTapGestureTarget(wrapping child: Widget, gesture: TapGesture) -> Widget {
         if gesture != .primary {
@@ -1215,6 +1223,34 @@ public class CustomWindow: WinUI.Window {
     var menuBar = WinUI.MenuBar()
     var child: WinUIBackend.Widget?
     var grid: WinUI.Grid
+    var cachedAppWindow: WinAppSDK.AppWindow!
+
+    var scaleFactor: Double {
+        // I'm leaving this code here for future travellers. Be warned that this always
+        // seems to return 100% even if the scale factor is set to 125% in settings.
+        // Perhaps it's only the device's built-in default scaling? But that seems pretty
+        // useless, and isn't what the docs seem to imply.
+        //
+        //   var deviceScaleFactor = SCALE_125_PERCENT
+        //   _ = GetScaleFactorForMonitor(monitor, &deviceScaleFactor)
+
+        let hwnd = cachedAppWindow.getHWND()!
+        let monitor = MonitorFromWindow(hwnd, DWORD(bitPattern: MONITOR_DEFAULTTONEAREST))!
+
+        var x: UINT = 0
+        var y: UINT = 0
+        let result = GetDpiForMonitor(monitor, MDT_EFFECTIVE_DPI, &x, &y);
+
+        let windowScaleFactor: Double
+        if result == S_OK {
+            windowScaleFactor = Double(x) / Double(USER_DEFAULT_SCREEN_DPI)
+        } else {
+            print("Warning: Failed to get window scale factor, defaulting to 1.0")
+            windowScaleFactor = 1
+        }
+        
+        return windowScaleFactor
+    }
 
     public override init() {
         grid = WinUI.Grid()
@@ -1232,6 +1268,10 @@ public class CustomWindow: WinUI.Window {
         grid.children.append(menuBar)
         WinUI.Grid.setRow(menuBar, 0)
         self.content = grid
+
+        // Caching appWindow is apparently a good idea in terms of performance:
+        // https://github.com/thebrowsercompany/swift-winrt/issues/199#issuecomment-2611006020
+        cachedAppWindow = appWindow
     }
 
     public func setChild(_ child: WinUIBackend.Widget) {

Original file line number	Diff line number	Diff line change
`@@ -279,7 +279,7 @@ public final class Gtk3Backend: AppBackend {`
`279`	`279`	`rootEnvironment: EnvironmentValues`
`280`	`280`	`) -> EnvironmentValues {`
`281`	`281`	`let windowScaleFactor = Int(gtk_widget_get_scale_factor(window.widgetPointer))`
`282`		`- return rootEnvironment.with(\.windowScaleFactor, windowScaleFactor)`
	`282`	`+ return rootEnvironment.with(\.windowScaleFactor, Double(windowScaleFactor))`
`283`	`283`	`}`
`284`	`284`
`285`	`285`	`public func setWindowEnvironmentChangeHandler(`