Question: How to set minimum window size (Desktop)

[dynamiquel]

WinUI 3 Preview 2 Desktop C#

Sorry, but how do I set the minimum window size? Currently the app can be shrunk almost entirely.

[StephenLPeters]

does this do iApplicationView.GetForCurrentView().SetPreferredMinSize()? It seems like the default window size for the desktop skew might be strang @MikeHillberg do you know if we have the ability to set a more reasonable default?

[ranjeshj]

@marb2000 for the window APIs.

[marb2000]

Desktop WinUI 3 don't have MinSize or MaxSize properties yet on a Window class, and it's not trivial to do this for a developer. The way to do it in Win32 is listening the message WM_GETMINMAXINFO, but you need first to get access to the procedure that get the messages in Windows (the WindowProc). Unfortunately, WinUI 3 Desktop doesn't expose it, so the solution is Subclassing. Subclassing allows to intercept and process messages sent to window before the WindowProc.

I wrote this code snippet that could help you to understand what to do:

using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;

using System;
using System.Runtime.InteropServices;
using System.Threading.Tasks;

using WinRT;

  public sealed partial class MainWindow : Window
    {
        public MainWindow()
        {
            this.InitializeComponent();
            SubClassing();
        }

        private delegate IntPtr WinProc(IntPtr hWnd, PInvoke.User32.WindowMessage Msg, IntPtr wParam, IntPtr lParam);
        private WinProc newWndProc = null;
        private IntPtr oldWndProc = IntPtr.Zero;
        [DllImport("user32")]
        private static extern IntPtr SetWindowLong(IntPtr hWnd, PInvoke.User32.WindowLongIndexFlags nIndex, WinProc newProc);
        [DllImport("user32.dll")]
        static extern IntPtr CallWindowProc(IntPtr lpPrevWndFunc, IntPtr hWnd, PInvoke.User32.WindowMessage Msg, IntPtr wParam, IntPtr lParam);

        private void SubClassing()
        {
            //Get the Window's HWND
            var hwnd = this.As<IWindowNative>().WindowHandle;

            newWndProc = new WinProc(NewWindowProc);
            oldWndProc = SetWindowLong(hwnd, PInvoke.User32.WindowLongIndexFlags.GWL_WNDPROC, newWndProc);
        }

        int MinWidth = 800;
        int MinHeight = 600;

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

        private IntPtr NewWindowProc(IntPtr hWnd, PInvoke.User32.WindowMessage Msg, IntPtr wParam, IntPtr lParam)
        {
            switch (Msg)
            {
                case PInvoke.User32.WindowMessage.WM_GETMINMAXINFO:
                    var dpi = PInvoke.User32.GetDpiForWindow(hWnd);
                    float scalingFactor = (float)dpi / 96;

                    MINMAXINFO minMaxInfo = Marshal.PtrToStructure<MINMAXINFO>(lParam);
                    minMaxInfo.ptMinTrackSize.x = (int)(MinWidth * scalingFactor);
                    minMaxInfo.ptMinTrackSize.y = (int)(MinHeight * scalingFactor); 
                    Marshal.StructureToPtr(minMaxInfo, lParam, true);
                    break;
                    
            }
            return CallWindowProc(oldWndProc, hWnd, Msg, wParam, lParam);
        }


        [ComImport]
        [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
        [Guid("EECDBF0E-BAE9-4CB6-A68E-9598E1CB57BB")]
        internal interface IWindowNative
        {
            IntPtr WindowHandle { get; }
        }
   }

[sylveon]

SetWindowLong only accepts 32 bits values which can result in unexpected truncations (therefore a crash due to a bad function pointer), SetWindowLongPtr should be used.

Subclassing via SetWindowLongPtr is also not recommended by the Microsoft docs due to various disadvantages, but the alternative subclassing APIs only work with common controls 6: https://docs.microsoft.com/en-us/windows/win32/controls/subclassing-overview#disadvantages-of-the-old-subclassing-approach

Why not add a protected overridable function to the Window class which is similar to WinForms' WndProc (with a respective Message struct which mirrors the native MSG struct)? It would be much simpler for everyone involved.

[rcohn]

Hello -
Is using PInvoke.User32.WindowMessage.WM_GETMINMAXINFO, as described above, really the only way to set the minimum size of a C# WinUI3 desktop app?

I'm using Windows App SDK 1.0. Is there no property that can be set, either at the App or Window level?

Thank you.