DPI fix: SetThreadDpiHostingBehavior + visible detach/reattach for PuTTY + Console API for PowerShell

Copilot · BornToBeRoot · Copilot · commit 8310b30df3e1 · 2026-03-03T21:36:15.000Z
Co-authored-by: BornToBeRoot &lt;16019165+BornToBeRoot@users.noreply.github.com&gt;
diff --git a/Source/NETworkManager.Utilities/NativeMethods.cs b/Source/NETworkManager.Utilities/NativeMethods.cs
@@ -13,8 +13,17 @@ public class NativeMethods
     public const int WS_THICKFRAME = 0x00040000;
     public const int SWP_NOZORDER = 0x0004;
     public const int SWP_NOACTIVATE = 0x0010;
+    public const int SWP_SHOWWINDOW = 0x0040;
     public const long WS_POPUP = 0x80000000L;
     public const long WS_CAPTION = 0x00C00000L;
+    public const long WS_CHILD = 0x40000000L;
+    public const uint MONITOR_DEFAULTTONEAREST = 0x00000002;
+
+    /// <summary>Places the window at the bottom of the Z order (behind all others).</summary>
+    public static readonly IntPtr HWND_BOTTOM = new IntPtr(1);
+
+    /// <summary>The value returned by CreateFile on failure.</summary>
+    public static readonly IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1);
 
     #endregion
 
@@ -42,6 +51,57 @@ public enum WM : uint
         SYSCOMMAND = 0x0112
     }
 
+    /// <summary>
+    /// Controls how a thread hosts child windows with different DPI awareness contexts.
+    /// Set to <see cref="DPI_HOSTING_BEHAVIOR_MIXED"/> before calling SetParent with a
+    /// cross-process child window to enable DPI notification forwarding.
+    /// Available on Windows 10 1803 (build 17134) and later.
+    /// </summary>
+    public enum DPI_HOSTING_BEHAVIOR
+    {
+        DPI_HOSTING_BEHAVIOR_INVALID = -1,
+        DPI_HOSTING_BEHAVIOR_DEFAULT = 0,
+        DPI_HOSTING_BEHAVIOR_MIXED = 1
+    }
+
+    #endregion
+
+    #region Structs
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct RECT
+    {
+        public int left, top, right, bottom;
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
+    public struct MONITORINFO
+    {
+        public int cbSize;
+        public RECT rcMonitor;
+        public RECT rcWork;
+        public uint dwFlags;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct COORD
+    {
+        public short X;
+        public short Y;
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    public struct CONSOLE_FONT_INFOEX
+    {
+        public uint cbSize;
+        public uint nFont;
+        public COORD dwFontSize;
+        public uint FontFamily;
+        public uint FontWeight;
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
+        public string FaceName;
+    }
+
     #endregion
 
     #region Pinvoke/Win32 Methods
@@ -88,5 +148,105 @@ public static extern IntPtr SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, in
     [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
     public static extern bool SetForegroundWindow(IntPtr hWnd);
 
+    /// <summary>
+    /// Sets the DPI hosting behavior for windows created or reparented on the calling thread.
+    /// Call with <see cref="DPI_HOSTING_BEHAVIOR.DPI_HOSTING_BEHAVIOR_MIXED"/> before
+    /// SetParent to opt into mixed-DPI hosting and enable DPI notification routing for
+    /// child windows. Returns the previous behavior so it can be restored.
+    /// Windows 10 1803+ only.
+    /// </summary>
+    [DllImport("user32.dll")]
+    public static extern DPI_HOSTING_BEHAVIOR SetThreadDpiHostingBehavior(DPI_HOSTING_BEHAVIOR value);
+
+    [DllImport("user32.dll")]
+    public static extern IntPtr MonitorFromWindow(IntPtr hWnd, uint dwFlags);
+
+    [DllImport("user32.dll", CharSet = CharSet.Auto)]
+    public static extern bool GetMonitorInfo(IntPtr hMonitor, ref MONITORINFO lpmi);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    public static extern bool AttachConsole(uint dwProcessId);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    public static extern bool FreeConsole();
+
+    [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
+    private static extern IntPtr CreateFile(string lpFileName, uint dwDesiredAccess, uint dwShareMode,
+        IntPtr lpSecurityAttributes, uint dwCreationDisposition, uint dwFlagsAndAttributes, IntPtr hTemplateFile);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern bool CloseHandle(IntPtr hObject);
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    private static extern bool GetCurrentConsoleFontEx(IntPtr hConsoleOutput, bool bMaximumWindow,
+        ref CONSOLE_FONT_INFOEX lpConsoleCurrentFontEx);
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    private static extern bool SetCurrentConsoleFontEx(IntPtr hConsoleOutput, bool bMaximumWindow,
+        ref CONSOLE_FONT_INFOEX lpConsoleCurrentFontEx);
+
+    #endregion
+
+    #region Helpers
+
+    /// <summary>
+    /// Returns the physical-pixel bounding rectangle of the monitor that contains
+    /// the specified window (nearest monitor if the window is off-screen).
+    /// </summary>
+    public static RECT GetMonitorBoundsForWindow(IntPtr hWnd)
+    {
+        var hMonitor = MonitorFromWindow(hWnd, MONITOR_DEFAULTTONEAREST);
+        var mi = new MONITORINFO { cbSize = Marshal.SizeOf<MONITORINFO>() };
+        GetMonitorInfo(hMonitor, ref mi);
+        return mi.rcMonitor;
+    }
+
+    /// <summary>
+    /// Attaches to <paramref name="processId"/>'s console and rescales its current font
+    /// by <paramref name="scaleFactor"/> using <c>SetCurrentConsoleFontEx</c>.
+    /// This is a cross-process-safe approach that bypasses WM_DPICHANGED message passing
+    /// entirely. Works for any conhost-based console (PowerShell, cmd, etc.).
+    /// </summary>
+    public static void TryRescaleConsoleFont(uint processId, double scaleFactor)
+    {
+        if (Math.Abs(scaleFactor - 1.0) < 0.01)
+            return;
+
+        if (!AttachConsole(processId))
+            return;
+
+        const uint GENERIC_READ_WRITE = 0xC0000000u;
+        const uint FILE_SHARE_READ_WRITE = 3u;
+        const uint OPEN_EXISTING = 3u;
+
+        var hOut = CreateFile("CONOUT$", GENERIC_READ_WRITE, FILE_SHARE_READ_WRITE,
+            IntPtr.Zero, OPEN_EXISTING, 0u, IntPtr.Zero);
+
+        try
+        {
+            if (hOut == INVALID_HANDLE_VALUE)
+                return;
+
+            try
+            {
+                var fi = new CONSOLE_FONT_INFOEX { cbSize = (uint)Marshal.SizeOf<CONSOLE_FONT_INFOEX>() };
+                if (GetCurrentConsoleFontEx(hOut, false, ref fi))
+                {
+                    fi.dwFontSize.Y = (short)Math.Max(1, (int)Math.Round(fi.dwFontSize.Y * scaleFactor));
+                    fi.cbSize = (uint)Marshal.SizeOf<CONSOLE_FONT_INFOEX>();
+                    SetCurrentConsoleFontEx(hOut, false, ref fi);
+                }
+            }
+            finally
+            {
+                CloseHandle(hOut);
+            }
+        }
+        finally
+        {
+            FreeConsole();
+        }
+    }
+
     #endregion
 }
diff --git a/Source/NETworkManager/Controls/PowerShellControl.xaml.cs b/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
@@ -16,55 +16,26 @@ public partial class PowerShellControl : UserControlBase, IDragablzTabItem, IEmb
 {
     #region Events
 
-    private bool _isDpiChanging;
-
     private void WindowGrid_SizeChanged(object sender, SizeChangedEventArgs e)
     {
         ResizeEmbeddedWindow();
     }
 
-    private async void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArgs e)
+    private void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArgs e)
     {
-        if (!IsConnected || _appWin == IntPtr.Zero || _isDpiChanging)
-            return;
-
-        _isDpiChanging = true;
+        ResizeEmbeddedWindow();
 
-        try
-        {
-            // Windows does not forward DPI change notifications across process boundaries
-            // after SetParent. Workaround: temporarily detach the embedded window back to
-            // a top-level window on the new monitor. Windows then delivers WM_DPICHANGED
-            // natively to the process's own message loop so it can rescale its fonts,
-            // exactly as it would when running standalone. Then re-embed and resize.
-            var screen = System.Windows.Forms.Screen.FromHandle(WindowHost.Handle);
-
-            NativeMethods.ShowWindow(_appWin, NativeMethods.WindowShowStyle.Hide);
-            NativeMethods.SetParent(_appWin, IntPtr.Zero);
-
-            // Place the window on the new monitor so Windows sends it WM_DPICHANGED.
-            // The size (800x600) is a reasonable placeholder; the final dimensions are
-            // set by ResizeEmbeddedWindow() after re-embedding.
-            NativeMethods.SetWindowPos(_appWin, IntPtr.Zero,
-                screen.Bounds.X + screen.Bounds.Width / 2,
-                screen.Bounds.Y + screen.Bounds.Height / 2,
-                800, 600, NativeMethods.SWP_NOZORDER | NativeMethods.SWP_NOACTIVATE);
-
-            // 250 ms gives the process's message loop time to dequeue and handle
-            // WM_DPICHANGED, which Windows delivers asynchronously for cross-thread windows.
-            await Task.Delay(250);
-
-            if (!IsConnected || _appWin == IntPtr.Zero)
-                return;
+        if (!IsConnected || _process == null || _process.HasExited)
+            return;
 
-            NativeMethods.SetParent(_appWin, WindowHost.Handle);
-            ResizeEmbeddedWindow();
-            NativeMethods.ShowWindow(_appWin, NativeMethods.WindowShowStyle.ShowNoActivate);
-        }
-        finally
-        {
-            _isDpiChanging = false;
-        }
+        // PowerShell runs inside conhost.exe, a console host process. The Windows
+        // Console API (kernel32.dll) provides cross-process access to the console's
+        // font settings, so we can rescale fonts directly without any window message
+        // passing — completely bypassing the WM_DPICHANGED cross-process delivery
+        // problem that affects the PuTTY (non-console) embedding approach.
+        NativeMethods.TryRescaleConsoleFont(
+            (uint)_process.Id,
+            e.NewDpi.PixelsPerInchX / e.OldDpi.PixelsPerInchX);
     }
 
     #endregion
@@ -211,7 +182,13 @@ private async Task Connect()
 
                 if (_appWin != IntPtr.Zero)
                 {
+                    // Enable mixed-DPI hosting on this thread before SetParent so that
+                    // Windows routes DPI notifications to the cross-process child window.
+                    // SetThreadDpiHostingBehavior is available on Windows 10 1803+.
+                    var prevDpiHosting = NativeMethods.SetThreadDpiHostingBehavior(
+                        NativeMethods.DPI_HOSTING_BEHAVIOR.DPI_HOSTING_BEHAVIOR_MIXED);
                     NativeMethods.SetParent(_appWin, WindowHost.Handle);
+                    NativeMethods.SetThreadDpiHostingBehavior(prevDpiHosting);
 
                     // Show window before set style and resize
                     NativeMethods.ShowWindow(_appWin, NativeMethods.WindowShowStyle.Maximize);
diff --git a/Source/NETworkManager/Controls/PuTTYControl.xaml.cs b/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
@@ -33,31 +33,42 @@ private async void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArg
 
         try
         {
-            // Windows does not forward DPI change notifications across process boundaries
-            // after SetParent. Workaround: temporarily detach the embedded window back to
-            // a top-level window on the new monitor. Windows then delivers WM_DPICHANGED
-            // natively to the process's own message loop so it can rescale its fonts,
-            // exactly as it would when running standalone. Then re-embed and resize.
-            var screen = System.Windows.Forms.Screen.FromHandle(WindowHost.Handle);
+            // Use MonitorFromWindow for reliable physical-pixel coordinates — WinForms's
+            // Screen.FromHandle can return DPI-virtualized (wrong) coordinates on
+            // PerMonitorV2 setups.
+            var bounds = NativeMethods.GetMonitorBoundsForWindow(WindowHost.Handle);
+            int cx = bounds.left + (bounds.right - bounds.left) / 2;
+            int cy = bounds.top + (bounds.bottom - bounds.top) / 2;
+
+            // Windows sends WM_DPICHANGED only to *visible* top-level windows that move
+            // across a monitor DPI boundary.  The previous approach hid the window before
+            // detaching, which prevented the trigger.  Fix: detach first (window stays
+            // visible), then reposition on the new monitor.
+            //
+            // Clear WS_CHILD in case SetParent set it; a WS_CHILD window is not treated
+            // as top-level and will not receive WM_DPICHANGED.
+            long style = NativeMethods.GetWindowLong(_appWin, NativeMethods.GWL_STYLE);
+            if ((style & NativeMethods.WS_CHILD) != 0)
+            {
+                style &= ~NativeMethods.WS_CHILD;
+                NativeMethods.SetWindowLongPtr(_appWin, NativeMethods.GWL_STYLE, new IntPtr(style));
+            }
 
-            NativeMethods.ShowWindow(_appWin, NativeMethods.WindowShowStyle.Hide);
             NativeMethods.SetParent(_appWin, IntPtr.Zero);
 
-            // Place the window on the new monitor so Windows sends it WM_DPICHANGED.
-            // The size (800x600) is a reasonable placeholder; the final dimensions are
-            // set by ResizeEmbeddedWindow() after re-embedding.
-            NativeMethods.SetWindowPos(_appWin, IntPtr.Zero,
-                screen.Bounds.X + screen.Bounds.Width / 2,
-                screen.Bounds.Y + screen.Bounds.Height / 2,
-                800, 600, NativeMethods.SWP_NOZORDER | NativeMethods.SWP_NOACTIVATE);
+            // Place as a 1×1 window at the centre of the new monitor, behind all other
+            // windows (HWND_BOTTOM).  SWP_SHOWWINDOW ensures the window is visible so
+            // Windows detects the monitor change and delivers WM_DPICHANGED natively.
+            NativeMethods.SetWindowPos(_appWin, NativeMethods.HWND_BOTTOM, cx, cy, 1, 1,
+                NativeMethods.SWP_NOACTIVATE | NativeMethods.SWP_SHOWWINDOW);
 
-            // 250 ms gives the process's message loop time to dequeue and handle
-            // WM_DPICHANGED, which Windows delivers asynchronously for cross-thread windows.
-            await Task.Delay(250);
+            // Give the process time to dequeue and handle WM_DPICHANGED.
+            await Task.Delay(300);
 
             if (!IsConnected || _appWin == IntPtr.Zero)
                 return;
 
+            NativeMethods.ShowWindow(_appWin, NativeMethods.WindowShowStyle.Hide);
             NativeMethods.SetParent(_appWin, WindowHost.Handle);
             ResizeEmbeddedWindow();
             NativeMethods.ShowWindow(_appWin, NativeMethods.WindowShowStyle.ShowNoActivate);
@@ -224,7 +235,13 @@ private async Task Connect()
 
                     if (!_process.HasExited)
                     {
+                        // Enable mixed-DPI hosting on this thread before SetParent so that
+                        // Windows routes DPI notifications to the cross-process child window.
+                        // SetThreadDpiHostingBehavior is available on Windows 10 1803+.
+                        var prevDpiHosting = NativeMethods.SetThreadDpiHostingBehavior(
+                            NativeMethods.DPI_HOSTING_BEHAVIOR.DPI_HOSTING_BEHAVIOR_MIXED);
                         NativeMethods.SetParent(_appWin, WindowHost.Handle);
+                        NativeMethods.SetThreadDpiHostingBehavior(prevDpiHosting);
 
                         // Show window before set style and resize
                         NativeMethods.ShowWindow(_appWin, NativeMethods.WindowShowStyle.Maximize);
