From 61b55c613965b2a932fd139e5a092bfb5a452739 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 1 Mar 2026 00:17:22 +0000
Subject: [PATCH 01/15] Initial plan


From 60b75623b1ddd36e84c07926fb7ef66e4bfd8814 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 1 Mar 2026 00:22:54 +0000
Subject: [PATCH 02/15] Fix DPI scaling for embedded PuTTY and PowerShell
 windows

Co-authored-by: BornToBeRoot <16019165+BornToBeRoot@users.noreply.github.com>
---
 Source/NETworkManager/Controls/PowerShellControl.xaml    | 3 ++-
 Source/NETworkManager/Controls/PowerShellControl.xaml.cs | 5 +++++
 Source/NETworkManager/Controls/PuTTYControl.xaml         | 3 ++-
 Source/NETworkManager/Controls/PuTTYControl.xaml.cs      | 5 +++++
 4 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/Source/NETworkManager/Controls/PowerShellControl.xaml b/Source/NETworkManager/Controls/PowerShellControl.xaml
index 051baa2312..7730f87c68 100644
--- a/Source/NETworkManager/Controls/PowerShellControl.xaml
+++ b/Source/NETworkManager/Controls/PowerShellControl.xaml
@@ -19,7 +19,8 @@
     </local:UserControlBase.Resources>
     <Grid SizeChanged="WindowGrid_SizeChanged">
         <!-- Background color will prevent flickering when app inside the panel is closed -->
-        <WindowsFormsHost Background="{DynamicResource MahApps.Brushes.Window.Background}" Margin="10">
+        <WindowsFormsHost Background="{DynamicResource MahApps.Brushes.Window.Background}" Margin="10"
+                          DpiChanged="WindowsFormsHost_DpiChanged">
             <WindowsFormsHost.Style>
                 <Style TargetType="{x:Type WindowsFormsHost}">
                     <Style.Triggers>
diff --git a/Source/NETworkManager/Controls/PowerShellControl.xaml.cs b/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
index 420654fc22..49a5ec8958 100644
--- a/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
+++ b/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
@@ -21,6 +21,11 @@ private void WindowGrid_SizeChanged(object sender, SizeChangedEventArgs e)
         ResizeEmbeddedWindow();
     }
 
+    private void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArgs e)
+    {
+        ResizeEmbeddedWindow();
+    }
+
     #endregion
 
     #region Variables
diff --git a/Source/NETworkManager/Controls/PuTTYControl.xaml b/Source/NETworkManager/Controls/PuTTYControl.xaml
index d431ec8685..5958d5424b 100644
--- a/Source/NETworkManager/Controls/PuTTYControl.xaml
+++ b/Source/NETworkManager/Controls/PuTTYControl.xaml
@@ -19,7 +19,8 @@
     </local:UserControlBase.Resources>
     <Grid SizeChanged="WindowGrid_SizeChanged">
         <!-- Background color will prevent flickering when app inside the panel is closed -->
-        <WindowsFormsHost Background="{DynamicResource MahApps.Brushes.Window.Background}" Margin="10">
+        <WindowsFormsHost Background="{DynamicResource MahApps.Brushes.Window.Background}" Margin="10"
+                          DpiChanged="WindowsFormsHost_DpiChanged">
             <WindowsFormsHost.Style>
                 <Style TargetType="{x:Type WindowsFormsHost}">
                     <Style.Triggers>
diff --git a/Source/NETworkManager/Controls/PuTTYControl.xaml.cs b/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
index 8d7c623af2..cce5bace00 100644
--- a/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
+++ b/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
@@ -22,6 +22,11 @@ private void WindowGrid_SizeChanged(object sender, SizeChangedEventArgs e)
         ResizeEmbeddedWindow();
     }
 
+    private void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArgs e)
+    {
+        ResizeEmbeddedWindow();
+    }
+
     #endregion
 
     #region Variables

From 90bd9b415bbf40dc6bd194b3586324fdfb31c09d Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 1 Mar 2026 00:51:03 +0000
Subject: [PATCH 03/15] Send WM_DPICHANGED_AFTERPARENT to embedded window on
 DPI change

Co-authored-by: BornToBeRoot <16019165+BornToBeRoot@users.noreply.github.com>
---
 Source/NETworkManager.Utilities/NativeMethods.cs         | 3 ++-
 Source/NETworkManager/Controls/PowerShellControl.xaml.cs | 4 ++++
 Source/NETworkManager/Controls/PuTTYControl.xaml.cs      | 4 ++++
 3 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/Source/NETworkManager.Utilities/NativeMethods.cs b/Source/NETworkManager.Utilities/NativeMethods.cs
index 7b5e08ba08..ccf1e378da 100644
--- a/Source/NETworkManager.Utilities/NativeMethods.cs
+++ b/Source/NETworkManager.Utilities/NativeMethods.cs
@@ -39,7 +39,8 @@ public enum WindowShowStyle : uint
 
     public enum WM : uint
     {
-        SYSCOMMAND = 0x0112
+        SYSCOMMAND = 0x0112,
+        DPICHANGED_AFTERPARENT = 0x02E3
     }
 
     #endregion
diff --git a/Source/NETworkManager/Controls/PowerShellControl.xaml.cs b/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
index 49a5ec8958..93649ef90f 100644
--- a/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
+++ b/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
@@ -23,6 +23,10 @@ private void WindowGrid_SizeChanged(object sender, SizeChangedEventArgs e)
 
     private void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArgs e)
     {
+        if (IsConnected && _appWin != IntPtr.Zero)
+            NativeMethods.SendMessage(_appWin, (uint)NativeMethods.WM.DPICHANGED_AFTERPARENT, IntPtr.Zero,
+                IntPtr.Zero);
+
         ResizeEmbeddedWindow();
     }
 
diff --git a/Source/NETworkManager/Controls/PuTTYControl.xaml.cs b/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
index cce5bace00..a3983d21cd 100644
--- a/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
+++ b/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
@@ -24,6 +24,10 @@ private void WindowGrid_SizeChanged(object sender, SizeChangedEventArgs e)
 
     private void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArgs e)
     {
+        if (IsConnected && _appWin != IntPtr.Zero)
+            NativeMethods.SendMessage(_appWin, (uint)NativeMethods.WM.DPICHANGED_AFTERPARENT, IntPtr.Zero,
+                IntPtr.Zero);
+
         ResizeEmbeddedWindow();
     }
 

From 98f61726791fd2028e5789ec0cfbb98b3af80578 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 1 Mar 2026 01:22:28 +0000
Subject: [PATCH 04/15] Fix cross-process DPI scaling: send WM_DPICHANGED with
 explicit DPI to embedded window

Co-authored-by: BornToBeRoot <16019165+BornToBeRoot@users.noreply.github.com>
---
 Source/NETworkManager.Utilities/NativeMethods.cs |  5 ++++-
 .../Controls/PowerShellControl.xaml.cs           | 16 ++++++++++++----
 .../NETworkManager/Controls/PuTTYControl.xaml.cs | 16 ++++++++++++----
 3 files changed, 28 insertions(+), 9 deletions(-)

diff --git a/Source/NETworkManager.Utilities/NativeMethods.cs b/Source/NETworkManager.Utilities/NativeMethods.cs
index ccf1e378da..fea2a32e44 100644
--- a/Source/NETworkManager.Utilities/NativeMethods.cs
+++ b/Source/NETworkManager.Utilities/NativeMethods.cs
@@ -40,7 +40,7 @@ public enum WindowShowStyle : uint
     public enum WM : uint
     {
         SYSCOMMAND = 0x0112,
-        DPICHANGED_AFTERPARENT = 0x02E3
+        DPICHANGED = 0x02E0
     }
 
     #endregion
@@ -77,6 +77,9 @@ public static extern IntPtr SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, in
     [DllImport("user32.dll", CharSet = CharSet.Auto)]
     public static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
 
+    [DllImport("user32.dll", CharSet = CharSet.Auto)]
+    public static extern bool PostMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
+
     [DllImport("user32.dll", SetLastError = true)]
     public static extern bool MoveWindow(IntPtr hWnd, int x, int y, int cx, int cy, bool repaint);
 
diff --git a/Source/NETworkManager/Controls/PowerShellControl.xaml.cs b/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
index 93649ef90f..7229cabc2c 100644
--- a/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
+++ b/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
@@ -23,11 +23,19 @@ private void WindowGrid_SizeChanged(object sender, SizeChangedEventArgs e)
 
     private void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArgs e)
     {
-        if (IsConnected && _appWin != IntPtr.Zero)
-            NativeMethods.SendMessage(_appWin, (uint)NativeMethods.WM.DPICHANGED_AFTERPARENT, IntPtr.Zero,
-                IntPtr.Zero);
-
+        // Resize first so the embedded window is physically on the new monitor,
+        // then post WM_DPICHANGED with the explicit new DPI in wParam so the
+        // embedded process rescales its fonts without relying on a cross-process
+        // GetDpiForWindow() call (which is unreliable after SetParent across processes).
         ResizeEmbeddedWindow();
+
+        if (IsConnected && _appWin != IntPtr.Zero)
+        {
+            var dpiX = (int)e.NewDpi.PixelsPerInchX;
+            var dpiY = (int)e.NewDpi.PixelsPerInchY;
+            var wParam = new IntPtr(unchecked((int)(uint)((dpiX & 0xFFFF) | ((dpiY & 0xFFFF) << 16))));
+            NativeMethods.PostMessage(_appWin, (uint)NativeMethods.WM.DPICHANGED, wParam, IntPtr.Zero);
+        }
     }
 
     #endregion
diff --git a/Source/NETworkManager/Controls/PuTTYControl.xaml.cs b/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
index a3983d21cd..159936107c 100644
--- a/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
+++ b/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
@@ -24,11 +24,19 @@ private void WindowGrid_SizeChanged(object sender, SizeChangedEventArgs e)
 
     private void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArgs e)
     {
-        if (IsConnected && _appWin != IntPtr.Zero)
-            NativeMethods.SendMessage(_appWin, (uint)NativeMethods.WM.DPICHANGED_AFTERPARENT, IntPtr.Zero,
-                IntPtr.Zero);
-
+        // Resize first so the embedded window is physically on the new monitor,
+        // then post WM_DPICHANGED with the explicit new DPI in wParam so the
+        // embedded process rescales its fonts without relying on a cross-process
+        // GetDpiForWindow() call (which is unreliable after SetParent across processes).
         ResizeEmbeddedWindow();
+
+        if (IsConnected && _appWin != IntPtr.Zero)
+        {
+            var dpiX = (int)e.NewDpi.PixelsPerInchX;
+            var dpiY = (int)e.NewDpi.PixelsPerInchY;
+            var wParam = new IntPtr(unchecked((int)(uint)((dpiX & 0xFFFF) | ((dpiY & 0xFFFF) << 16))));
+            NativeMethods.PostMessage(_appWin, (uint)NativeMethods.WM.DPICHANGED, wParam, IntPtr.Zero);
+        }
     }
 
     #endregion

From 06a543a2ccaa12764d5fc35bfeba0dcc88a625b0 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 1 Mar 2026 01:36:49 +0000
Subject: [PATCH 05/15] DPI fix: detach/reattach embedded window so Windows
 delivers WM_DPICHANGED natively

Co-authored-by: BornToBeRoot <16019165+BornToBeRoot@users.noreply.github.com>
---
 .../NETworkManager.Utilities/NativeMethods.cs |  3 +-
 .../Controls/PowerShellControl.xaml.cs        | 51 +++++++++++++++----
 .../Controls/PuTTYControl.xaml.cs             | 51 +++++++++++++++----
 3 files changed, 81 insertions(+), 24 deletions(-)

diff --git a/Source/NETworkManager.Utilities/NativeMethods.cs b/Source/NETworkManager.Utilities/NativeMethods.cs
index fea2a32e44..4198879973 100644
--- a/Source/NETworkManager.Utilities/NativeMethods.cs
+++ b/Source/NETworkManager.Utilities/NativeMethods.cs
@@ -39,8 +39,7 @@ public enum WindowShowStyle : uint
 
     public enum WM : uint
     {
-        SYSCOMMAND = 0x0112,
-        DPICHANGED = 0x02E0
+        SYSCOMMAND = 0x0112
     }
 
     #endregion
diff --git a/Source/NETworkManager/Controls/PowerShellControl.xaml.cs b/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
index 7229cabc2c..bdc9e3c0f7 100644
--- a/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
+++ b/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
@@ -16,25 +16,54 @@ public partial class PowerShellControl : UserControlBase, IDragablzTabItem, IEmb
 {
     #region Events
 
+    private bool _isDpiChanging;
+
     private void WindowGrid_SizeChanged(object sender, SizeChangedEventArgs e)
     {
         ResizeEmbeddedWindow();
     }
 
-    private void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArgs e)
+    private async void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArgs e)
     {
-        // Resize first so the embedded window is physically on the new monitor,
-        // then post WM_DPICHANGED with the explicit new DPI in wParam so the
-        // embedded process rescales its fonts without relying on a cross-process
-        // GetDpiForWindow() call (which is unreliable after SetParent across processes).
-        ResizeEmbeddedWindow();
+        if (!IsConnected || _appWin == IntPtr.Zero || _isDpiChanging)
+            return;
 
-        if (IsConnected && _appWin != IntPtr.Zero)
+        _isDpiChanging = true;
+
+        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;
+
+            NativeMethods.SetParent(_appWin, WindowHost.Handle);
+            ResizeEmbeddedWindow();
+            NativeMethods.ShowWindow(_appWin, NativeMethods.WindowShowStyle.ShowNoActivate);
+        }
+        finally
         {
-            var dpiX = (int)e.NewDpi.PixelsPerInchX;
-            var dpiY = (int)e.NewDpi.PixelsPerInchY;
-            var wParam = new IntPtr(unchecked((int)(uint)((dpiX & 0xFFFF) | ((dpiY & 0xFFFF) << 16))));
-            NativeMethods.PostMessage(_appWin, (uint)NativeMethods.WM.DPICHANGED, wParam, IntPtr.Zero);
+            _isDpiChanging = false;
         }
     }
 
diff --git a/Source/NETworkManager/Controls/PuTTYControl.xaml.cs b/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
index 159936107c..56142605be 100644
--- a/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
+++ b/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
@@ -17,25 +17,54 @@ public partial class PuTTYControl : UserControlBase, IDragablzTabItem, IEmbedded
 {
     #region Events
 
+    private bool _isDpiChanging;
+
     private void WindowGrid_SizeChanged(object sender, SizeChangedEventArgs e)
     {
         ResizeEmbeddedWindow();
     }
 
-    private void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArgs e)
+    private async void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArgs e)
     {
-        // Resize first so the embedded window is physically on the new monitor,
-        // then post WM_DPICHANGED with the explicit new DPI in wParam so the
-        // embedded process rescales its fonts without relying on a cross-process
-        // GetDpiForWindow() call (which is unreliable after SetParent across processes).
-        ResizeEmbeddedWindow();
+        if (!IsConnected || _appWin == IntPtr.Zero || _isDpiChanging)
+            return;
 
-        if (IsConnected && _appWin != IntPtr.Zero)
+        _isDpiChanging = true;
+
+        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;
+
+            NativeMethods.SetParent(_appWin, WindowHost.Handle);
+            ResizeEmbeddedWindow();
+            NativeMethods.ShowWindow(_appWin, NativeMethods.WindowShowStyle.ShowNoActivate);
+        }
+        finally
         {
-            var dpiX = (int)e.NewDpi.PixelsPerInchX;
-            var dpiY = (int)e.NewDpi.PixelsPerInchY;
-            var wParam = new IntPtr(unchecked((int)(uint)((dpiX & 0xFFFF) | ((dpiY & 0xFFFF) << 16))));
-            NativeMethods.PostMessage(_appWin, (uint)NativeMethods.WM.DPICHANGED, wParam, IntPtr.Zero);
+            _isDpiChanging = false;
         }
     }
 

From 8310b30df3e1598685ba69d065db74edca69fe02 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 3 Mar 2026 21:36:15 +0000
Subject: [PATCH 06/15] DPI fix: SetThreadDpiHostingBehavior + visible
 detach/reattach for PuTTY + Console API for PowerShell

Co-authored-by: BornToBeRoot <16019165+BornToBeRoot@users.noreply.github.com>
---
 .../NETworkManager.Utilities/NativeMethods.cs | 160 ++++++++++++++++++
 .../Controls/PowerShellControl.xaml.cs        |  59 ++-----
 .../Controls/PuTTYControl.xaml.cs             |  51 ++++--
 3 files changed, 212 insertions(+), 58 deletions(-)

diff --git a/Source/NETworkManager.Utilities/NativeMethods.cs b/Source/NETworkManager.Utilities/NativeMethods.cs
index 4198879973..416149d371 100644
--- 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
 }
\ No newline at end of file
diff --git a/Source/NETworkManager/Controls/PowerShellControl.xaml.cs b/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
index bdc9e3c0f7..075469452b 100644
--- 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
index 56142605be..3596e36bf4 100644
--- 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);

From 21a2be8b8db7a821d0cf07b25d016450c636a4f7 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 3 Mar 2026 21:58:54 +0000
Subject: [PATCH 07/15] Fix PowerShell initial DPI + PuTTY WS_POPUP/window-size
 for reliable DpiChanged delivery

Co-authored-by: BornToBeRoot <16019165+BornToBeRoot@users.noreply.github.com>
---
 .../NETworkManager.Utilities/NativeMethods.cs |  7 +++
 .../Controls/PowerShellControl.xaml.cs        | 14 +++++
 .../Controls/PuTTYControl.xaml.cs             | 61 +++++++++++++------
 3 files changed, 65 insertions(+), 17 deletions(-)

diff --git a/Source/NETworkManager.Utilities/NativeMethods.cs b/Source/NETworkManager.Utilities/NativeMethods.cs
index 416149d371..c59e9e7293 100644
--- a/Source/NETworkManager.Utilities/NativeMethods.cs
+++ b/Source/NETworkManager.Utilities/NativeMethods.cs
@@ -158,6 +158,13 @@ public static extern IntPtr SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, in
     [DllImport("user32.dll")]
     public static extern DPI_HOSTING_BEHAVIOR SetThreadDpiHostingBehavior(DPI_HOSTING_BEHAVIOR value);
 
+    /// <summary>
+    /// Returns the DPI (dots per inch) value for the monitor that contains the specified window.
+    /// Returns 0 if the window handle is invalid. Available on Windows 10 version 1607+.
+    /// </summary>
+    [DllImport("user32.dll")]
+    public static extern uint GetDpiForWindow(IntPtr hWnd);
+
     [DllImport("user32.dll")]
     public static extern IntPtr MonitorFromWindow(IntPtr hWnd, uint dwFlags);
 
diff --git a/Source/NETworkManager/Controls/PowerShellControl.xaml.cs b/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
index 075469452b..ad0696b014 100644
--- a/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
+++ b/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
@@ -182,6 +182,11 @@ private async Task Connect()
 
                 if (_appWin != IntPtr.Zero)
                 {
+                    // Capture the DPI of conhost's window before embedding. The process
+                    // might have started on a different monitor than ours, so its font
+                    // may be scaled for a different DPI. We correct this after embedding.
+                    var initialWindowDpi = NativeMethods.GetDpiForWindow(_appWin);
+
                     // 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+.
@@ -204,6 +209,15 @@ private async Task Connect()
                     // Requires a short delay because it's not applied immediately
                     await Task.Delay(250);
                     ResizeEmbeddedWindow();
+
+                    // If conhost started at a different DPI than our monitor (e.g. it
+                    // spawned on a secondary monitor with a different scale factor),
+                    // correct the font now so WindowsFormsHost_DpiChanged always starts
+                    // from the right baseline for relative scaling.
+                    var currentPanelDpi = NativeMethods.GetDpiForWindow(WindowHost.Handle);
+                    if (initialWindowDpi != currentPanelDpi)
+                        NativeMethods.TryRescaleConsoleFont((uint)_process.Id,
+                            (double)currentPanelDpi / initialWindowDpi);
                 }
             }
             else
diff --git a/Source/NETworkManager/Controls/PuTTYControl.xaml.cs b/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
index 3596e36bf4..ca0950ca77 100644
--- a/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
+++ b/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
@@ -29,6 +29,19 @@ private async void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArg
         if (!IsConnected || _appWin == IntPtr.Zero || _isDpiChanging)
             return;
 
+        await TriggerDpiUpdateAsync();
+    }
+
+    /// <summary>
+    /// Detaches PuTTY's window, places it visibly on the current monitor so Windows
+    /// delivers WM_DPICHANGED natively to PuTTY's message loop, then re-embeds it.
+    /// Called both on initial connect (if DPIs differ) and on every DPI change.
+    /// </summary>
+    private async Task TriggerDpiUpdateAsync()
+    {
+        if (_isDpiChanging || !IsConnected || _appWin == IntPtr.Zero)
+            return;
+
         _isDpiChanging = true;
 
         try
@@ -40,29 +53,26 @@ private async void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArg
             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.
+            // Temporarily restore WS_POPUP so that after SetParent(null) Windows treats
+            // the window as a proper top-level popup. Without WS_POPUP (stripped during
+            // embedding), the window has no recognised top-level style and Windows
+            // skips sending WM_DPICHANGED to it entirely.
+            // Also clear WS_CHILD if SetParent happened to set it.
             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));
-            }
+            style &= ~NativeMethods.WS_CHILD;
+            style |= NativeMethods.WS_POPUP;
+            NativeMethods.SetWindowLongPtr(_appWin, NativeMethods.GWL_STYLE, new IntPtr(style));
 
             NativeMethods.SetParent(_appWin, IntPtr.Zero);
 
-            // 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,
+            // Place as an 800×600 window at the centre of the target monitor, behind
+            // all other windows (HWND_BOTTOM). SWP_SHOWWINDOW makes it visible so
+            // Windows detects the monitor's DPI and delivers WM_DPICHANGED natively.
+            // A 1×1 window is below the threshold Windows uses for DPI detection.
+            NativeMethods.SetWindowPos(_appWin, NativeMethods.HWND_BOTTOM, cx, cy, 800, 600,
                 NativeMethods.SWP_NOACTIVATE | NativeMethods.SWP_SHOWWINDOW);
 
-            // Give the process time to dequeue and handle WM_DPICHANGED.
+            // Give PuTTY's message loop time to dequeue and handle WM_DPICHANGED.
             await Task.Delay(300);
 
             if (!IsConnected || _appWin == IntPtr.Zero)
@@ -70,6 +80,13 @@ private async void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArg
 
             NativeMethods.ShowWindow(_appWin, NativeMethods.WindowShowStyle.Hide);
             NativeMethods.SetParent(_appWin, WindowHost.Handle);
+
+            // Remove WS_POPUP after re-embedding; keeping it on a child window can
+            // cause painting to overflow the parent panel (see issue #167).
+            style = NativeMethods.GetWindowLong(_appWin, NativeMethods.GWL_STYLE);
+            style &= ~NativeMethods.WS_POPUP;
+            NativeMethods.SetWindowLongPtr(_appWin, NativeMethods.GWL_STYLE, new IntPtr(style));
+
             ResizeEmbeddedWindow();
             NativeMethods.ShowWindow(_appWin, NativeMethods.WindowShowStyle.ShowNoActivate);
         }
@@ -235,6 +252,10 @@ private async Task Connect()
 
                     if (!_process.HasExited)
                     {
+                        // Capture PuTTY's DPI before embedding. If it started on a
+                        // different monitor than ours, we correct below via detach/reattach.
+                        var initialWindowDpi = NativeMethods.GetDpiForWindow(_appWin);
+
                         // 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+.
@@ -260,6 +281,12 @@ private async Task Connect()
                         await Task.Delay(250);
 
                         ResizeEmbeddedWindow();
+
+                        // If PuTTY started on a different DPI monitor than ours, trigger
+                        // a DPI correction now so its font matches the current monitor.
+                        var currentPanelDpi = NativeMethods.GetDpiForWindow(WindowHost.Handle);
+                        if (initialWindowDpi != currentPanelDpi)
+                            await TriggerDpiUpdateAsync();
                     }
                 }
             }

From fd46a3d64d4c7145b9b9cbdec04722557e389073 Mon Sep 17 00:00:00 2001
From: BornToBeRoot <16019165+BornToBeRoot@users.noreply.github.com>
Date: Tue, 3 Mar 2026 23:50:50 +0100
Subject: [PATCH 08/15] Fix: PuTTY DPI issues

---
 .../NETworkManager.Utilities/NativeMethods.cs | 81 ++++++++--------
 .../Controls/PuTTYControl.xaml.cs             | 97 ++++---------------
 2 files changed, 62 insertions(+), 116 deletions(-)

diff --git a/Source/NETworkManager.Utilities/NativeMethods.cs b/Source/NETworkManager.Utilities/NativeMethods.cs
index c59e9e7293..5f2b0799b3 100644
--- a/Source/NETworkManager.Utilities/NativeMethods.cs
+++ b/Source/NETworkManager.Utilities/NativeMethods.cs
@@ -20,10 +20,10 @@ public class NativeMethods
     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);
+    public static readonly IntPtr HWND_BOTTOM = new(1);
 
     /// <summary>The value returned by CreateFile on failure.</summary>
-    public static readonly IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1);
+    public static readonly IntPtr INVALID_HANDLE_VALUE = new(-1);
 
     #endregion
 
@@ -74,15 +74,6 @@ 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
     {
@@ -105,10 +96,7 @@ public struct CONSOLE_FONT_INFOEX
     #endregion
 
     #region Pinvoke/Win32 Methods
-
-    [DllImport("user32.dll")]
-    public static extern IntPtr GetForegroundWindow();
-
+        
     [DllImport("user32.dll", SetLastError = true)]
     public static extern long SetParent(IntPtr hWndChild, IntPtr hWndParent);
 
@@ -136,12 +124,6 @@ public static extern IntPtr SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, in
     [DllImport("user32.dll", CharSet = CharSet.Auto)]
     public static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
 
-    [DllImport("user32.dll", CharSet = CharSet.Auto)]
-    public static extern bool PostMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
-
-    [DllImport("user32.dll", SetLastError = true)]
-    public static extern bool MoveWindow(IntPtr hWnd, int x, int y, int cx, int cy, bool repaint);
-
     [DllImport("user32.dll")]
     public static extern bool ShowWindow(IntPtr hWnd, WindowShowStyle nCmdShow);
 
@@ -165,11 +147,8 @@ public static extern IntPtr SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, in
     [DllImport("user32.dll")]
     public static extern uint GetDpiForWindow(IntPtr hWnd);
 
-    [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("user32.dll", SetLastError = true)]
+    public static extern bool GetWindowRect(IntPtr hWnd, ref RECT lpRect);
 
     [DllImport("kernel32.dll", SetLastError = true)]
     public static extern bool AttachConsole(uint dwProcessId);
@@ -194,19 +173,7 @@ private static extern bool SetCurrentConsoleFontEx(IntPtr hConsoleOutput, bool b
 
     #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;
-    }
+    #region Helpers       
 
     /// <summary>
     /// Attaches to <paramref name="processId"/>'s console and rescales its current font
@@ -255,5 +222,41 @@ public static void TryRescaleConsoleFont(uint processId, double scaleFactor)
         }
     }
 
+    /// <summary>
+    /// Sends a <c>WM_DPICHANGED</c> message to a GUI window (e.g. PuTTY) so it can
+    /// rescale its fonts and layout internally. This is necessary because
+    /// <c>WM_DPICHANGED</c> is not reliably forwarded to cross-process child windows
+    /// embedded via <c>SetParent</c>. Requires PuTTY 0.75+ to take effect.
+    /// </summary>
+    public static void TrySendDpiChangedMessage(IntPtr hWnd, double oldDpi, double newDpi)
+    {
+        if (hWnd == IntPtr.Zero)
+            return;
+
+        if (Math.Abs(newDpi - oldDpi) < 0.01)
+            return;
+
+        const uint WM_DPICHANGED = 0x02E0;
+
+        var newDpiInt = (int)Math.Round(newDpi);
+        var wParam = (IntPtr)((newDpiInt << 16) | newDpiInt); // HIWORD = Y DPI, LOWORD = X DPI
+
+        // Build the suggested new rect from the current window position.
+        var rect = new RECT();
+        GetWindowRect(hWnd, ref rect);
+
+        // lParam must point to a RECT with the suggested new size/position.
+        var lParam = Marshal.AllocHGlobal(Marshal.SizeOf<RECT>());
+        try
+        {
+            Marshal.StructureToPtr(rect, lParam, false);
+            SendMessage(hWnd, WM_DPICHANGED, wParam, lParam);
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(lParam);
+        }
+    }
+
     #endregion
 }
\ No newline at end of file
diff --git a/Source/NETworkManager/Controls/PuTTYControl.xaml.cs b/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
index ca0950ca77..78f2d3fe86 100644
--- a/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
+++ b/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
@@ -17,8 +17,6 @@ public partial class PuTTYControl : UserControlBase, IDragablzTabItem, IEmbedded
 {
     #region Events
 
-    private bool _isDpiChanging;
-
     private void WindowGrid_SizeChanged(object sender, SizeChangedEventArgs e)
     {
         ResizeEmbeddedWindow();
@@ -26,76 +24,20 @@ private void WindowGrid_SizeChanged(object sender, SizeChangedEventArgs e)
 
     private async void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArgs e)
     {
-        if (!IsConnected || _appWin == IntPtr.Zero || _isDpiChanging)
-            return;
-
-        await TriggerDpiUpdateAsync();
-    }
+        ResizeEmbeddedWindow();
 
-    /// <summary>
-    /// Detaches PuTTY's window, places it visibly on the current monitor so Windows
-    /// delivers WM_DPICHANGED natively to PuTTY's message loop, then re-embeds it.
-    /// Called both on initial connect (if DPIs differ) and on every DPI change.
-    /// </summary>
-    private async Task TriggerDpiUpdateAsync()
-    {
-        if (_isDpiChanging || !IsConnected || _appWin == IntPtr.Zero)
+        if (!IsConnected || _process == null || _process.HasExited)
             return;
 
-        _isDpiChanging = true;
-
-        try
-        {
-            // 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;
-
-            // Temporarily restore WS_POPUP so that after SetParent(null) Windows treats
-            // the window as a proper top-level popup. Without WS_POPUP (stripped during
-            // embedding), the window has no recognised top-level style and Windows
-            // skips sending WM_DPICHANGED to it entirely.
-            // Also clear WS_CHILD if SetParent happened to set it.
-            long style = NativeMethods.GetWindowLong(_appWin, NativeMethods.GWL_STYLE);
-            style &= ~NativeMethods.WS_CHILD;
-            style |= NativeMethods.WS_POPUP;
-            NativeMethods.SetWindowLongPtr(_appWin, NativeMethods.GWL_STYLE, new IntPtr(style));
-
-            NativeMethods.SetParent(_appWin, IntPtr.Zero);
-
-            // Place as an 800×600 window at the centre of the target monitor, behind
-            // all other windows (HWND_BOTTOM). SWP_SHOWWINDOW makes it visible so
-            // Windows detects the monitor's DPI and delivers WM_DPICHANGED natively.
-            // A 1×1 window is below the threshold Windows uses for DPI detection.
-            NativeMethods.SetWindowPos(_appWin, NativeMethods.HWND_BOTTOM, cx, cy, 800, 600,
-                NativeMethods.SWP_NOACTIVATE | NativeMethods.SWP_SHOWWINDOW);
-
-            // Give PuTTY's message loop 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);
-
-            // Remove WS_POPUP after re-embedding; keeping it on a child window can
-            // cause painting to overflow the parent panel (see issue #167).
-            style = NativeMethods.GetWindowLong(_appWin, NativeMethods.GWL_STYLE);
-            style &= ~NativeMethods.WS_POPUP;
-            NativeMethods.SetWindowLongPtr(_appWin, NativeMethods.GWL_STYLE, new IntPtr(style));
-
-            ResizeEmbeddedWindow();
-            NativeMethods.ShowWindow(_appWin, NativeMethods.WindowShowStyle.ShowNoActivate);
-        }
-        finally
-        {
-            _isDpiChanging = false;
-        }
+        // PuTTY is a GUI application (not console-based), so the Console Font API
+        // (AttachConsole/SetCurrentConsoleFontEx) does not apply. Instead, send
+        // WM_DPICHANGED directly to the PuTTY window so it can rescale its fonts
+        // and layout internally — bypassing the cross-process delivery limitation.
+        NativeMethods.TrySendDpiChangedMessage(
+            _appWin,
+            e.OldDpi.PixelsPerInchX,
+            e.NewDpi.PixelsPerInchX);
     }
-
     #endregion
 
     #region Variables
@@ -252,8 +194,9 @@ private async Task Connect()
 
                     if (!_process.HasExited)
                     {
-                        // Capture PuTTY's DPI before embedding. If it started on a
-                        // different monitor than ours, we correct below via detach/reattach.
+                        // Capture PuTTY's window DPI before embedding. The process
+                        // might have started on a different monitor than ours, so its font
+                        // may be scaled for a different DPI. We correct this after embedding.
                         var initialWindowDpi = NativeMethods.GetDpiForWindow(_appWin);
 
                         // Enable mixed-DPI hosting on this thread before SetParent so that
@@ -267,11 +210,9 @@ private async Task Connect()
                         // Show window before set style and resize
                         NativeMethods.ShowWindow(_appWin, NativeMethods.WindowShowStyle.Maximize);
 
-                        // Remove border etc.
+                        // Remove border etc.                        
                         long style = (int)NativeMethods.GetWindowLong(_appWin, NativeMethods.GWL_STYLE);
-                        style &= ~(NativeMethods.WS_CAPTION | NativeMethods.WS_POPUP |
-                                   NativeMethods
-                                       .WS_THICKFRAME); // NativeMethods.WS_POPUP --> Overflow? (https://github.com/BornToBeRoot/NETworkManager/issues/167)
+                        style &= ~(NativeMethods.WS_CAPTION | NativeMethods.WS_POPUP | NativeMethods.WS_THICKFRAME);
                         NativeMethods.SetWindowLongPtr(_appWin, NativeMethods.GWL_STYLE, new IntPtr(style));
 
                         IsConnected = true;
@@ -282,11 +223,13 @@ private async Task Connect()
 
                         ResizeEmbeddedWindow();
 
-                        // If PuTTY started on a different DPI monitor than ours, trigger
-                        // a DPI correction now so its font matches the current monitor.
+                        // If PuTTY started at a different DPI than our panel (e.g. it
+                        // spawned on a secondary monitor with a different scale factor),
+                        // send WM_DPICHANGED so PuTTY rescales its fonts to match.
                         var currentPanelDpi = NativeMethods.GetDpiForWindow(WindowHost.Handle);
                         if (initialWindowDpi != currentPanelDpi)
-                            await TriggerDpiUpdateAsync();
+                            NativeMethods.TrySendDpiChangedMessage(_appWin,
+                                initialWindowDpi, currentPanelDpi);
                     }
                 }
             }

From 96adce7217170a3ec4380c68ef84f4160ed8a4f8 Mon Sep 17 00:00:00 2001
From: BornToBeRoot <16019165+BornToBeRoot@users.noreply.github.com>
Date: Wed, 4 Mar 2026 20:39:39 +0100
Subject: [PATCH 09/15] Chore: Refactoring / cleanup

---
 .../Controls/PowerShellControl.xaml.cs        | 31 +++++--------------
 .../Controls/PuTTYControl.xaml.cs             | 30 +++++-------------
 2 files changed, 16 insertions(+), 45 deletions(-)

diff --git a/Source/NETworkManager/Controls/PowerShellControl.xaml.cs b/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
index ad0696b014..7b016650b1 100644
--- a/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
+++ b/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
@@ -25,14 +25,10 @@ private void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArgs e)
     {
         ResizeEmbeddedWindow();
 
-        if (!IsConnected || _process == null || _process.HasExited)
+        if (!IsConnected)
             return;
 
-        // 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.
+        // Rescale the console font of the embedded conhost process so it remains the same physical size when the DPI changes.
         NativeMethods.TryRescaleConsoleFont(
             (uint)_process.Id,
             e.NewDpi.PixelsPerInchX / e.OldDpi.PixelsPerInchX);
@@ -182,18 +178,10 @@ private async Task Connect()
 
                 if (_appWin != IntPtr.Zero)
                 {
-                    // Capture the DPI of conhost's window before embedding. The process
-                    // might have started on a different monitor than ours, so its font
-                    // may be scaled for a different DPI. We correct this after embedding.
+                    // Capture DPI before embedding to correct font scaling afterwards
                     var initialWindowDpi = NativeMethods.GetDpiForWindow(_appWin);
 
-                    // 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);
@@ -205,19 +193,16 @@ private async Task Connect()
 
                     IsConnected = true;
 
-                    // Resize embedded application & refresh
-                    // Requires a short delay because it's not applied immediately
+                    // Resize after short delay — not applied immediately
                     await Task.Delay(250);
+
                     ResizeEmbeddedWindow();
 
-                    // If conhost started at a different DPI than our monitor (e.g. it
-                    // spawned on a secondary monitor with a different scale factor),
-                    // correct the font now so WindowsFormsHost_DpiChanged always starts
-                    // from the right baseline for relative scaling.
+                    // Correct font if conhost started at a different DPI than our panel
                     var currentPanelDpi = NativeMethods.GetDpiForWindow(WindowHost.Handle);
+
                     if (initialWindowDpi != currentPanelDpi)
-                        NativeMethods.TryRescaleConsoleFont((uint)_process.Id,
-                            (double)currentPanelDpi / initialWindowDpi);
+                        NativeMethods.TryRescaleConsoleFont((uint)_process.Id, (double)currentPanelDpi / initialWindowDpi);
                 }
             }
             else
diff --git a/Source/NETworkManager/Controls/PuTTYControl.xaml.cs b/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
index 78f2d3fe86..b06b247019 100644
--- a/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
+++ b/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
@@ -22,17 +22,14 @@ 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)
     {
         ResizeEmbeddedWindow();
 
-        if (!IsConnected || _process == null || _process.HasExited)
+        if (!IsConnected)
             return;
 
-        // PuTTY is a GUI application (not console-based), so the Console Font API
-        // (AttachConsole/SetCurrentConsoleFontEx) does not apply. Instead, send
-        // WM_DPICHANGED directly to the PuTTY window so it can rescale its fonts
-        // and layout internally — bypassing the cross-process delivery limitation.
+        // Send WM_DPICHANGED to the embedded window so it can rescale fonts and UI elements.
         NativeMethods.TrySendDpiChangedMessage(
             _appWin,
             e.OldDpi.PixelsPerInchX,
@@ -194,18 +191,10 @@ private async Task Connect()
 
                     if (!_process.HasExited)
                     {
-                        // Capture PuTTY's window DPI before embedding. The process
-                        // might have started on a different monitor than ours, so its font
-                        // may be scaled for a different DPI. We correct this after embedding.
+                        // Capture DPI before embedding to correct font scaling afterwards
                         var initialWindowDpi = NativeMethods.GetDpiForWindow(_appWin);
 
-                        // 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);
@@ -217,19 +206,16 @@ private async Task Connect()
 
                         IsConnected = true;
 
-                        // Resize embedded application & refresh
-                        // Requires a short delay because it's not applied immediately
+                        // Resize after short delay — not applied immediately
                         await Task.Delay(250);
 
                         ResizeEmbeddedWindow();
 
-                        // If PuTTY started at a different DPI than our panel (e.g. it
-                        // spawned on a secondary monitor with a different scale factor),
-                        // send WM_DPICHANGED so PuTTY rescales its fonts to match.
+                        // Correct DPI if PuTTY started at a different DPI than our panel
                         var currentPanelDpi = NativeMethods.GetDpiForWindow(WindowHost.Handle);
+
                         if (initialWindowDpi != currentPanelDpi)
-                            NativeMethods.TrySendDpiChangedMessage(_appWin,
-                                initialWindowDpi, currentPanelDpi);
+                            NativeMethods.TrySendDpiChangedMessage(_appWin, initialWindowDpi, currentPanelDpi);
                     }
                 }
             }

From 51ab08a362599625ac5440de56c9c10dc11742b0 Mon Sep 17 00:00:00 2001
From: BornToBeRoot <16019165+BornToBeRoot@users.noreply.github.com>
Date: Wed, 4 Mar 2026 20:55:28 +0100
Subject: [PATCH 10/15] Fix: Initial size

---
 Source/NETworkManager/Controls/PowerShellControl.xaml.cs | 6 ++++--
 Source/NETworkManager/Controls/PuTTYControl.xaml.cs      | 6 ++++--
 Source/NETworkManager/Controls/TigerVNCControl.xaml.cs   | 6 ++++--
 3 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/Source/NETworkManager/Controls/PowerShellControl.xaml.cs b/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
index 7b016650b1..844e19e580 100644
--- a/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
+++ b/Source/NETworkManager/Controls/PowerShellControl.xaml.cs
@@ -102,8 +102,10 @@ private void UserControl_Loaded(object sender, RoutedEventArgs e)
 
         // Fix 1: The control is not visible by default, thus height and width is not set. If the values are not set, the size does not scale properly
         // Fix 2: Somehow the initial size need to be 20px smaller than the actual size after using Dragablz (https://github.com/BornToBeRoot/NETworkManager/pull/2678)
-        WindowHost.Height = (int)ActualHeight - 20;
-        WindowHost.Width = (int)ActualWidth - 20;
+        // Fix 3: The size needs to be scaled by the DPI, otherwise the embedded window is too small on high DPI screens (https://github.com/BornToBeRoot/NETworkManager/pull/3352)
+        var dpi = System.Windows.Media.VisualTreeHelper.GetDpi(this);
+        WindowHost.Height = (int)((ActualHeight - 20) * dpi.DpiScaleY);
+        WindowHost.Width = (int)((ActualWidth - 20) * dpi.DpiScaleX);
 
         Connect().ConfigureAwait(false);
 
diff --git a/Source/NETworkManager/Controls/PuTTYControl.xaml.cs b/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
index b06b247019..ef1a06e5ee 100644
--- a/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
+++ b/Source/NETworkManager/Controls/PuTTYControl.xaml.cs
@@ -103,8 +103,10 @@ private void UserControl_Loaded(object sender, RoutedEventArgs e)
 
         // Fix 1: The control is not visible by default, thus height and width is not set. If the values are not set, the size does not scale properly
         // Fix 2: Somehow the initial size need to be 20px smaller than the actual size after using Dragablz (https://github.com/BornToBeRoot/NETworkManager/pull/2678)
-        WindowHost.Height = (int)ActualHeight - 20;
-        WindowHost.Width = (int)ActualWidth - 20;
+        // Fix 3: The size needs to be scaled by the DPI, otherwise the embedded window is too small on high DPI screens (https://github.com/BornToBeRoot/NETworkManager/pull/3352)
+        var dpi = System.Windows.Media.VisualTreeHelper.GetDpi(this);
+        WindowHost.Height = (int)((ActualHeight - 20) * dpi.DpiScaleY);
+        WindowHost.Width = (int)((ActualWidth - 20) * dpi.DpiScaleX);
 
         Connect().ConfigureAwait(false);
 
diff --git a/Source/NETworkManager/Controls/TigerVNCControl.xaml.cs b/Source/NETworkManager/Controls/TigerVNCControl.xaml.cs
index b4f6f4bf89..e4032144fc 100644
--- a/Source/NETworkManager/Controls/TigerVNCControl.xaml.cs
+++ b/Source/NETworkManager/Controls/TigerVNCControl.xaml.cs
@@ -88,8 +88,10 @@ private void UserControl_Loaded(object sender, RoutedEventArgs e)
             return;
 
         // Fix 1: The control is not visible by default, thus height and width is not set. If the values are not set, the size does not scale properly
-        WindowHost.Height = (int)ActualHeight;
-        WindowHost.Width = (int)ActualWidth;
+        // Fix 2: The size needs to be scaled by the DPI, otherwise the embedded window is too small on high DPI screens (https://github.com/BornToBeRoot/NETworkManager/pull/3352)
+        var dpi = System.Windows.Media.VisualTreeHelper.GetDpi(this);
+        WindowHost.Height = (int)(ActualHeight * dpi.DpiScaleY);
+        WindowHost.Width = (int)(ActualWidth * dpi.DpiScaleX);
 
         Connect().ConfigureAwait(false);
 

From b1cad9ad68e2eb0fc4dbb0cfbeec048aac9b13e4 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 4 Mar 2026 20:02:13 +0000
Subject: [PATCH 11/15] Blog: Add technical article on high DPI for embedded
 processes (conhost + GUI)

Co-authored-by: BornToBeRoot <16019165+BornToBeRoot@users.noreply.github.com>
---
 .../index.md                                  | 282 ++++++++++++++++++
 1 file changed, 282 insertions(+)
 create mode 100644 Website/blog/2026-03-04-high-dpi-embedded-processes/index.md

diff --git a/Website/blog/2026-03-04-high-dpi-embedded-processes/index.md b/Website/blog/2026-03-04-high-dpi-embedded-processes/index.md
new file mode 100644
index 0000000000..2a30f36f98
--- /dev/null
+++ b/Website/blog/2026-03-04-high-dpi-embedded-processes/index.md
@@ -0,0 +1,282 @@
+---
+slug: high-dpi-embedded-processes
+title: "High DPI for Embedded Processes in WPF: Making SetParent Work Across Monitor Scales"
+authors: [borntoberoot]
+tags: [wpf, dpi, windows, c#, win32, putty, powershell]
+---
+
+Modern Windows setups with multiple monitors at different scale factors (100 %, 125 %, 150 %, …) expose a hard Win32 limitation the moment you embed a foreign process window into your own application via `SetParent`. Windows simply does not forward `WM_DPICHANGED` across process boundaries.
+
+This article documents the investigation and the two different solutions NETworkManager uses for its embedded **PowerShell** (a console host process) and **PuTTY** (a GUI process) tabs — together with the complete, relevant C# source code.
+
+<!-- truncate -->
+
+## The Embedding Technique
+
+NETworkManager uses `WindowsFormsHost` to host a native Win32 `Panel` (WinForms `Panel`), and then calls `SetParent` to re-parent a foreign process window into that panel:
+
+```csharp
+// Make the external process window a child of our WinForms panel
+NativeMethods.SetParent(_appWin, WindowHost.Handle);
+
+// Strip decorations so it looks native inside our tab
+long style = (int)NativeMethods.GetWindowLong(_appWin, NativeMethods.GWL_STYLE);
+style &= ~(NativeMethods.WS_CAPTION | NativeMethods.WS_POPUP | NativeMethods.WS_THICKFRAME);
+NativeMethods.SetWindowLongPtr(_appWin, NativeMethods.GWL_STYLE, new IntPtr(style));
+```
+
+This works fine visually — the external window appears seamlessly inside the WPF application. **But fonts never rescale when the user drags the window to a monitor with a different DPI.**
+
+## Why DPI Notifications Break
+
+WPF applications declare `PerMonitorV2` DPI awareness in their manifest. When the application's `HwndSource` (the root Win32 window) moves to a different DPI monitor, Windows walks the entire Win32 window tree within the **same process** and sends `WM_DPICHANGED` / `WM_DPICHANGED_AFTERPARENT` to every child. The `WindowsFormsHost` → `WindowHost` chain is all in-process, so it receives `DpiChanged` events correctly.
+
+The problem is that `_appWin` is owned by a **completely separate process** (PuTTY, conhost). From the Windows DWM compositor's perspective it is now a child window of your panel, but the DPI notification system only walks intra-process window trees. The external child window never receives any DPI message.
+
+### What Does Not Work
+
+Before arriving at the solutions below, several approaches were tried:
+
+| Attempt | Why it failed |
+|---------|---------------|
+| Send `WM_DPICHANGED_AFTERPARENT` (0x02E3) | Causes the process to call `GetDpiForWindow` on itself — returns the DPI of its **current monitor** (now wrong because it is a child, not a top-level window) |
+| Send `WM_DPICHANGED` (0x02E0) with explicit DPI in wParam | Works only for newer PuTTY builds (0.75+) that handle this message; breaks for older builds and doesn't help console processes at all |
+| Hide → detach → move → re-embed | **Hiding** the window before detaching prevents the trigger: Windows only sends `WM_DPICHANGED` to **visible** top-level windows that cross a monitor DPI boundary |
+
+## Solution A — Console Host Processes (PowerShell, cmd)
+
+PowerShell runs inside **conhost.exe**, the Windows console host. Unlike a GUI process, conhost exposes its font settings through the Console API (`kernel32.dll`). This is a true cross-process interface: any process can attach to an existing console and modify its font without sending any window messages.
+
+```csharp
+// NativeMethods helpers used below
+[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", 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);
+```
+
+### Rescale helper
+
+```csharp
+/// <summary>
+/// Attaches to <paramref name="processId"/>'s console and rescales its current font
+/// by <paramref name="scaleFactor"/> using SetCurrentConsoleFontEx.
+/// 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(); }
+}
+```
+
+### Using it in the PowerShell control
+
+`WindowsFormsHost` raises `DpiChanged` when the parent WPF window moves monitors. The handler uses the `NewDpi / OldDpi` ratio to rescale the font relatively:
+
+```csharp
+private void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArgs e)
+{
+    ResizeEmbeddedWindow();
+
+    if (!IsConnected)
+        return;
+
+    NativeMethods.TryRescaleConsoleFont(
+        (uint)_process.Id,
+        e.NewDpi.PixelsPerInchX / e.OldDpi.PixelsPerInchX);
+}
+```
+
+### Fixing the initial DPI baseline
+
+There is a subtle bug if the embedded process spawns on a **different monitor** than NETworkManager: conhost's font is scaled for *its* monitor's DPI, not ours. Every subsequent `newDpi/oldDpi` relative rescale will then compound the error.
+
+Fix: read `GetDpiForWindow` for both windows **before** `SetParent`, and correct the baseline immediately after embedding:
+
+```csharp
+// Capture DPI before embedding to correct font scaling afterwards
+var initialWindowDpi = NativeMethods.GetDpiForWindow(_appWin);
+
+NativeMethods.SetParent(_appWin, WindowHost.Handle);
+// ... ShowWindow, strip styles, IsConnected = true ...
+
+await Task.Delay(250);
+ResizeEmbeddedWindow();
+
+// Correct font if conhost started at a different DPI than our panel
+var currentPanelDpi = NativeMethods.GetDpiForWindow(WindowHost.Handle);
+if (initialWindowDpi != currentPanelDpi)
+    NativeMethods.TryRescaleConsoleFont(
+        (uint)_process.Id,
+        (double)currentPanelDpi / initialWindowDpi);
+```
+
+`GetDpiForWindow` is available since Windows 10 version 1607:
+
+```csharp
+[DllImport("user32.dll")]
+public static extern uint GetDpiForWindow(IntPtr hWnd);
+```
+
+## Solution B — GUI Processes (PuTTY)
+
+PuTTY is a standard Win32 GUI application, not a console. The Console API does not apply. Instead, the approach is to send `WM_DPICHANGED` (0x02E0) directly to the PuTTY window, which it handles natively (requires PuTTY 0.75+ for reliable behaviour).
+
+`WM_DPICHANGED` carries the new DPI packed into `wParam` (LOWORD = DPI X, HIWORD = DPI Y) and a `RECT*` in `lParam` with the suggested new window rect:
+
+```csharp
+/// <summary>
+/// Sends WM_DPICHANGED to a GUI window so it can rescale its fonts and layout.
+/// WM_DPICHANGED is not reliably forwarded to cross-process child windows
+/// embedded via SetParent, so we send it explicitly.
+/// </summary>
+public static void TrySendDpiChangedMessage(IntPtr hWnd, double oldDpi, double newDpi)
+{
+    if (hWnd == IntPtr.Zero)
+        return;
+
+    if (Math.Abs(newDpi - oldDpi) < 0.01)
+        return;
+
+    const uint WM_DPICHANGED = 0x02E0;
+
+    var newDpiInt = (int)Math.Round(newDpi);
+    // HIWORD = Y DPI, LOWORD = X DPI
+    var wParam = (IntPtr)((newDpiInt << 16) | newDpiInt);
+
+    // lParam must point to a RECT with the suggested new size/position.
+    var rect = new RECT();
+    GetWindowRect(hWnd, ref rect);
+
+    var lParam = Marshal.AllocHGlobal(Marshal.SizeOf<RECT>());
+    try
+    {
+        Marshal.StructureToPtr(rect, lParam, false);
+        SendMessage(hWnd, WM_DPICHANGED, wParam, lParam);
+    }
+    finally
+    {
+        Marshal.FreeHGlobal(lParam);
+    }
+}
+```
+
+### Using it in the PuTTY control
+
+```csharp
+private void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArgs e)
+{
+    ResizeEmbeddedWindow();
+
+    if (!IsConnected)
+        return;
+
+    NativeMethods.TrySendDpiChangedMessage(
+        _appWin,
+        e.OldDpi.PixelsPerInchX,
+        e.NewDpi.PixelsPerInchX);
+}
+```
+
+### Fixing the initial DPI baseline for PuTTY
+
+Same issue as PowerShell: PuTTY may start on a different monitor. Because PuTTY is a GUI process, the console API does not apply — but the explicit `WM_DPICHANGED` message works for the initial correction too:
+
+```csharp
+// Capture DPI before embedding
+var initialWindowDpi = NativeMethods.GetDpiForWindow(_appWin);
+
+NativeMethods.SetParent(_appWin, WindowHost.Handle);
+// ... ShowWindow, strip styles, IsConnected = true ...
+
+await Task.Delay(250);
+ResizeEmbeddedWindow();
+
+// Correct DPI if PuTTY started at a different DPI than our panel
+var currentPanelDpi = NativeMethods.GetDpiForWindow(WindowHost.Handle);
+if (initialWindowDpi != currentPanelDpi)
+    NativeMethods.TrySendDpiChangedMessage(_appWin, initialWindowDpi, currentPanelDpi);
+```
+
+## Sizing the WindowsFormsHost at Load
+
+One more pitfall: `WindowsFormsHost` starts with zero size because WPF's logical pixel coordinates do not account for the system DPI. The panel's `ClientSize` must be set in **physical pixels**:
+
+```csharp
+private void UserControl_Loaded(object sender, RoutedEventArgs e)
+{
+    if (_initialized) return;
+
+    // VisualTreeHelper.GetDpi returns DpiScaleX/Y as a ratio (1.0 = 96 DPI, 1.5 = 144 DPI).
+    var dpi = System.Windows.Media.VisualTreeHelper.GetDpi(this);
+    WindowHost.Height = (int)((ActualHeight - 20) * dpi.DpiScaleY);
+    WindowHost.Width  = (int)((ActualWidth  - 20) * dpi.DpiScaleX);
+
+    Connect().ConfigureAwait(false);
+    _initialized = true;
+}
+```
+
+The `-20` offset compensates for a layout quirk introduced by the Dragablz tab control (see [pull request #2678](https://github.com/BornToBeRoot/NETworkManager/pull/2678)).
+
+## Summary
+
+| Process type | DPI change handler | Initial DPI correction |
+|---|---|---|
+| **Console host** (conhost.exe) | `AttachConsole` + `SetCurrentConsoleFontEx` with `newDpi / oldDpi` scale factor | Same — compare `GetDpiForWindow` before and after embed |
+| **GUI process** (PuTTY, any Win32 app) | Send `WM_DPICHANGED` (0x02E0) with explicit new DPI | Same — send `WM_DPICHANGED` from old to new DPI |
+| Both | `WindowsFormsHost` initial size set in physical pixels via `VisualTreeHelper.GetDpi` | — |
+
+The full implementation is available in the NETworkManager source:
+
+- [`NETworkManager.Utilities/NativeMethods.cs`](https://github.com/BornToBeRoot/NETworkManager/blob/main/Source/NETworkManager.Utilities/NativeMethods.cs) — all P/Invoke declarations and helpers
+- [`NETworkManager/Controls/PowerShellControl.xaml.cs`](https://github.com/BornToBeRoot/NETworkManager/blob/main/Source/NETworkManager/Controls/PowerShellControl.xaml.cs) — console host approach
+- [`NETworkManager/Controls/PuTTYControl.xaml.cs`](https://github.com/BornToBeRoot/NETworkManager/blob/main/Source/NETworkManager/Controls/PuTTYControl.xaml.cs) — GUI process approach
+
+If you encounter a similar cross-process embedding scenario, open an [issue on GitHub](https://github.com/BornToBeRoot/NETworkManager/issues) — we are happy to discuss edge cases.

From 5a7794396c5522d8fb89f24c33e3a46b0a899c65 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 4 Mar 2026 20:17:28 +0000
Subject: [PATCH 12/15] Cleanup: remove unused constants, DPI_HOSTING_BEHAVIOR
 enum, and SetThreadDpiHostingBehavior from NativeMethods

Co-authored-by: BornToBeRoot <16019165+BornToBeRoot@users.noreply.github.com>
---
 .../NETworkManager.Utilities/NativeMethods.cs | 29 -------------------
 1 file changed, 29 deletions(-)

diff --git a/Source/NETworkManager.Utilities/NativeMethods.cs b/Source/NETworkManager.Utilities/NativeMethods.cs
index 5f2b0799b3..999edcc642 100644
--- a/Source/NETworkManager.Utilities/NativeMethods.cs
+++ b/Source/NETworkManager.Utilities/NativeMethods.cs
@@ -13,14 +13,8 @@ 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(1);
 
     /// <summary>The value returned by CreateFile on failure.</summary>
     public static readonly IntPtr INVALID_HANDLE_VALUE = new(-1);
@@ -51,19 +45,6 @@ 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
@@ -130,16 +111,6 @@ 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);
-
     /// <summary>
     /// Returns the DPI (dots per inch) value for the monitor that contains the specified window.
     /// Returns 0 if the window handle is invalid. Available on Windows 10 version 1607+.

From 440e7e864476f5fe892d110eef3571a5c4607617 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 4 Mar 2026 20:19:40 +0000
Subject: [PATCH 13/15] Add DPI/font scaling and initial size bug fix entries
 to next-release changelog

Co-authored-by: BornToBeRoot <16019165+BornToBeRoot@users.noreply.github.com>
---
 Website/docs/changelog/next-release.md | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/Website/docs/changelog/next-release.md b/Website/docs/changelog/next-release.md
index 520449fa34..93098bd2fa 100644
--- a/Website/docs/changelog/next-release.md
+++ b/Website/docs/changelog/next-release.md
@@ -19,10 +19,30 @@ Release date: **xx.xx.2025**
 
 ## What's new?
 
+**PowerShell**
+
+- DPI scaling is now applied correctly when NETworkManager is moved to a monitor with a different DPI scaling factor. The embedded PowerShell (conhost) window now rescales its font automatically using the Windows Console API (`AttachConsole` + `SetCurrentConsoleFontEx`), bypassing the OS limitation that prevents `WM_DPICHANGED` from being forwarded to cross-process child windows. [#3352](https://github.com/BornToBeRoot/NETworkManager/pull/3352)
+
+**PuTTY**
+
+- DPI scaling is now applied correctly when NETworkManager is moved to a monitor with a different DPI scaling factor. The embedded PuTTY window now receives an explicit `WM_DPICHANGED` message with the new DPI value packed into `wParam`, since the OS does not forward this message across process boundaries after `SetParent`. [#3352](https://github.com/BornToBeRoot/NETworkManager/pull/3352)
+
 ## Improvements
 
 ## Bug Fixes
 
+**PowerShell**
+
+- Fixed incorrect initial embedded window size on high-DPI monitors. The `WindowsFormsHost` panel now sets its initial dimensions in physical pixels using the current DPI scale factor, ensuring the PowerShell window fills the panel correctly at startup. [#3352](https://github.com/BornToBeRoot/NETworkManager/pull/3352)
+
+**PuTTY**
+
+- Fixed incorrect initial embedded window size on high-DPI monitors. The `WindowsFormsHost` panel now sets its initial dimensions in physical pixels using the current DPI scale factor, ensuring the PuTTY window fills the panel correctly at startup. [#3352](https://github.com/BornToBeRoot/NETworkManager/pull/3352)
+
+**TigerVNC**
+
+- Fixed incorrect initial embedded window size on high-DPI monitors. The `WindowsFormsHost` panel now sets its initial dimensions in physical pixels using the current DPI scale factor, ensuring the TigerVNC window fills the panel correctly at startup. [#3352](https://github.com/BornToBeRoot/NETworkManager/pull/3352)
+
 ## Dependencies, Refactoring & Documentation
 
 - Code cleanup & refactoring

From 8389c17916fcd6297d49d0e7cc6a9b6b116e70bc Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 4 Mar 2026 20:37:55 +0000
Subject: [PATCH 14/15] Update blog post: add C#/WPF mention, XAML snippet,
 inline comments, remove "What Does Not Work" table, rewrite summary

Co-authored-by: BornToBeRoot <16019165+BornToBeRoot@users.noreply.github.com>
---
 .../index.md                                  | 36 +++++++++----------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/Website/blog/2026-03-04-high-dpi-embedded-processes/index.md b/Website/blog/2026-03-04-high-dpi-embedded-processes/index.md
index 2a30f36f98..6109d64b35 100644
--- a/Website/blog/2026-03-04-high-dpi-embedded-processes/index.md
+++ b/Website/blog/2026-03-04-high-dpi-embedded-processes/index.md
@@ -13,7 +13,17 @@ This article documents the investigation and the two different solutions NETwork
 
 ## The Embedding Technique
 
-NETworkManager uses `WindowsFormsHost` to host a native Win32 `Panel` (WinForms `Panel`), and then calls `SetParent` to re-parent a foreign process window into that panel:
+NETworkManager is a C#/WPF application that uses `WindowsFormsHost` to host a native Win32 `Panel` (WinForms `Panel`), and then calls `SetParent` to re-parent a foreign process window into that panel.
+
+The XAML wires up the `DpiChanged` event and embeds a WinForms `Panel` as the hosting surface:
+
+```xaml
+<WindowsFormsHost DpiChanged="WindowsFormsHost_DpiChanged">
+    <windowsForms:Panel x:Name="WindowHost" />
+</WindowsFormsHost>
+```
+
+The C# code-behind then calls `SetParent` to embed the external process window:
 
 ```csharp
 // Make the external process window a child of our WinForms panel
@@ -33,16 +43,6 @@ WPF applications declare `PerMonitorV2` DPI awareness in their manifest. When th
 
 The problem is that `_appWin` is owned by a **completely separate process** (PuTTY, conhost). From the Windows DWM compositor's perspective it is now a child window of your panel, but the DPI notification system only walks intra-process window trees. The external child window never receives any DPI message.
 
-### What Does Not Work
-
-Before arriving at the solutions below, several approaches were tried:
-
-| Attempt | Why it failed |
-|---------|---------------|
-| Send `WM_DPICHANGED_AFTERPARENT` (0x02E3) | Causes the process to call `GetDpiForWindow` on itself — returns the DPI of its **current monitor** (now wrong because it is a child, not a top-level window) |
-| Send `WM_DPICHANGED` (0x02E0) with explicit DPI in wParam | Works only for newer PuTTY builds (0.75+) that handle this message; breaks for older builds and doesn't help console processes at all |
-| Hide → detach → move → re-embed | **Hiding** the window before detaching prevents the trigger: Windows only sends `WM_DPICHANGED` to **visible** top-level windows that cross a monitor DPI boundary |
-
 ## Solution A — Console Host Processes (PowerShell, cmd)
 
 PowerShell runs inside **conhost.exe**, the Windows console host. Unlike a GUI process, conhost exposes its font settings through the Console API (`kernel32.dll`). This is a true cross-process interface: any process can attach to an existing console and modify its font without sending any window messages.
@@ -127,6 +127,9 @@ private void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArgs e)
     if (!IsConnected)
         return;
 
+    // Rescale the console font using the new/old DPI ratio via the Console API.
+    // WM_DPICHANGED is never forwarded to cross-process child windows,
+    // so we use AttachConsole + SetCurrentConsoleFontEx instead.
     NativeMethods.TryRescaleConsoleFont(
         (uint)_process.Id,
         e.NewDpi.PixelsPerInchX / e.OldDpi.PixelsPerInchX);
@@ -217,6 +220,9 @@ private void WindowsFormsHost_DpiChanged(object sender, DpiChangedEventArgs e)
     if (!IsConnected)
         return;
 
+    // Send WM_DPICHANGED explicitly to the PuTTY window with the new DPI.
+    // WM_DPICHANGED is never forwarded to cross-process child windows after SetParent,
+    // so we inject the message directly.
     NativeMethods.TrySendDpiChangedMessage(
         _appWin,
         e.OldDpi.PixelsPerInchX,
@@ -267,16 +273,10 @@ The `-20` offset compensates for a layout quirk introduced by the Dragablz tab c
 
 ## Summary
 
-| Process type | DPI change handler | Initial DPI correction |
-|---|---|---|
-| **Console host** (conhost.exe) | `AttachConsole` + `SetCurrentConsoleFontEx` with `newDpi / oldDpi` scale factor | Same — compare `GetDpiForWindow` before and after embed |
-| **GUI process** (PuTTY, any Win32 app) | Send `WM_DPICHANGED` (0x02E0) with explicit new DPI | Same — send `WM_DPICHANGED` from old to new DPI |
-| Both | `WindowsFormsHost` initial size set in physical pixels via `VisualTreeHelper.GetDpi` | — |
+When you embed a foreign process window via `SetParent`, Windows never forwards DPI change notifications across process boundaries. For console host processes (PowerShell, cmd) use the Windows Console API (`AttachConsole` + `SetCurrentConsoleFontEx`) to rescale fonts directly; for GUI processes (PuTTY) send `WM_DPICHANGED` (0x02E0) explicitly with the new DPI packed into `wParam`. In both cases, apply an initial DPI correction after `SetParent` by comparing `GetDpiForWindow` before and after embedding, and set the `WindowsFormsHost` initial size in physical pixels using `VisualTreeHelper.GetDpi`.
 
 The full implementation is available in the NETworkManager source:
 
 - [`NETworkManager.Utilities/NativeMethods.cs`](https://github.com/BornToBeRoot/NETworkManager/blob/main/Source/NETworkManager.Utilities/NativeMethods.cs) — all P/Invoke declarations and helpers
 - [`NETworkManager/Controls/PowerShellControl.xaml.cs`](https://github.com/BornToBeRoot/NETworkManager/blob/main/Source/NETworkManager/Controls/PowerShellControl.xaml.cs) — console host approach
 - [`NETworkManager/Controls/PuTTYControl.xaml.cs`](https://github.com/BornToBeRoot/NETworkManager/blob/main/Source/NETworkManager/Controls/PuTTYControl.xaml.cs) — GUI process approach
-
-If you encounter a similar cross-process embedding scenario, open an [issue on GitHub](https://github.com/BornToBeRoot/NETworkManager/issues) — we are happy to discuss edge cases.

From a5c76d1a269a65912ddf414b5d0c6729fcc84893 Mon Sep 17 00:00:00 2001
From: BornToBeRoot <16019165+BornToBeRoot@users.noreply.github.com>
Date: Wed, 4 Mar 2026 21:47:56 +0100
Subject: [PATCH 15/15] Docs: Add descriptions to blog entries

---
 Website/blog/2024-01-01-welcome/index.md                         | 1 +
 .../2024-05-24-introducing-code-signing-to-binaries/index.md     | 1 +
 Website/blog/2025-09-06-introducing-hosts-file-editor/index.md   | 1 +
 .../index.md                                                     | 1 +
 .../blog/2025-10-23-improved-light-theme-readability/index.md    | 1 +
 .../index.md                                                     | 1 +
 Website/blog/2026-03-04-high-dpi-embedded-processes/index.md     | 1 +
 7 files changed, 7 insertions(+)

diff --git a/Website/blog/2024-01-01-welcome/index.md b/Website/blog/2024-01-01-welcome/index.md
index 27e6d2b42b..453ae1a347 100644
--- a/Website/blog/2024-01-01-welcome/index.md
+++ b/Website/blog/2024-01-01-welcome/index.md
@@ -1,6 +1,7 @@
 ---
 slug: welcome
 title: Welcome
+description: "Welcome to the new NETworkManager website, blod and documentation. It's build with Docusaurus, a static website generator, and hosted on GitHub Pages."
 authors: [borntoberoot]
 tags: [welcome, docusaurus]
 ---
diff --git a/Website/blog/2024-05-24-introducing-code-signing-to-binaries/index.md b/Website/blog/2024-05-24-introducing-code-signing-to-binaries/index.md
index dc73d7ec58..b09b4953fc 100644
--- a/Website/blog/2024-05-24-introducing-code-signing-to-binaries/index.md
+++ b/Website/blog/2024-05-24-introducing-code-signing-to-binaries/index.md
@@ -1,6 +1,7 @@
 ---
 slug: introducing-code-signing-for-binaries
 title: Introducing Code Signing for Binaries
+description: "Starting with NETworkManager version 2024.5.24.0, the binaries and the installer are now signed with a code signing certificate."
 authors: [borntoberoot]
 tags: [code-signing, binaries, installer]
 ---
diff --git a/Website/blog/2025-09-06-introducing-hosts-file-editor/index.md b/Website/blog/2025-09-06-introducing-hosts-file-editor/index.md
index b431d95199..4dad09ff1f 100644
--- a/Website/blog/2025-09-06-introducing-hosts-file-editor/index.md
+++ b/Website/blog/2025-09-06-introducing-hosts-file-editor/index.md
@@ -1,6 +1,7 @@
 ---
 slug: introducing-hosts-file-editor
 title: Introducing Hosts File Editor
+description: "NETworkManager 2025.8.10.0 introduced a new feature, the `Hosts File Editor`. You can now easily manage and edit your system's hosts file in a user-friendly interface."
 authors: [borntoberoot]
 tags: [hosts file, dns, new feature]
 ---
diff --git a/Website/blog/2025-10-19-streamlined-profile-management-with-tags-and-filters/index.md b/Website/blog/2025-10-19-streamlined-profile-management-with-tags-and-filters/index.md
index 44927079ac..33894669e3 100644
--- a/Website/blog/2025-10-19-streamlined-profile-management-with-tags-and-filters/index.md
+++ b/Website/blog/2025-10-19-streamlined-profile-management-with-tags-and-filters/index.md
@@ -1,6 +1,7 @@
 ---
 slug: streamlined-profile-management-with-tags-and-filters
 title: Streamlined Profile Management with Tags & Filters
+description: "NETworkManager 2025.10.18.0 brings a streamlined approach to profile management with the introduction of Tags and Filtering. You can now add or remove tags directly within each profile, making it effortless to organize and quickly locate your hosts and networks."
 authors: [borntoberoot]
 tags: [profile management, tags, new feature]
 ---
diff --git a/Website/blog/2025-10-23-improved-light-theme-readability/index.md b/Website/blog/2025-10-23-improved-light-theme-readability/index.md
index 1653e0b610..0e98347a16 100644
--- a/Website/blog/2025-10-23-improved-light-theme-readability/index.md
+++ b/Website/blog/2025-10-23-improved-light-theme-readability/index.md
@@ -1,6 +1,7 @@
 ---
 slug: improved-light-theme-readability
 title: Improved light theme readability
+description: "The latest release of NETworkManager (version 2025.10.18.0) introduces major enhancements to the light theme, improving both readability and overall user experience. This article highlights the changes made to the light theme and how they enhance usability."
 authors: [borntoberoot]
 tags: [theme, ui]
 ---
diff --git a/Website/blog/2026-02-22-system-wide-policies-for-enterprise-deployments/index.md b/Website/blog/2026-02-22-system-wide-policies-for-enterprise-deployments/index.md
index 7a6d1e0404..997b23bf37 100644
--- a/Website/blog/2026-02-22-system-wide-policies-for-enterprise-deployments/index.md
+++ b/Website/blog/2026-02-22-system-wide-policies-for-enterprise-deployments/index.md
@@ -1,6 +1,7 @@
 ---
 slug: system-wide-policies-for-enterprise-deployments
 title: System-Wide Policies for Enterprise Deployments
+description: "NETworkManager now supports system-wide policies, giving administrators centralized control over application settings across all users on a machine. This article explains how to configure and deploy these policies in enterprise environments."
 authors: [borntoberoot]
 tags: [policies, enterprise, settings, new feature]
 ---
diff --git a/Website/blog/2026-03-04-high-dpi-embedded-processes/index.md b/Website/blog/2026-03-04-high-dpi-embedded-processes/index.md
index 6109d64b35..ca4a815c7f 100644
--- a/Website/blog/2026-03-04-high-dpi-embedded-processes/index.md
+++ b/Website/blog/2026-03-04-high-dpi-embedded-processes/index.md
@@ -1,6 +1,7 @@
 ---
 slug: high-dpi-embedded-processes
 title: "High DPI for Embedded Processes in WPF: Making SetParent Work Across Monitor Scales"
+description: "When you embed a foreign process window via SetParent in WPF, it never receives DPI change notifications across process boundaries. This article shows how to rescale fonts for embedded console hosts (PowerShell) using the Console API, and for GUI processes (PuTTY) by sending WM_DPICHANGED explicitly."
 authors: [borntoberoot]
 tags: [wpf, dpi, windows, c#, win32, putty, powershell]
 ---