@bobfrankston/winpos 2.0.51 → 2.0.52

package/README.md

@@ -89,6 +89,7 @@ Screens are numbered starting from 0, sorted by position:
 - `-title <name>` - Window title/pattern (alternative to positional)
 - `-pos x,y[,screen]` - Position (comma-separated, screen optional)
 - `-size w,h` - Window size (width,height)
+- `-numsize <inches>` - Physical size of the screen-number overlays (default 2)
 - `-min` - Minimize window
 - `-max` - Maximize window
 - `-load <file>` - Load config from JSON file
@@ -109,10 +110,22 @@ and all appear at once. They close themselves; winpos returns immediately
 without waiting for them. If msger is unavailable the listing still works, just
 without the numbers.
 
+Each overlay is 2 inches square **on the glass**, not 2 inches' worth of pixels
+- `-numsize <inches>` changes that. Sizing anything in pixels (or in CSS
+inches, which are just 96 pixels) comes out a different physical size on every
+monitor, because Windows' scale factor is a preference rather than a
+measurement: a 28" 4K panel left at 100% claims 96 DPI while really being 160.
+winpos asks the display driver for the panel's physical millimetres (EDID, via
+a GDI display DC) and works out each screen's true DPI, so the same square of
+glass lights up on every monitor. Drivers that report nothing fall back to the
+old pixel sizing.
+
 ```typescript
-import { showScreenNumbers, enumerateScreens, sortScreens } from '@bobfrankston/winpos';
+import { showScreenNumbers, enumerateScreens, sortScreens, screenDpi } from '@bobfrankston/winpos';
 
-await showScreenNumbers(sortScreens(enumerateScreens()), 5);
+const screens = sortScreens(enumerateScreens());
+await showScreenNumbers(screens, 5, 2);     // 5 seconds, 2 inches
+console.log(screens.map(screenDpi));        // True DPI per screen
 ```
 
 ## Parameters

package/ffi-wrapper.d.ts

@@ -25,6 +25,8 @@ export interface MONITORINFO {
     rcMonitor: RECT;
     rcWork: RECT;
     dwFlags: number;
+    /** Display device name, e.g. \\.\DISPLAY1 (MONITORINFOEXW szDevice) */
+    szDevice?: string;
 }
 export declare const MONITORINFOF_PRIMARY = 1;
 export declare const DEFAULT_SCALE_PERCENT = 100;
@@ -42,6 +44,11 @@ export interface WindowsAPI {
     GetMonitorInfoW: (hMonitor: bigint, lpmi: any) => boolean;
     /** Monitor scale factor as a percent (100, 125, 150...). 100 when unavailable. */
     GetScaleFactorForMonitor?: (hMonitor: bigint) => number;
+    /** Physical panel size in millimetres from the display driver (EDID). Null when unavailable. */
+    GetPhysicalSizeMm?: (deviceName: string) => {
+        width: number;
+        height: number;
+    } | null;
 }
 declare const user32: WindowsAPI;
 export { user32, isBun };

package/ffi-wrapper.js

@@ -16,6 +16,9 @@ export const SW_MINIMIZE = 6;
 export const SW_SHOWMINNOACTIVE = 7;
 export const SW_SHOWNA = 8;
 export const SW_RESTORE = 9;
+// GetDeviceCaps indices for the panel's physical size in millimetres
+const HORZSIZE = 4;
+const VERTSIZE = 6;
 export const MONITORINFOF_PRIMARY = 1;
 // Monitor scale factor as a percentage (100 = no scaling, 125 = 125%)
 export const DEFAULT_SCALE_PERCENT = 100;
@@ -110,6 +113,21 @@ async function initializeFFI() {
     catch {
         // Leave null - callers fall back to 100%
     }
+    // A display DC reports the panel's physical size in millimetres, straight
+    // from the driver's EDID. That is the only measurement of a monitor
+    // available: the scale factor above is a user preference, so a 160 DPI
+    // panel left at 100% claims to be a 96 DPI one. Optional, like shcore -
+    // callers fall back to nominal DPI when this returns null.
+    let CreateDCW = null, GetDeviceCaps = null, DeleteDC = null;
+    try {
+        const gdi32 = koffi.load('gdi32.dll');
+        CreateDCW = gdi32.func('void * __stdcall CreateDCW(const char16_t *pwszDriver, const char16_t *pwszDevice, const char16_t *pszPort, const void *pdm)');
+        GetDeviceCaps = gdi32.func('int __stdcall GetDeviceCaps(void *hdc, int index)');
+        DeleteDC = gdi32.func('bool __stdcall DeleteDC(void *hdc)');
+    }
+    catch {
+        CreateDCW = null;
+    }
     // Keep references to registered callbacks to prevent garbage collection
     // These must persist for the entire duration of the native callback invocation
     const __callbackRefs = [];
@@ -154,14 +172,18 @@ async function initializeFFI() {
             return result;
         },
         GetMonitorInfoW: (hMonitor, lpmi) => {
-            // MONITORINFO structure:
+            // MONITORINFOEXW structure:
             // DWORD cbSize (4 bytes)
             // RECT rcMonitor (16 bytes)
             // RECT rcWork (16 bytes)
             // DWORD dwFlags (4 bytes)
-            // Total: 40 bytes
-            const buffer = Buffer.alloc(40);
-            buffer.writeUInt32LE(40, 0); // cbSize
+            // WCHAR szDevice[32] (64 bytes) - the EX part, and the reason for
+            //   asking: the device name is what gdi32 wants to open a DC on
+            //   this monitor, and the only reliable tie from an HMONITOR to a
+            //   \\.\DISPLAYn. cbSize is what selects EX over plain MONITORINFO.
+            // Total: 104 bytes
+            const buffer = Buffer.alloc(104);
+            buffer.writeUInt32LE(104, 0); // cbSize
             const result = GetMonitorInfoW(hMonitor, buffer);
             if (result) {
                 lpmi.cbSize = buffer.readUInt32LE(0);
@@ -178,6 +200,9 @@ async function initializeFFI() {
                     Bottom: buffer.readInt32LE(32),
                 };
                 lpmi.dwFlags = buffer.readUInt32LE(36);
+                const device = buffer.toString('utf16le', 40, 104);
+                const end = device.indexOf('\0');
+                lpmi.szDevice = end >= 0 ? device.substring(0, end) : device;
             }
             return result;
         },
@@ -188,6 +213,32 @@ async function initializeFFI() {
             const hr = GetScaleFactorForMonitorRaw(hMonitor, scale);
             return hr === 0 ? (scale.readUInt32LE(0) || DEFAULT_SCALE_PERCENT) : DEFAULT_SCALE_PERCENT;
         },
+        GetPhysicalSizeMm: (deviceName) => {
+            if (!CreateDCW || !deviceName)
+                return null;
+            let hdc = null;
+            try {
+                // An information DC would do, but CreateDCW on the DISPLAY
+                // driver is what every monitor exposes; the caps are the same.
+                hdc = CreateDCW('DISPLAY', deviceName, null, null);
+                if (!hdc)
+                    return null;
+                const width = GetDeviceCaps(hdc, HORZSIZE);
+                const height = GetDeviceCaps(hdc, VERTSIZE);
+                return width > 0 && height > 0 ? { width, height } : null;
+            }
+            catch {
+                return null; // Best-effort: no measurement is not an error
+            }
+            finally {
+                if (hdc) {
+                    try {
+                        DeleteDC(hdc);
+                    }
+                    catch { /* nothing useful to do */ }
+                }
+            }
+        },
     };
 }
 const user32 = await initializeFFI();

package/index.d.ts

@@ -4,10 +4,10 @@
  * Cross-platform Node.js/Bun implementation with FFI
  */
 import { user32, RECT } from './ffi-wrapper.js';
-import { enumerateScreens, sortScreens, ScreenInfo } from './screens.js';
+import { enumerateScreens, sortScreens, screenScale, screenDpi, ScreenInfo } from './screens.js';
 import { enumerateWindows, findWindowsByPattern, WindowInfo, WindowState, getWindowState, setWindowState, isMinimized, isMaximized, isNormal, minimizeWindow, maximizeWindow, restoreWindow } from './windows.js';
 import { enumerateTabs, TabInfo, mightHaveTabs, TAB_ENUMERATION_NOTE } from './tabs.js';
-import { showScreenNumbers } from './screennums.js';
+import { showScreenNumbers, OVERLAY_SECONDS, OVERLAY_INCHES } from './screennums.js';
 export interface WindowConfig {
     name: string;
     regex?: boolean;
@@ -24,7 +24,7 @@ export interface WindowConfig {
     maximize?: boolean;
 }
 export type ConfigFile = WindowConfig | WindowConfig[];
-export { RECT, ScreenInfo, WindowInfo, WindowState, TabInfo, enumerateScreens, sortScreens, enumerateWindows, findWindowsByPattern, getWindowState, setWindowState, isMinimized, isMaximized, isNormal, minimizeWindow, maximizeWindow, restoreWindow, enumerateTabs, mightHaveTabs, TAB_ENUMERATION_NOTE, showScreenNumbers, user32 };
+export { RECT, ScreenInfo, WindowInfo, WindowState, TabInfo, enumerateScreens, sortScreens, screenScale, screenDpi, enumerateWindows, findWindowsByPattern, getWindowState, setWindowState, isMinimized, isMaximized, isNormal, minimizeWindow, maximizeWindow, restoreWindow, enumerateTabs, mightHaveTabs, TAB_ENUMERATION_NOTE, showScreenNumbers, OVERLAY_INCHES, OVERLAY_SECONDS, user32 };
 /**
  * Convert screen-relative coordinates to global coordinates
  * @param x - X coordinate relative to screen

package/index.js

@@ -4,16 +4,16 @@
  * Cross-platform Node.js/Bun implementation with FFI
  */
 import { user32 } from './ffi-wrapper.js';
-import { enumerateScreens, sortScreens } from './screens.js';
+import { enumerateScreens, sortScreens, screenScale, screenDpi } from './screens.js';
 import { enumerateWindows, findWindowsByPattern, loadIgnorePatterns, WindowState, getWindowState, setWindowState, isMinimized, isMaximized, isNormal, minimizeWindow, maximizeWindow, restoreWindow } from './windows.js';
 import { enumerateTabs, mightHaveTabs, TAB_ENUMERATION_NOTE } from './tabs.js';
-import { showScreenNumbers, OVERLAY_SECONDS } from './screennums.js';
+import { showScreenNumbers, OVERLAY_SECONDS, OVERLAY_INCHES } from './screennums.js';
 import { join, resolve, isAbsolute } from 'path';
 import { readFileSync, writeFileSync, existsSync } from 'fs';
 import { parse as parseJsonc, printParseErrorCode } from 'jsonc-parser';
 import * as packageJson from './package.json' with { type: 'json' };
 // Re-export public API for library usage
-export { WindowState, enumerateScreens, sortScreens, enumerateWindows, findWindowsByPattern, getWindowState, setWindowState, isMinimized, isMaximized, isNormal, minimizeWindow, maximizeWindow, restoreWindow, enumerateTabs, mightHaveTabs, TAB_ENUMERATION_NOTE, showScreenNumbers, user32 };
+export { WindowState, enumerateScreens, sortScreens, screenScale, screenDpi, enumerateWindows, findWindowsByPattern, getWindowState, setWindowState, isMinimized, isMaximized, isNormal, minimizeWindow, maximizeWindow, restoreWindow, enumerateTabs, mightHaveTabs, TAB_ENUMERATION_NOTE, showScreenNumbers, OVERLAY_INCHES, OVERLAY_SECONDS, user32 };
 // WindowConfig and ConfigFile types are exported from interface definitions above
 // Note: screenPosToPos is exported separately below (after the function definition)
 /**
@@ -179,6 +179,16 @@ function parseArgs(args) {
                         opts.windowTitle = args[i];
                     }
                     break;
+                case 'numsize':
+                    i++;
+                    if (i < args.length) {
+                        const inches = parseFloat(args[i]);
+                        if (inches > 0)
+                            opts.numSize = inches;
+                        else
+                            console.log(`Ignoring -numsize ${args[i]}: expected a size in inches`);
+                    }
+                    break;
                 case 'min':
                     opts.minimize = true;
                     break;
@@ -289,6 +299,7 @@ function applyWindowConfig(config, screensInfo) {
 let dbg = false;
 let dbgVerbose = false; // -dbg flag for detailed output
 let screens = [];
+let numSize = OVERLAY_INCHES; // -numsize: screen-number overlay size in inches
 /**
  * Convert screen-relative coordinates to global coordinates
  * @param x - X coordinate relative to screen
@@ -450,7 +461,7 @@ function listAllWindows(includeIgnored = false) {
     console.log('Command format: tswinpos <title> <x> <y> <screen> [<width> <height>]');
     // Flash each screen's number on that screen - launched last so the overlays
     // can't turn up in the listing above. Detached, so we don't wait for them.
-    void showScreenNumbers(screens);
+    void showScreenNumbers(screens, OVERLAY_SECONDS, numSize);
 }
 function usage(msg = '') {
     printUsage(msg);
@@ -478,6 +489,7 @@ function printUsage(msg = '') {
     console.log('  -title name Window title/pattern (alternative to positional)');
     console.log('  -pos x,y[,s] Position (x,y with optional screen index)');
     console.log('  -size w,h   Window size (width,height)');
+    console.log(`  -numsize n  Screen-number overlay size in inches (default ${OVERLAY_INCHES})`);
     console.log('  -min        Minimize window');
     console.log('  -max        Maximize window');
     console.log('  -load file  Load config from JSON/JSONC file (comments + trailing commas OK)');
@@ -519,6 +531,8 @@ export function run(args) {
     // Set debug flags
     dbg = opts.debug;
     dbgVerbose = opts.debugVerbose;
+    if (opts.numSize)
+        numSize = opts.numSize;
     if (dbg)
         console.log('Debug mode enabled.');
     if (dbgVerbose)
@@ -615,7 +629,7 @@ export function run(args) {
     // themselves; we only wait for the launch, because process.exit here would
     // kill the spawn in mid-flight and no numbers would ever appear.
     if (posArgs.length === 0) {
-        const overlays = showScreenNumbers(screens);
+        const overlays = showScreenNumbers(screens, OVERLAY_SECONDS, numSize);
         printUsage();
         void overlays.finally(() => process.exit(1));
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/winpos",
-  "version": "2.0.51",
+  "version": "2.0.52",
   "description": "TypeScript implementation of winpos - Windows window positioning utility",
   "type": "module",
   "main": "index.js",

package/screennums.d.ts

@@ -7,6 +7,8 @@
  * self-closing, so winpos exits immediately and leaves them up.
  */
 import { type ScreenInfo } from './screens.js';
+/** Default overlay size, in real inches on the glass */
+export declare const OVERLAY_INCHES = 2;
 export declare const OVERLAY_SECONDS = 5;
 /**
  * Show the index of every screen in the middle of that screen.
@@ -16,6 +18,7 @@ export declare const OVERLAY_SECONDS = 5;
  *
  * @param screens - Screens in winpos order (the index shown is the array index)
  * @param seconds - How long each overlay stays up
+ * @param inches - Size of each overlay in real inches, measured on the glass
  */
-export declare function showScreenNumbers(screens: ScreenInfo[], seconds?: number): Promise<void>;
+export declare function showScreenNumbers(screens: ScreenInfo[], seconds?: number, inches?: number): Promise<void>;
 //# sourceMappingURL=screennums.d.ts.map

package/screennums.js

@@ -6,13 +6,33 @@
  * Rendered with msger (@bobfrankston/msger). The overlays are detached and
  * self-closing, so winpos exits immediately and leaves them up.
  */
-import { screenScale } from './screens.js';
-const CARD = 260; // Overlay content size in pixels (square)
-const FRAME_W = 16; // Window border added around that content
-const FRAME_H = 46; // Border + title bar
+import { screenDpi, screenScale } from './screens.js';
+/** Default overlay size, in real inches on the glass */
+export const OVERLAY_INCHES = 2;
 export const OVERLAY_SECONDS = 5;
+// Guard rails for the computed window size, in case a driver's reported
+// dimensions survive the DPI sanity check but still make no sense.
+const MIN_CARD = 80;
+const MAX_CARD = 1200;
+/**
+ * Overlay size in logical pixels so it measures `inches` on that panel.
+ *
+ * Pixels are not a length: the same 360-pixel square is 3.9 inches on a 93 DPI
+ * 32" 1440p panel and 2.2 inches on a 160 DPI 28" 4K one. Going through the
+ * screen's true DPI is what makes the number the same physical size on every
+ * monitor. The scale factor divides back out because msger positions and sizes
+ * windows in logical pixels, which Windows then multiplies by that factor.
+ */
+function cardSize(screen, inches) {
+    const dips = (inches * screenDpi(screen)) / screenScale(screen);
+    return Math.round(Math.min(MAX_CARD, Math.max(MIN_CARD, dips)));
+}
 /**
  * Full page for one overlay - big number, no msger template or buttons.
+ *
+ * Everything is sized in vh so the page fits whatever window the caller asked
+ * for: the window is what carries the physical size, and the digit is simply a
+ * fraction of it.
  */
 function overlayHtml(index, screen, seconds) {
     const b = screen.bounds;
@@ -26,18 +46,28 @@ function overlayHtml(index, screen, seconds) {
     return `<!doctype html>
 <html><head><meta charset="utf-8"><title>winpos screen ${index}</title>
 <style>
-  html, body { height: 100%; margin: 0; }
+  html, body { height: 100%; margin: 0; background: transparent; }
   body {
-    display: flex; flex-direction: column;
-    align-items: center; justify-content: center;
-    background: #1e1e1e; color: #f0f0f0;
+    display: flex; align-items: center; justify-content: center;
     font-family: "Segoe UI", system-ui, sans-serif;
     user-select: none;
   }
-  .num { font-size: 160px; font-weight: 700; line-height: 1; }
-  .label { font-size: 16px; opacity: 0.65; margin-top: 12px; }
+  .card {
+    display: flex; flex-direction: column;
+    align-items: center; justify-content: center;
+    width: 100%; height: 100%;
+    box-sizing: border-box;
+    /* Solid black, white digits - the highest-contrast reading of the number.
+       msger's overlay window composites onto white rather than the desktop
+       here, so a translucent background just came out gray; painting it
+       opaque is both clearer and honest about what's actually drawn. */
+    background: #000000;
+    color: #ffffff;
+  }
+  .num { font-size: 62vh; font-weight: 700; line-height: 1; }
+  .label { font-size: 4.5vh; opacity: 0.75; margin-top: 3vh; }
 </style></head>
-<body><div class="num">${index}</div><div class="label">${label}</div>
+<body><div class="card"><div class="num">${index}</div><div class="label">${label}</div></div>
 <script>
   // The page dismisses itself: msger's own timeout is only checked when the
   // window sees an event, so an overlay nobody touches sits there forever.
@@ -60,8 +90,9 @@ function overlayHtml(index, screen, seconds) {
  *
  * @param screens - Screens in winpos order (the index shown is the array index)
  * @param seconds - How long each overlay stays up
+ * @param inches - Size of each overlay in real inches, measured on the glass
  */
-export async function showScreenNumbers(screens, seconds = OVERLAY_SECONDS) {
+export async function showScreenNumbers(screens, seconds = OVERLAY_SECONDS, inches = OVERLAY_INCHES) {
     let showMessageBox;
     try {
         ({ showMessageBox } = await import('@bobfrankston/msger'));
@@ -79,16 +110,17 @@ export async function showScreenNumbers(screens, seconds = OVERLAY_SECONDS) {
         // Without this, the overlay on a 125% monitor whose origin is a few
         // thousand pixels out lands far right of center (5K screen, 768px off).
         const scale = screenScale(screen);
-        const x = b.Left / scale + (b.Width - CARD - FRAME_W) / 2;
-        const y = b.Top / scale + (b.Height - CARD - FRAME_H) / 2;
+        const card = cardSize(screen, inches);
+        const x = b.Left / scale + (b.Width - card) / 2;
+        const y = b.Top / scale + (b.Height - card) / 2;
         return showMessageBox({
             title: `winpos screen ${i}`,
             html: overlayHtml(i, screen, seconds),
             rawHtml: true, // No msger template, no OK button
-            size: { width: CARD, height: CARD },
+            overlay: true, // Frameless, transparent, click-through, on top
+            size: { width: card, height: card },
             pos: { x: Math.round(x), y: Math.round(y) },
             timeout: seconds + 5, // Backstop if the page never runs
-            alwaysOnTop: true,
             detach: true, // Outlives winpos itself
             // Own WebView2 profile per overlay: msger windows sharing one
             // user-data dir also share a browser process, and starting all of

package/screens.d.ts

@@ -14,9 +14,28 @@ export interface ScreenInfo {
     primary: boolean;
     /** Display scaling of this monitor as a percent: 100, 125, 150... */
     scalePercent: number;
+    /** Physical panel size in millimetres (EDID), when the driver reports it */
+    physicalMm?: {
+        width: number;
+        height: number;
+    };
 }
 /** Display scaling of a screen as a factor (1.25 for a 125% display) */
 export declare function screenScale(screen: ScreenInfo): number;
+/** What CSS assumes an inch is, and what Windows calls 100% scaling */
+export declare const NOMINAL_DPI = 96;
+/**
+ * True pixels-per-inch of a screen, measured from the panel's physical size.
+ *
+ * Not the same thing as the scale factor: scaling is a preference, so a 28"
+ * 4K panel left at 100% reports 96 DPI while actually being 160. Anything
+ * sized in pixels - or in CSS inches, which are just 96 pixels - therefore
+ * comes out a different physical size on each monitor.
+ *
+ * Falls back to nominal (96 x scale) when the driver won't say, which is the
+ * old pixel-sized behaviour.
+ */
+export declare function screenDpi(screen: ScreenInfo): number;
 export declare function enumerateScreens(): ScreenInfo[];
 export declare function sortScreens(screens: ScreenInfo[]): ScreenInfo[];
 //# sourceMappingURL=screens.d.ts.map

package/screens.js

@@ -6,6 +6,33 @@ import { user32, isBun, MONITORINFOF_PRIMARY, DEFAULT_SCALE_PERCENT } from './ff
 export function screenScale(screen) {
     return (screen.scalePercent || DEFAULT_SCALE_PERCENT) / 100;
 }
+/** What CSS assumes an inch is, and what Windows calls 100% scaling */
+export const NOMINAL_DPI = 96;
+// A real monitor outside this range means the driver lied about its size
+// (some report the whole video wall, projectors report nothing sensible).
+const MIN_PLAUSIBLE_DPI = 30;
+const MAX_PLAUSIBLE_DPI = 700;
+/**
+ * True pixels-per-inch of a screen, measured from the panel's physical size.
+ *
+ * Not the same thing as the scale factor: scaling is a preference, so a 28"
+ * 4K panel left at 100% reports 96 DPI while actually being 160. Anything
+ * sized in pixels - or in CSS inches, which are just 96 pixels - therefore
+ * comes out a different physical size on each monitor.
+ *
+ * Falls back to nominal (96 x scale) when the driver won't say, which is the
+ * old pixel-sized behaviour.
+ */
+export function screenDpi(screen) {
+    const scale = screenScale(screen);
+    const mm = screen.physicalMm;
+    if (!mm || mm.width <= 0)
+        return NOMINAL_DPI * scale;
+    // bounds are logical pixels, so undo the scaling to get what the panel
+    // actually lights up - that is what spans those millimetres.
+    const dpi = (screen.bounds.Width * scale) / (mm.width / 25.4);
+    return dpi >= MIN_PLAUSIBLE_DPI && dpi <= MAX_PLAUSIBLE_DPI ? dpi : NOMINAL_DPI * scale;
+}
 export function enumerateScreens() {
     const screens = [];
     let monitorIndex = 0;
@@ -20,8 +47,12 @@ export function enumerateScreens() {
                 const monitorInfo = {};
                 if (user32.GetMonitorInfoW(hMonitor, monitorInfo)) {
                     const rcMonitor = monitorInfo.rcMonitor;
+                    // The driver's own name for this monitor - enumeration
+                    // order is not the DISPLAYn numbering, so a name made up
+                    // from the index would point gdi32 at the wrong panel.
+                    const deviceName = monitorInfo.szDevice || `\\\\.\\DISPLAY${monitorIndex + 1}`;
                     screens.push({
-                        deviceName: `\\\\.\\DISPLAY${monitorIndex + 1}`,
+                        deviceName,
                         bounds: {
                             Left: rcMonitor.Left,
                             Top: rcMonitor.Top,
@@ -32,6 +63,7 @@ export function enumerateScreens() {
                         },
                         primary: (monitorInfo.dwFlags & MONITORINFOF_PRIMARY) !== 0,
                         scalePercent: user32.GetScaleFactorForMonitor?.(hMonitor) ?? DEFAULT_SCALE_PERCENT,
+                        physicalMm: user32.GetPhysicalSizeMm?.(deviceName) ?? undefined,
                     });
                     monitorIndex++;
                 }