Proposal: Add DeviceLeft and DeviceTop to Window for DPI-Independent Positioning

[imechZhangLY]

When developing a WPF application with Per-Monitor DPI Awareness, positioning a window across multiple monitors becomes unexpectedly difficult. The core issue is that WPF uses logical pixels for window coordinates, but converting logical pixels to device pixels depends on the window’s DPI. At the same time, the window’s DPI depends on which monitor the window is on, and the monitor the window is on is determined by the window’s position.
This creates a circular dependency:

• Window position → depends on window DPI
• Window DPI → depends on the monitor
• Monitor → depends on window position

To address this, WPF provides the WindowStartupTopLeftPointHelper class. However, this helper does not actually solve the positioning problem. Its algorithm works as follows:

• Enumerate all monitors.
• Convert each monitor’s bounds into logical pixels.
• Check whether the window’s logical top-left point falls within those bounds.
• If it does, convert the logical point to device pixels using that monitor’s DPI.

The relevant code is:

private bool MonitorEnumProc(IntPtr hMonitor, IntPtr hdcMonitor, ref NativeMethods.RECT lprcMonitor, IntPtr dwData)
{
    bool continueMonitorEnumeration = true;

    uint dpiX, dpiY;
    var hr =
        UnsafeNativeMethods.GetDpiForMonitor(
            new HandleRef(null, hMonitor),
            NativeMethods.MONITOR_DPI_TYPE.MDT_EFFECTIVE_DPI,
            out dpiX, out dpiY);

    if (hr == NativeMethods.S_OK)
    {
        double dpiScaleX = dpiX * 1.0d / 96.0d;
        double dpiScaleY = dpiY * 1.0d / 96.0d;

        Rect monitorRectInWpfScale = new Rect
        {
            X = lprcMonitor.left / dpiScaleX,
            Y = lprcMonitor.top / dpiScaleY,
            Width = (lprcMonitor.right - lprcMonitor.left) / dpiScaleX,
            Height = (lprcMonitor.bottom - lprcMonitor.top) / dpiScaleY
        };

        if (monitorRectInWpfScale.Contains(LogicalTopLeft))
        {
            ScreenTopLeft = new Point
            {
                X = LogicalTopLeft.X * dpiScaleX,
                Y = LogicalTopLeft.Y * dpiScaleY
            };

            continueMonitorEnumeration = false;
        }
    }

    return continueMonitorEnumeration;
}

Problems with This Algorithm

This algorithm has two fundamental issues:

1. Some logical pixel values may not fall on any monitor
   Consider two horizontally arranged monitors A and B:

• Monitor A: DPI scale = $s_A$, width = 100 device pixels
• Monitor B: DPI scale = $s_B$, width = 100 device pixels
• Monitor A starts at device pixel 0
• Monitor B starts at device pixel 100
  The logical-to-device mapping is:
• $logical=device/s_A, for 0<= device <= 100$
• $logical=device/s_B, for 100< device <= 200$
  If $s_A>s_B$, the two functions create a gap in logical space—some logical pixel values correspond to no device pixel on either monitor.

2. Some logical pixel values may fall on multiple monitors
   If $s_A<s_B$, the two functions overlap in logical space.
   This means a logical coordinate may be valid on both monitors A and B.
   In this case, the final monitor selection depends purely on the enumeration order, which is nondeterministic and undesirable.

Illustration of the Problem

The following image visualizes both scenarios:

• Top graph (s_A = 2.0, s_B = 1.0): Shows a gap in logical pixel values that cannot be mapped to either monitor.
• Bottom graph (s_A = 1.0, s_B = 2.0): Shows overlapping logical pixel values that can map to both monitors.
  Logical pixel mapping under different DPI scale

Proposed Solution

To avoid the circular dependency and the ambiguity caused by logical coordinates, I suggest adding DeviceLeft and DeviceTop properties to Window, allowing developers to position windows directly using device pixels.
This would:

• Eliminate ambiguity in monitor selection
• Avoid logical-pixel gaps or overlaps
• Provide deterministic, DPI-independent window placement
• Align WPF behavior with Win32 APIs, which already use device pixels for window positioning