fix(Win32): propagate expansion through navigation wrappers; DPI-scale navigation header

Sources/Backend/Win32/CWin32/d2d1_shim.cpp

@@ -49,7 +49,13 @@ HRESULT d2d1_Factory_CreateHwndRenderTarget(
     D2DRenderTarget *ppTarget
 ) {
     auto f = AS_FACTORY(factory);
+    // The layout engine works in physical pixels, so pin the target's DPI
+    // to 96 (1 DIP = 1 physical pixel). The default (system DPI) would
+    // reinterpret every coordinate as device-independent pixels and
+    // double all sizes on a 200% display.
     D2D1_RENDER_TARGET_PROPERTIES rtProps = D2D1::RenderTargetProperties();
+    rtProps.dpiX = 96.0f;
+    rtProps.dpiY = 96.0f;
     D2D1_HWND_RENDER_TARGET_PROPERTIES hwndProps = D2D1::HwndRenderTargetProperties(
         hwnd, D2D1::SizeU(width, height)
     );

Sources/Backend/Win32/Rendering/LayoutEngine.swift

@@ -5,8 +5,10 @@ import SwiftOpenUI
 /// Measure a text string's size using DirectWrite (preferred) or GDI fallback.
 /// DirectWrite provides more accurate sub-pixel measurement than GDI.
 public func measureText(_ text: String, hwnd: HWND) -> (width: Int32, height: Int32) {
+    // Text renders DPI-scaled, so measure with the scaled default size.
+    let dpiScale = Float(win32_GetDpiForWindow(hwnd)) / 96.0
     // Try DirectWrite first — more accurate and consistent with D2D rendering
-    if let fmt = D2DRenderer.shared.textFormat() {
+    if let fmt = D2DRenderer.shared.textFormat(fontSize: 14 * dpiScale) {
         let (w, h) = D2DRenderer.shared.measureText(text, format: fmt)
         if w > 0 || h > 0 {
             return (width: Int32(w) + 4, height: Int32(h) + 2)
@@ -23,12 +25,13 @@ public func measureText(_ text: String, hwnd: HWND) -> (width: Int32, height: In
         win32_GetTextExtentPoint32W(hdc, wstr, len, &size)
     }
 
-    return (width: size.cx, height: size.cy)
+    return (width: Int32(Double(size.cx) * Double(dpiScale)), height: Int32(Double(size.cy) * Double(dpiScale)))
 }
 
 /// Measure text with a specific font family using DirectWrite.
 public func measureText(_ text: String, fontFamily: String, hwnd: HWND) -> (width: Int32, height: Int32) {
-    if let fmt = D2DRenderer.shared.textFormat(fontFamily: fontFamily) {
+    let dpiScale = Float(win32_GetDpiForWindow(hwnd)) / 96.0
+    if let fmt = D2DRenderer.shared.textFormat(fontFamily: fontFamily, fontSize: 14 * dpiScale) {
         let (w, h) = D2DRenderer.shared.measureText(text, format: fmt)
         if w > 0 || h > 0 {
             return (width: Int32(w) + 4, height: Int32(h) + 2)

Sources/Backend/Win32/Rendering/Win32Backend.swift

@@ -126,7 +126,8 @@ extension WindowGroup: Win32WindowRenderable {
             break
         }
 
-        // Create with default size initially; we'll resize after rendering content
+        // Create at the system default size (CW_USEDEFAULT); resize to the
+        // specified size after rendering content.
         let titleWide: [WCHAR] = Array(title.utf16) + [0]
         let hwnd = titleWide.withUnsafeBufferPointer { titlePtr in
             className.withUnsafeBufferPointer { classPtr in
@@ -136,7 +137,7 @@ extension WindowGroup: Win32WindowRenderable {
                     titlePtr.baseAddress!,
                     style,
                     Int32(CW_USEDEFAULT), Int32(CW_USEDEFAULT),
-                    500, 600,
+                    Int32(CW_USEDEFAULT), Int32(CW_USEDEFAULT),
                     nil,
                     nil,
                     hInstance,
@@ -161,48 +162,41 @@ extension WindowGroup: Win32WindowRenderable {
             let naturalContentW = contentRect.right - contentRect.left
             let naturalContentH = contentRect.bottom - contentRect.top
 
-            let desiredClientSize: (Int32, Int32) = {
-                switch windowSizing ?? .automatic {
-                case .automatic, .content, .contentFixed:
-                    return (naturalContentW + 20, naturalContentH + 20)
-                case .size(let width, let height):
-                    return (Int32(width), Int32(height))
-                }
-            }()
-
+            // The window starts at the system default size (CW_USEDEFAULT).
+            // Resize it only when the app specifies a size.
             let screenW = GetSystemMetrics(SM_CXSCREEN)
             let screenH = GetSystemMetrics(SM_CYSCREEN)
-            // When explicit sizing is provided (defaultWindowSize or windowSizing(.size)),
-            // don't enforce 300x200 minimum — the developer chose the size.
-            let hasExplicitSize = defaultWindowWidth != nil || defaultWindowHeight != nil || {
-                if case .size = windowSizing ?? .automatic { return true }
-                if case .contentFixed = windowSizing ?? .automatic { return true }
-                return false
-            }()
-            let minClientW = minWindowWidth.map { Int32($0) } ?? (hasExplicitSize ? 1 : 300)
-            let minClientH = minWindowHeight.map { Int32($0) } ?? (hasExplicitSize ? 1 : 200)
-            let maxClientW = maxWindowWidth.map { Int32($0) } ?? (screenW * 3 / 4)
-            let maxClientH = maxWindowHeight.map { Int32($0) } ?? (screenH * 3 / 4)
-
-            let defaultClientW = defaultWindowWidth.map { Int32($0) }
-            let defaultClientH = defaultWindowHeight.map { Int32($0) }
-            let automaticDefaultClientSize: (Int32?, Int32?) = {
-                if case .automatic = windowSizing ?? .automatic {
-                    return (Int32(defaultAutomaticWindowWidth), Int32(defaultAutomaticWindowHeight))
+            // Scale by the existing window's DPI.
+            let dpiScale = Double(win32_GetDpiForWindow(hwnd)) / 96.0
+            let minClientW = minWindowWidth.map { Int32(Double($0) * dpiScale) }
+            let minClientH = minWindowHeight.map { Int32(Double($0) * dpiScale) }
+            let maxClientW = maxWindowWidth.map { Int32(Double($0) * dpiScale) } ?? (screenW * 3 / 4)
+            let maxClientH = maxWindowHeight.map { Int32(Double($0) * dpiScale) } ?? (screenH * 3 / 4)
+
+            var requestedSize: (Int32, Int32)?
+            if let dw = defaultWindowWidth, let dh = defaultWindowHeight {
+                requestedSize = (Int32(Double(dw) * dpiScale), Int32(Double(dh) * dpiScale))
+            } else if let sizing = windowSizing {
+                switch sizing {
+                case .size(let width, let height):
+                    requestedSize = (Int32(Double(width) * dpiScale), Int32(Double(height) * dpiScale))
+                case .content, .contentFixed:
+                    requestedSize = (naturalContentW + 20, naturalContentH + 20)
+                case .automatic:
+                    break
                 }
-                return (nil, nil)
-            }()
-            let unclampedW = defaultClientW ?? automaticDefaultClientSize.0 ?? desiredClientSize.0
-            let unclampedH = defaultClientH ?? automaticDefaultClientSize.1 ?? desiredClientSize.1
-            let clientW = max(minClientW, min(unclampedW, maxClientW))
-            let clientH = max(minClientH, min(unclampedH, maxClientH))
-
-            let windowSize = adjustedWindowSize(clientWidth: clientW, clientHeight: clientH, style: style)
-            SetWindowPos(hwnd, nil,
-                         Int32(CW_USEDEFAULT), Int32(CW_USEDEFAULT),
-                         windowSize.0,
-                         windowSize.1,
-                         UINT(SWP_NOMOVE | SWP_NOZORDER))
+            }
+
+            if let (reqW, reqH) = requestedSize {
+                let clientW = max(minClientW ?? 1, min(reqW, maxClientW))
+                let clientH = max(minClientH ?? 1, min(reqH, maxClientH))
+                let windowSize = adjustedWindowSize(clientWidth: clientW, clientHeight: clientH, style: style)
+                SetWindowPos(hwnd, nil,
+                             Int32(CW_USEDEFAULT), Int32(CW_USEDEFAULT),
+                             windowSize.0,
+                             windowSize.1,
+                             UINT(SWP_NOMOVE | SWP_NOZORDER))
+            }
 
             // SwiftUI's WindowGroup centers intrinsically-sized root content
             // (e.g. a plain Text) and stretches fill-semantic roots (e.g. a
@@ -283,13 +277,20 @@ private let mainWindowProc: WNDPROC = { (hwnd, uMsg, wParam, lParam) in
         let userData = win32_GetWindowLongPtrW(hwnd!, GWLP_USERDATA)
         if userData != 0, let info = UnsafeMutablePointer<MINMAXINFO>(bitPattern: Int(lParam)) {
             let state = Unmanaged<MainWindowState>.fromOpaque(UnsafeMutableRawPointer(bitPattern: Int(userData))!).takeUnretainedValue()
+            let dpiScale = Double(win32_GetDpiForWindow(hwnd!)) / 96.0
             if let minW = state.minClientWidth, let minH = state.minClientHeight {
-                let adjusted = adjustedWindowSize(clientWidth: minW, clientHeight: minH, style: state.style)
+                let adjusted = adjustedWindowSize(
+                    clientWidth: Int32(Double(minW) * dpiScale),
+                    clientHeight: Int32(Double(minH) * dpiScale),
+                    style: state.style)
                 info.pointee.ptMinTrackSize.x = LONG(adjusted.0)
                 info.pointee.ptMinTrackSize.y = LONG(adjusted.1)
             }
             if let maxW = state.maxClientWidth, let maxH = state.maxClientHeight {
-                let adjusted = adjustedWindowSize(clientWidth: maxW, clientHeight: maxH, style: state.style)
+                let adjusted = adjustedWindowSize(
+                    clientWidth: Int32(Double(maxW) * dpiScale),
+                    clientHeight: Int32(Double(maxH) * dpiScale),
+                    style: state.style)
                 info.pointee.ptMaxTrackSize.x = LONG(adjusted.0)
                 info.pointee.ptMaxTrackSize.y = LONG(adjusted.1)
             }
@@ -768,11 +769,8 @@ extension Window: Win32WindowRenderable {
         }
 
         let style = DWORD(WS_OVERLAPPEDWINDOW)
-        let clientW = defaultWindowWidth.map { Int32($0) } ?? 400
-        let clientH = defaultWindowHeight.map { Int32($0) } ?? 300
-        let windowSize = adjustedWindowSize(
-            clientWidth: clientW, clientHeight: clientH, style: style)
-
+        // Create at the system default size (CW_USEDEFAULT); resize to the
+        // specified logical size (DPI-scaled) once the window exists.
         let titleWide: [WCHAR] = Array(title.utf16) + [0]
         let hwnd = titleWide.withUnsafeBufferPointer { titlePtr in
             classNameWide.withUnsafeBufferPointer { classPtr in
@@ -782,7 +780,7 @@ extension Window: Win32WindowRenderable {
                     titlePtr.baseAddress!,
                     style,
                     Int32(CW_USEDEFAULT), Int32(CW_USEDEFAULT),
-                    windowSize.0, windowSize.1,
+                    Int32(CW_USEDEFAULT), Int32(CW_USEDEFAULT),
                     nil, nil, hInstance, nil
                 )
             }
@@ -833,6 +831,17 @@ extension Window: Win32WindowRenderable {
         let windowId = id
         Win32WindowRegistry.shared.setLiveWindow(id: windowId, hwnd: hwnd)
 
+        // Resize to the specified logical size, scaled by this window's DPI.
+        if let dw = defaultWindowWidth, let dh = defaultWindowHeight {
+            let dpiScale = Double(win32_GetDpiForWindow(hwnd)) / 96.0
+            let scaledSize = adjustedWindowSize(
+                clientWidth: Int32(Double(dw) * dpiScale),
+                clientHeight: Int32(Double(dh) * dpiScale),
+                style: style)
+            SetWindowPos(hwnd, nil, 0, 0, scaledSize.0, scaledSize.1,
+                         UINT(SWP_NOMOVE | SWP_NOZORDER))
+        }
+
         ShowWindow(hwnd, SW_SHOWDEFAULT)
         UpdateWindow(hwnd)
     }
@@ -864,9 +873,12 @@ private let windowSceneWndProc: WNDPROC = { (hwnd, uMsg, wParam, lParam) in
             let state = Unmanaged<MainWindowState>.fromOpaque(
                 UnsafeMutableRawPointer(bitPattern: Int(userData))!
             ).takeUnretainedValue()
+            let dpiScale = Double(win32_GetDpiForWindow(hwnd!)) / 96.0
             if let minW = state.minClientWidth, let minH = state.minClientHeight {
                 let adjusted = adjustedWindowSize(
-                    clientWidth: minW, clientHeight: minH, style: state.style)
+                    clientWidth: Int32(Double(minW) * dpiScale),
+                    clientHeight: Int32(Double(minH) * dpiScale),
+                    style: state.style)
                 info.pointee.ptMinTrackSize.x = LONG(adjusted.0)
                 info.pointee.ptMinTrackSize.y = LONG(adjusted.1)
             }

Sources/Backend/Win32/Rendering/Win32Navigation.swift

@@ -299,23 +299,42 @@ private let navContainerWndProc: WNDPROC = { (hwnd, uMsg, wParam, lParam) in
     }
 }
 
+/// Measure the back button text with the title font (the font applied
+/// to the button via WM_SETFONT). Querying the button for its font here
+/// would re-enter the control while it processes a message.
+private func measureBackButton(ctx: Win32NavigationContext) -> Int32 {
+    let hdc = GetDC(ctx.backButton)
+    defer { ReleaseDC(ctx.backButton, hdc) }
+    var size = SIZE()
+    "← Back".withCString(encodedAs: UTF16.self) { wstr in
+        let len = Int32(wcslen(wstr))
+        let old = ctx.titleFont.flatMap { SelectObject(hdc, $0) }
+        win32_GetTextExtentPoint32W(hdc, wstr, len, &size)
+        if let old = old { SelectObject(hdc, old) }
+    }
+    return size.cx
+}
+
 /// Layout the navigation container: header bar at top, content area fills the rest.
 private func layoutNavContainer(_ ctx: Win32NavigationContext) {
     var rect = RECT()
     GetClientRect(ctx.container, &rect)
     let w = rect.right - rect.left
     let h = rect.bottom - rect.top
 
-    let headerHeight: Int32 = 32
+    // Header sizes are physical px; scale the 96-DPI defaults by the window DPI.
+    let dpiScale = Int32(Double(win32_GetDpiForWindow(ctx.container)) / 96.0)
+    let headerHeight: Int32 = 32 * dpiScale
     SetWindowPos(ctx.headerContainer, nil, 0, 0, w, headerHeight, UINT(SWP_NOZORDER))
 
     // Layout back button (child of headerContainer)
     let backVisible = IsWindowVisible(ctx.backButton) != false
-    let backWidth: Int32 = backVisible ? 60 : 0
+    let backWidth: Int32 = backVisible ? measureBackButton(ctx: ctx) + 16 * dpiScale : 0
     if backVisible {
         SetWindowPos(ctx.backButton, nil, 4, 4, backWidth - 8, headerHeight - 8, UINT(SWP_NOZORDER))
     }
-    SetWindowPos(ctx.titleLabel, nil, backWidth + 4, 0, w - backWidth - 8, headerHeight, UINT(SWP_NOZORDER))
+    SetWindowPos(ctx.titleLabel, nil, backWidth + 4, 0,
+                 w - backWidth - 8, headerHeight, UINT(SWP_NOZORDER))
 
     // Content area fills the rest
     SetWindowPos(ctx.contentArea, nil, 0, headerHeight, w, h - headerHeight, UINT(SWP_NOZORDER))
@@ -341,11 +360,14 @@ extension NavigationStack: WinRenderable {
             context.parent, nil, context.hInstance, nil
         )!
 
-        // Header bar (background: button face color)
+        // Header bar (background: button face color). Sizes are physical
+        // pixels, so scale the 96-DPI defaults by the window's DPI.
+        let dpiScale = Int32(Double(win32_GetDpiForWindow(container)) / 96.0)
+        let headerHeight: Int32 = 32 * dpiScale
         let headerContainer = CreateWindowExW(
             0, stackContainerClassName, nil,
             DWORD(WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN),
-            0, 0, 0, 32,
+            0, 0, 0, headerHeight,
             container, nil, context.hInstance, nil
         )!
 
@@ -357,7 +379,7 @@ extension NavigationStack: WinRenderable {
         let backButton = "← Back".withCString(encodedAs: UTF16.self) { wstr in
             win32_CreateChildWindow(
                 win32_WC_BUTTON(), wstr, DWORD(BS_PUSHBUTTON),
-                0, 0, 60, 24,
+                0, 0, 60 * dpiScale, 24 * dpiScale,
                 headerContainer,
                 HMENU(bitPattern: UInt(backControlID)),
                 context.hInstance
@@ -371,19 +393,23 @@ extension NavigationStack: WinRenderable {
         // Title label
         let titleLabel = win32_CreateChildWindow(
             win32_WC_STATIC(), nil, DWORD(SS_CENTER | SS_CENTERIMAGE),
-            0, 0, 0, 32,
+            0, 0, 0, headerHeight,
             headerContainer, nil, context.hInstance
         )!
 
-        // Apply bold font to title (tracked for cleanup in context deinit)
+        // Apply bold font to title (tracked for cleanup in context deinit).
+        // -height is physical px; scale the 16px default by the window DPI.
         let titleFont = "Segoe UI".withCString(encodedAs: UTF16.self) { namePtr in
-            CreateFontW(-16, 0, 0, 0, FW_BOLD, 0, 0, 0,
+            CreateFontW(-16 * dpiScale, 0, 0, 0, FW_BOLD, 0, 0, 0,
                         DWORD(DEFAULT_CHARSET), DWORD(OUT_DEFAULT_PRECIS),
                         DWORD(CLIP_DEFAULT_PRECIS), DWORD(CLEARTYPE_QUALITY),
                         DWORD(DEFAULT_PITCH), namePtr)
         }
         if let f = titleFont {
             SendMessageW(titleLabel, UINT(WM_SETFONT), WPARAM(UInt(bitPattern: f)), 1)
+            // The native button's default font is not DPI-scaled; use the
+            // same scaled font as the title.
+            SendMessageW(backButton, UINT(WM_SETFONT), WPARAM(UInt(bitPattern: f)), 1)
         }
 
         // Content area
@@ -436,7 +462,6 @@ extension NavigationStack: WinRenderable {
         setCurrentNavigationContext(nil)
 
         // Add root as first entry and size the nav container
-        let headerHeight: Int32 = 32
         if let rootHwnd = rootHwnd {
             // Get root content's natural size
             var rootRect = RECT()
@@ -459,6 +484,10 @@ extension NavigationStack: WinRenderable {
                          caRect.right, caRect.bottom, UINT(SWP_NOZORDER))
 
             navCtx.entries.append(Win32NavigationEntry(title: title, hwnd: rootHwnd))
+            // Propagate the root content's expansion so the stack fills
+            // its available space.
+            if shouldExpandWidth(rootHwnd) { markExpandWidth(container) }
+            if shouldExpandHeight(rootHwnd) { markExpandHeight(container) }
         }
 
         // Set initial title

Sources/Backend/Win32/Rendering/WinRenderer.swift

@@ -1333,7 +1333,8 @@ class FlatButtonState {
             tr = textColorR ?? 0.1; tg = textColorG ?? 0.1; tb = textColorB ?? 0.1
         }
         d2d1_SolidColorBrush_SetColor(brush, tr, tg, tb, 1)
-        if let fmt = customTextFormat ?? D2DRenderer.shared.textFormat() {
+        let dpiScale = Float(win32_GetDpiForWindow(hwnd)) / 96.0
+        if let fmt = customTextFormat ?? D2DRenderer.shared.textFormat(fontSize: 14 * dpiScale) {
             dwrite_TextFormat_SetTextAlignment(fmt, 2) // center
             D2DRenderer.shared.drawText(title, target: rt, format: fmt,
                                          brush: brush, x: 0, y: 0, width: w, height: h)
@@ -4252,7 +4253,8 @@ extension Image: WinRenderable {
             )
         }
 
-        let size = Int32(scale.pointSize) + 4
+        // Box must track the DPI-scaled font height or the glyph is cropped.
+        let size = Int32(Double(scale.pointSize) * dpiScale) + 4
         // SS_CENTER | SS_CENTERIMAGE center the glyph within its box so the
         // icon sits centered rather than top-left.
         let hwnd = glyph.withCString(encodedAs: UTF16.self) { wstr in
@@ -7052,6 +7054,12 @@ extension NavigationSplitView: WinRenderable {
         SetWindowPos(container, nil, 0, 0, max(w, 400), max(h, 300),
                      UINT(SWP_NOZORDER | SWP_NOMOVE))
 
+        // Propagate the columns' expansion so the split view fills its
+        // available space (SwiftUI/GTK4 behavior).
+        let columnHwnds = [sidebarHwnd, contentHwnd, detailHwnd].compactMap { $0 }
+        if columnHwnds.contains(where: { shouldExpandWidth($0) }) { markExpandWidth(container) }
+        if columnHwnds.contains(where: { shouldExpandHeight($0) }) { markExpandHeight(container) }
+
         return container
     }
 }

Sources/SwiftOpenUISymbols/MaterialSymbolsCodepoints.swift

@@ -73,6 +73,12 @@ public enum MaterialSymbolsCodepoints {
         "info":                0xE88E,
         "verified":            0xEF76,
         "warning":             0xE002,
+        // Devices / media
+        "fiber_manual_record": 0xE061,
+        "history":             0xE889,
+        "no_sim":              0xE0CE,
+        "photo_camera":        0xE412,
+        "smartphone":          0xE32C,
 
         // Common actions
         "add":                 0xE145,