On the issue of modal windows

[BlameTwo]

5月I ask how to implement a modal window similar to the Windows ShowDialog() on Windows App SDK? I have seen the relevant API, but I am unable to set a Control to a new modal window. When can I do this?

[BlameTwo]

I know that ContentDialogs can solve related problems, but in some cases, such as browser login or better blocking user operations, this problem is inevitable

[castorix]

This test works for me with Windows App SDK 1.42, but maybe there is a simpler method with latest versions...

{
    Button btn1;
    Grid grid1 = new Grid()
    {
        Background = new SolidColorBrush(Microsoft.UI.Colors.Blue),
        HorizontalAlignment = HorizontalAlignment.Stretch,
        VerticalAlignment = VerticalAlignment.Stretch,
        Children =
    {
        (btn1 = new Button()
        {
            HorizontalAlignment = HorizontalAlignment.Center,
            VerticalAlignment = VerticalAlignment.Center,
            Content = "Click" }
        ),
    }
    };

    btn1.Click += (sender, e) =>
    {
        Console.Beep(5000, 10);
    };

    Window wnd1 = new Window()
    {
        Content = grid1
    };
    IntPtr hWnd1 = WinRT.Interop.WindowNative.GetWindowHandle(wnd1);
    Microsoft.UI.WindowId windowId1 = Microsoft.UI.Win32Interop.GetWindowIdFromWindow(hWnd1);
    Microsoft.UI.Windowing.AppWindow appWindow1 = Microsoft.UI.Windowing.AppWindow.GetFromWindowId(windowId1);
    appWindow1.Resize(new Windows.Graphics.SizeInt32(400, 300));
    appWindow1.Move(new Windows.Graphics.PointInt32(600, 400));
    Microsoft.UI.Windowing.OverlappedPresenter presenter = appWindow1.Presenter as Microsoft.UI.Windowing.OverlappedPresenter;

    IntPtr hWnd = WinRT.Interop.WindowNative.GetWindowHandle(this);
    // e = "Paramètre incorrect.\r\n\r\nThe window should have an owner when IsModal=true."
    SetWindowLong(hWnd1, GWL_HWNDPARENT, hWnd);
    presenter.IsModal = true;

    wnd1.Closed += (sender, e) =>
    {
        // Otherwise the focus on main window is lost...
        EnableWindow(hWnd, true);
    };

    wnd1.Activate();
    appWindow1.Show();

    return;
}

with :

    [DllImport("User32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
    public static extern bool EnableWindow(IntPtr hWnd, bool bEnable);

    public const int GWL_STYLE = (-16);
    public const int GWL_EXSTYLE = (-20);
    public const int GWL_HWNDPARENT = (-8);
    public static IntPtr SetWindowLong(IntPtr hWnd, int nIndex, IntPtr dwNewLong)
    {
        if (IntPtr.Size == 4)
        {
            return SetWindowLongPtr32(hWnd, nIndex, dwNewLong);
        }
        return SetWindowLongPtr64(hWnd, nIndex, dwNewLong);
    }

    [DllImport("User32.dll", CharSet = CharSet.Auto, EntryPoint = "SetWindowLong")]
    public static extern IntPtr SetWindowLongPtr32(IntPtr hWnd, int nIndex, IntPtr dwNewLong);

    [DllImport("User32.dll", CharSet = CharSet.Auto, EntryPoint = "SetWindowLongPtr")]
    public static extern IntPtr SetWindowLongPtr64(IntPtr hWnd, int nIndex, IntPtr dwNewLong);

    public static long GetWindowLong(IntPtr hWnd, int nIndex)
    {
        if (IntPtr.Size == 4)
        {
            return GetWindowLong32(hWnd, nIndex);
        }
        return GetWindowLongPtr64(hWnd, nIndex);
    }

    [DllImport("User32.dll", EntryPoint = "GetWindowLong", CharSet = CharSet.Auto)]
    public static extern long GetWindowLong32(IntPtr hWnd, int nIndex);

    [DllImport("User32.dll", EntryPoint = "GetWindowLongPtr", CharSet = CharSet.Auto)]
    public static extern long GetWindowLongPtr64(IntPtr hWnd, int nIndex);

[DarranRowe]

It should also be noted that this is technically undocumented behaviour.
Neither SetWindowLong nor SetWindowLongPtr are documented to allow the use of GWL(P)_HWNDPARENT in the current version of the documentation.

[BlameTwo]

thanks

[Zakariathr22]

using Microsoft.UI.Windowing;
using Microsoft.UI;
using Microsoft.UI.Xaml;
using System;
using System.Runtime.InteropServices;
using WinRT.Interop;

namespace YourNamespace
{
    public sealed partial class ModalWindow : Window
    {
        private AppWindow appWindow;

        public ModalWindow()
        {
            this.InitializeComponent();
            appWindow = GetAppWindowForCurrentWindow();
            OverlappedPresenter presenter = OverlappedPresenter.CreateForDialog();

            // Set this modal window's owner (the main application window).
            SetOwnership(appWindow, App.m_window);

            // Make the window modal (blocks interaction with the owner window until closed).
            presenter.IsModal = true;

            // Apply the presenter settings to the AppWindow.
            appWindow.SetPresenter(presenter);

            // Show the modal window.
            appWindow.Show();

            Closed += ModalWindow_Closed;
        }

        private AppWindow GetAppWindowForCurrentWindow()
        {
            IntPtr hWnd = WindowNative.GetWindowHandle(this);
            WindowId myWndId = Win32Interop.GetWindowIdFromWindow(hWnd);
            return AppWindow.GetFromWindowId(myWndId);
        }

        // Sets the owner window of the modal window.
        private void SetOwnership(AppWindow ownedAppWindow, Window ownerWindow)
        {
            // Get the HWND (window handle) of the owner window (main window).
            IntPtr ownerHwnd = WindowNative.GetWindowHandle(ownerWindow);
    
            // Get the HWND of the AppWindow (modal window).
            IntPtr ownedHwnd = Win32Interop.GetWindowFromWindowId(ownedAppWindow.Id);
    
            // Set the owner window using SetWindowLongPtr for 64-bit systems
            // or SetWindowLong for 32-bit systems.
            if (IntPtr.Size == 8) // Check if the system is 64-bit
            {
                SetWindowLongPtr(ownedHwnd, -8, ownerHwnd); // -8 = GWLP_HWNDPARENT
            }
            else // 32-bit system
            {
                SetWindowLong(ownedHwnd, -8, ownerHwnd);
            }
        }

        // Import the Windows API function SetWindowLongPtr for modifying window properties on 64-bit systems.
        [DllImport("User32.dll", CharSet = CharSet.Auto, EntryPoint = "SetWindowLongPtr")]
        public static extern IntPtr SetWindowLongPtr(IntPtr hWnd, int nIndex, IntPtr dwNewLong);

        // Import the Windows API function SetWindowLong for modifying window properties on 32-bit systems.
        [DllImport("User32.dll", CharSet = CharSet.Auto, EntryPoint = "SetWindowLong")]
        public static extern IntPtr SetWindowLong(IntPtr hWnd, int nIndex, IntPtr dwNewLong);

        private void ModalWindow_Closed(object sender, WindowEventArgs args)
        {
            // Reactivate the main application window when the modal window closes.
            App.m_window.Activate();
        }
    }
}

[DarranRowe]

The thing is, if Microsoft.UI.Xaml.Window was intended to support being owned, it would have a constructor that would take a WindowId. This is important because it will get the owner window handle into Xaml before the call to CreateWindowEx. There is a call to CreateWindowEx because this is the only way for desktop applications to create windows.

Adding the constructor is actually quite easy, the runtime class is set up for composing anyway. Restricting it with the contract version and adding a second factory interface is pretty straight forward. The problem is whether or not Microsoft.UI.Xaml.Window or the message pump is written to handle these windows being owned.

[Zakariathr22]

Adding the constructor is actually quite easy, the runtime class is set up for composing anyway. Restricting it with the contract version and adding a second factory interface is pretty straight forward. The problem is whether or not Microsoft.UI.Xaml.Window or the message pump is written to handle these windows being owned.

I think this is straightforward.
Ownership and modal windows are not new concepts; they have been used for years.
While there may be some differences, the core principle remains the same, especially since the previously mentioned code has already worked.

[DarranRowe]

Something working and something actually being designed to work that way are two totally different concepts too.

The ONLY documented way of setting an owner window is through CreateWindowEx. There are lots of things in Windows which are documented as not working or have no documentation but it "works".

One example of this is Windows.UI.ViewManagement.UISettings.ColorValuesChanged is documented to be unsupported in desktop applications. Yet if you hook up the event then it will fire in almost all situations that it should. WM_SETTINGCHANGE is another case of this, and it is related to ColorValuesChanged. The lParam of this can be a string and when the theme changes, WM_SETTINGCHANGE is broadcasted with lParam being a pointer to the string "ImmersiveColorSet". Yet there is no documentation saying that this is a valid value.

If you honestly believe that the documentation is incorrect, then there are other things that needs to be done first, like getting bug reports sent to fix the documentaiton.

[Zakariathr22]

If you honestly believe that the documentation is incorrect, then there are other things that needs to be done first, like getting bug reports sent to fix the documentaiton.

I understand, but I’ve tried to find the right place to report this issue in the documentation and haven’t been able to locate it. Could you point me to the appropriate place?

[Zakariathr22]

After further research, I found an interesting and useful video titled "PDC 2005 - Five Things Every Win32 Developer Should Know - Raymond Chen - 2005/09." At exactly 52:00, on slide 32, Raymond Chen explains the SetOwnerWindow function, using HWNDPARENT (-8) with SetWindowLong - the same approach outlined in the solution provided.

This serves as strong evidence that the approach is valid. Even though it is not officially documented, its internal recognition and use by WPF as I mentioned before suggesting that it is a reliable method and the lack of formal documentation does not preclude its use.