`CenterOwner` with Win32 owner

[chucker]

Description

I see that a code path exists for using WindowStartupLocation.CenterOwner with a Win32 owner, namely the else branch after https://source.dot.net/#PresentationFramework/System/Windows/Window.cs,3659.

And indeed, this works, as long as that owner isn't maximized. If it is maximized, the window position isn't what I would expect.

Reproduction Steps

Take a WPF app template.

Enable WinForms interop in the csproj:

<UseWindowsForms>true</UseWindowsForms>

Modify App.xaml to not have a StartupUri:

<Application x:Class="WpfApp1.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:local="clr-namespace:WpfApp1">
    <Application.Resources>

    </Application.Resources>
</Application>

Modify MainWindow.xaml to be a little smaller:

<Window x:Class="WpfApp1.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WpfApp1"
        mc:Ignorable="d"
        Title="MainWindow" Height="600" Width="600">
    <Grid>

    </Grid>
</Window>

Finally, add a constructor to App that creates a WinForms form and uses MainWindow:

using System.Windows;
using System.Windows.Interop;

namespace WpfApp1
{
    /// <summary>
    /// Interaction logic for App.xaml
    /// </summary>
    public partial class App : Application
    {
        public App()
        {
            var form = new System.Windows.Forms.Form
            {
                Width = 1_000,
                Height = 1_000
            };
            form.WindowState = System.Windows.Forms.FormWindowState.Maximized;
            form.Show();

            var window = new MainWindow
            {
                WindowStartupLocation = WindowStartupLocation.CenterOwner
            };

            _ = new WindowInteropHelper(window)
            {
                Owner = form.Handle
            };

            window.ShowDialog();
        }
    }
}

Expected behavior

The WPF window should show up as concentric to the form.

Actual behavior

If we comment out form.WindowState = System.Windows.Forms.FormWindowState.Maximized; and thus the form shows as a regular window, this does work.

But if the form is maximized, the WPF window instead is concentric to where the form would be if it weren't maximized. I don't believe this behavior makes sense.

Regression?

None.

Reproducible in net47, net7.0-windows, net8.0-windows.

Known Workarounds

I would like one, especially one that works with .NET Framework 4.7.2.

I'm guessing I need to call SetupInitialState, perhaps by calling CreateSourceWindow(duringShow: false), then fixing the location, then call Show()?

Impact

We have a legacy primarily WinForms app that we're adding WPF stuff to bit by bit, including by adding WPF-based dialogs — which, preferably, would center correctly.

Configuration

• net472, net7.0-windows, net8.0-windows
• Windows 11 22H2 23612
• x64 (because of net472), ARM64

I don't think this is specific to the above configuration.

Other information

It appears CalculateWindowLocation does consider the case of "what if the owning WPF window is maximized", but not "what if the owning Win32 form is maximized".

[chucker]

I've written/amended extension methods to help myself in the meantime. Sharing this for others who run into the same problem. This will work in net472, net7.0-windows and newer.

using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Interop;

using WinForms = System.Windows.Forms;

namespace EL.Client.WpfUtils.WinFormsInterop
{
    public static class WindowOwnerExtensions
    {
        public static void SetOwner(this Window window, WinForms.Control winFormsControl)
        {
            _ = new WindowInteropHelper(window)
            {
                Owner = winFormsControl.Handle
            };
        }

        /// <summary>
        /// <para>
        /// Set a WPF window's owner to a Win32/WinForms owner, centers to, then
        /// opens it. Do not set <c>WindowStartupLocation</c> separately.
        /// </para>
        ///
        /// <para>
        /// This is necessary because WPF's code
        /// https://referencesource.microsoft.com/#PresentationFramework/src/Framework/System/Windows/Window.cs,1872024dfc3ed928
        /// gets the wrong metrics when a Win32 owner is maximized: it treats
        /// the owner as though it <em>weren't</em> maximized. Thus, with
        /// <see cref="WindowStartupLocation.CenterOwner"/> and a Win32 owner
        /// that's maximized, the center would be wrong.
        /// </para>
        /// </summary>
        /// <param name="window">The WPF window</param>
        /// <param name="winFormsControl">The owning Win32 control</param>
        public static void ShowWithConcentricOwner(this Window window, WinForms.Control winFormsControl)
        {
            SetOwner(window, winFormsControl);

            bool isMaximized = IsWinFormsOwnerMaximized(winFormsControl);

            if (!isMaximized)
                window.WindowStartupLocation = WindowStartupLocation.CenterOwner;
            else
                window.WindowStartupLocation = WindowStartupLocation.CenterScreen;

            window.Show();
        }

        /// <summary>
        /// <para>
        /// Set a WPF window's owner to a Win32/WinForms owner, centers to, then
        /// opens it. Do not set <c>WindowStartupLocation</c> separately.
        /// </para>
        /// 
        /// <para>
        /// Returns only when the window is closed.
        /// </para>
        ///
        /// <para>
        /// This is necessary because WPF's code
        /// https://referencesource.microsoft.com/#PresentationFramework/src/Framework/System/Windows/Window.cs,1872024dfc3ed928
        /// gets the wrong metrics when a Win32 owner is maximized: it treats
        /// the owner as though it <em>weren't</em> maximized. Thus, with
        /// <see cref="WindowStartupLocation.CenterOwner"/> and a Win32 owner
        /// that's maximized, the center would be wrong.
        /// </para>
        /// </summary>
        /// <param name="window">The WPF window</param>
        /// <param name="winFormsControl">The owning Win32 control</param>
        public static bool? ShowDialogWithConcentricOwner(this Window window, WinForms.Control winFormsControl)
        {
            SetOwner(window, winFormsControl);

            bool isMaximized = IsWinFormsOwnerMaximized(winFormsControl);

            if (!isMaximized)
                window.WindowStartupLocation = WindowStartupLocation.CenterOwner;
            else
                window.WindowStartupLocation = WindowStartupLocation.CenterScreen;

            return window.ShowDialog();
        }

        private static bool IsWinFormsOwnerMaximized(WinForms.Control winFormsControl)
        {
            bool isMaximized;

            Windows.Win32.UI.WindowsAndMessaging.WINDOWPLACEMENT windowPlacement = new();
            windowPlacement.length = (uint)Marshal.SizeOf(windowPlacement);
            Windows.Win32.Foundation.HWND windowHandle = (Windows.Win32.Foundation.HWND)winFormsControl.Handle;

            if (!Windows.Win32.PInvoke.GetWindowPlacement(windowHandle, ref windowPlacement))
                isMaximized = false; // fall back to WPF code
            else
                isMaximized = windowPlacement.showCmd == Windows.Win32.UI.WindowsAndMessaging.SHOW_WINDOW_CMD.SW_MAXIMIZE;

            return isMaximized;
        }
    }
}

(GetWindowPlacement and related symbols are source-generated with CsWin32.)