Function create_window

native/windows/src/lib.rs:212–270

Returns (hwnd, physical_w, physical_h). Caller's `width`/`height` are *logical* — on a HiDPI monitor with scale 2.0 the window will appear logically the right size while its client area is scaled-up physical pixels for the renderer to fill.

(width: f64, height: f64, title: &str)

    /// will appear logically the right size while its client area is
    /// scaled-up physical pixels for the renderer to fill.
    pub fn create_window(width: f64, height: f64, title: &str) -> (HWND, u32, u32) {
        unsafe {
            // Per-Monitor-Aware-V2: the window's DPI tracks the monitor
            // it's currently on, and Windows fires WM_DPICHANGED when
            // it moves between monitors of different DPI. Without this
            // call, Win32 silently virtualises us to 96 DPI on HiDPI
            // displays — a 4K monitor would render at ~2560×1440.
            // Safe to call early; ignored on pre-Win10 1703.
            let _ = SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);

            let hmodule = GetModuleHandleW(None).unwrap();
            let hinstance: HINSTANCE = hmodule.into();
            let class_name = w!("BloomWindowClass");

            let wc = WNDCLASSEXW {
                cbSize: std::mem::size_of::<WNDCLASSEXW>() as u32,
                style: CS_HREDRAW | CS_VREDRAW,
                lpfnWndProc: Some(wndproc),
                hInstance: hinstance,
                lpszClassName: class_name,
                hCursor: LoadCursorW(None, IDC_ARROW).unwrap(),
                ..Default::default()
            };
            RegisterClassExW(&wc);

            let title_wide: Vec<u16> = title.encode_utf16().chain(std::iter::once(0)).collect();

            // Initial window size in physical pixels. We don't have a
            // window handle yet, so use the system DPI — close enough,
            // and WM_DPICHANGED will resize on the first move if the
            // user lands on a different-DPI monitor.
            let system_dpi = GetDpiForSystem().max(96);
            let scale = system_dpi as f64 / 96.0;
            let phys_w = (width * scale).round() as i32;
            let phys_h = (height * scale).round() as i32;

            let hwnd = CreateWindowExW(
                WINDOW_EX_STYLE::default(),
                class_name,
                PCWSTR(title_wide.as_ptr()),
                WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                CW_USEDEFAULT, CW_USEDEFAULT,
                phys_w, phys_h,
                None, None, Some(&hinstance), None,
            ).unwrap();

            ShowWindow(hwnd, SW_SHOW);
            HWND_GLOBAL = Some(hwnd);

            // After the window exists, query the actual client-area
            // size. Includes whatever DWM trimmed for borders and
            // reflects this monitor's DPI rather than the system one.
            let mut rect = RECT::default();
            let _ = GetClientRect(hwnd, &mut rect);
            let actual_w = (rect.right - rect.left).max(1) as u32;
            let actual_h = (rect.bottom - rect.top).max(1) as u32;
            (hwnd, actual_w, actual_h)
        }