Request: Resize Border Outside the Window Like Native Windows

[Davidlegendre]

First of all, I just want to say that the WPF library is truly amazing—beautiful, powerful, and incredibly well-designed.

Now, regarding the resize border: I understand that the library uses a custom window for styling, which looks great. However, the resize border is currently inside the window. I’d like to suggest making the resize border behave like in native Windows—outside the window content area.

This small change would make a big difference in usability and would set the library apart even more. To my knowledge, no other library implements this feature, and adding it could make this one truly unique.

Thanks for the great work—really impressive stuff!

[chucker]

Likely related to #1414. Are you sure the wrong resize behavior happens below the title bar as well?

[Davidlegendre]

No, rather, I mean the entire resize border of the window — that it should be outside, like in Windows. When you move the cursor to the edges, it only changes when it's outside the window. But in the library, it resizes when the cursor is over the inner areas of the window.

I have a example code:

 public partial class MainWindow : Window
 {
     public MainWindow()
     {
         InitializeComponent();

         Loaded += async (_, __) =>
         {
             try
             {
                 await webView.EnsureCoreWebView2Async();
                 webView.CoreWebView2.Navigate("https://www.google.com");
             }
             catch (Exception ex)
             {
                 MessageBox.Show("Error al inicializar WebView2: " + ex.Message);
             }
         };

         Loaded += MainWindow_Loaded;
         StateChanged += Window_StateChanged;
     }

     private void MainWindow_Loaded(object sender, RoutedEventArgs e)
     {
         var hwnd = new WindowInteropHelper(this).Handle;
         HwndSource.FromHwnd(hwnd)?.AddHook(WindowProc);
         AdjustLayout();
     }

     private void Window_StateChanged(object sender, EventArgs e)
     {
         AdjustLayout();
     }

     private void AdjustLayout()
     {
         if (WindowState == WindowState.Maximized)
         {
             WindowBorder.BorderThickness = new Thickness(0);
             WindowBorder.CornerRadius = new CornerRadius(0);
             LayoutRoot.Margin = new Thickness(0);
         }
         else
         {
             WindowBorder.BorderThickness = new Thickness(0);
             WindowBorder.CornerRadius = new CornerRadius(8);
             LayoutRoot.Margin = new Thickness(0);
         }
     }

     private IntPtr WindowProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
     {
         const int WM_NCHITTEST = 0x0084;
         const int WM_GETMINMAXINFO = 0x0024;

         if (msg == WM_GETMINMAXINFO)
         {
             WmGetMinMaxInfo(hwnd, lParam);
             handled = true;
         }

         if (msg == WM_NCHITTEST)
         {
             if (WindowState == WindowState.Maximized)
             {
                 // Si está maximizada, solo permitir mover desde la barra
                 var mousePos = lParam.ToInt32();
                 int x = mousePos & 0xFFFF;
                 int y = (mousePos >> 16) & 0xFFFF;
                 var point = PointFromScreen(new Point(x, y));

                 if (point.Y <= TitleBar.ActualHeight && point.X >= 80 && point.X <= ActualWidth - 80)
                 {
                     handled = true;
                     return (IntPtr)2; // HTCAPTION (drag)
                 }

                 handled = true;
                 return (IntPtr)1; // HTCLIENT (no redimensiona)
             }

             // Si NO está maximizada, permitir redimensionar
             {
                 var mousePos = lParam.ToInt32();
                 int x = mousePos & 0xFFFF;
                 int y = (mousePos >> 16) & 0xFFFF;
                 var point = PointFromScreen(new Point(x, y));

                 double edge = 8;

                 if (point.Y <= edge)
                 {
                     if (point.X <= edge) { handled = true; return (IntPtr)13; }
                     if (point.X >= ActualWidth - edge) { handled = true; return (IntPtr)14; }
                     handled = true; return (IntPtr)12;
                 }
                 else if (point.Y >= ActualHeight - edge)
                 {
                     if (point.X <= edge) { handled = true; return (IntPtr)16; }
                     if (point.X >= ActualWidth - edge) { handled = true; return (IntPtr)17; }
                     handled = true; return (IntPtr)15;
                 }
                 else if (point.X <= edge)
                 {
                     handled = true; return (IntPtr)10;
                 }
                 else if (point.X >= ActualWidth - edge)
                 {
                     handled = true; return (IntPtr)11;
                 }

                 if (point.Y <= TitleBar.ActualHeight && point.X >= 80 && point.X <= ActualWidth - 80)
                 {
                     handled = true;
                     return (IntPtr)2; // HTCAPTION (drag)
                 }
             }
         }


         return IntPtr.Zero;
     }

     private void WmGetMinMaxInfo(IntPtr hwnd, IntPtr lParam)
     {
         IntPtr monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);

         if (monitor != IntPtr.Zero)
         {
             MONITORINFO monitorInfo = new MONITORINFO();
             monitorInfo.cbSize = Marshal.SizeOf(typeof(MONITORINFO));
             GetMonitorInfo(monitor, ref monitorInfo);

             RECT workArea = monitorInfo.rcWork;
             RECT monitorArea = monitorInfo.rcMonitor;

             MINMAXINFO mmi = Marshal.PtrToStructure<MINMAXINFO>(lParam);

             mmi.ptMaxPosition.x = Math.Abs(workArea.Left - monitorArea.Left);
             mmi.ptMaxPosition.y = Math.Abs(workArea.Top - monitorArea.Top);
             mmi.ptMaxSize.x = Math.Abs(workArea.Right - workArea.Left);
             mmi.ptMaxSize.y = Math.Abs(workArea.Bottom - workArea.Top);

             Marshal.StructureToPtr(mmi, lParam, true);
         }
     }

     // ==== Win32 ====

     private const int MONITOR_DEFAULTTONEAREST = 0x00000002;

     [DllImport("user32.dll")]
     private static extern IntPtr MonitorFromWindow(IntPtr hwnd, int dwFlags);

     [DllImport("user32.dll")]
     private static extern bool GetMonitorInfo(IntPtr hMonitor, ref MONITORINFO lpmi);

     [StructLayout(LayoutKind.Sequential)]
     public struct RECT
     {
         public int Left, Top, Right, Bottom;
     }

     [StructLayout(LayoutKind.Sequential)]
     public struct MONITORINFO
     {
         public int cbSize;
         public RECT rcMonitor;
         public RECT rcWork;
         public int dwFlags;
     }

     [StructLayout(LayoutKind.Sequential)]
     public struct POINT
     {
         public int x;
         public int y;
     }

     [StructLayout(LayoutKind.Sequential)]
     public struct MINMAXINFO
     {
         public POINT ptReserved;
         public POINT ptMaxSize;
         public POINT ptMaxPosition;
         public POINT ptMinTrackSize;
         public POINT ptMaxTrackSize;
     }
 }

<Window x:Class="LBrowser.View.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:wv2="clr-namespace:Microsoft.Web.WebView2.Wpf;assembly=Microsoft.Web.WebView2.Wpf"
        Title="LBrowser"
        Width="1000" Height="700"
        WindowStyle="None"
        ResizeMode="CanResize"
        Background="White"
        Loaded="MainWindow_Loaded"
        StateChanged="Window_StateChanged">

But the code have problems in Window State Maximized