How to open a WinUI Window from a WinForms project

[karmeye]

I am trying to open a WinUI Microsoft.UI.Xaml.Window from my WinForms project. The WinUI window's source is in a WinUI class library that is added to the WinForms project as a project reference.

Update:

But as soon as I call new MyWinUIWindow() I get exceptions thrown in the Constructor:

System.Runtime.InteropServices.COMException: ''

There is no message.

I have installed the latest WindowsAppSDK (1.4.240211001) via NuGet in both the WinForms project and the WinUI class library project and added <WindowsPackageType>None</WindowsPackageType> to the WinForms project.

I was trying to get it working with this code but, as mentioned, it fails on the first line:

public void OpenWinUIWindow(MainForm mainForm)
{
  var window = new MyWinUIWindow(); // Exception here
  WinRT.Interop.InitializeWithWindow.Initialize(window , mainForm.Handle);
  window.Activate();
}

Thanks for any pointers.

[DarranRowe]

Have you initialised XAML properly on the thread you are trying to create the Window instance on? At the very least you need a class that derives from Microsoft.UI.Xaml.Application which also implements Microsoft.UI.Xaml.Markup.IXamlMetadataProvider. You would also need a Microsoft.UI.Dispatching.DispatcherQueue active on the thread that you create all of this on.
Also, yes, if you use Microsoft.UI.Xaml.Application.Start, it will likely conflict with WinForms. If you want to try using multiple UI frameworks in the same application, you will probably need to have them on separate threads.
Finally, if your application isn't packaged, then you will need to bootstrap the Windows App Runtime. Just referencing the NuGet package isn't enough. You will either need to use the C# bootstrapper API or use the WindowsPackageType project property.

[karmeye]

Have you initialised XAML properly on the thread you are trying to create the Window instance on?

No. How do I do that?

At the very least you need a class that derives from Microsoft.UI.Xaml.Application

So I make this class and create an instance of it from the WinForms thread and then somehow use this class to open the WinUI Window?

So far, based on your answer, I created a class:

public class WinUIApp : Microsoft.UI.Xaml.Application, Microsoft.UI.Xaml.Markup.IXamlMetadataProvider
{
	public WinUIApp() 
	{
		
	}

	public IXamlType GetXamlType(Type type)
	{
		throw new NotImplementedException();
	}

	public IXamlType GetXamlType(string fullName)
	{
		throw new NotImplementedException();
	}

	public XmlnsDefinition[] GetXmlnsDefinitions()
	{
		throw new NotImplementedException();
	}
}

And I have

public void OpenWinUIWindow(MainForm mainForm)
{
  var queueController = Microsoft.UI.Dispatching.DispatcherQueueController.CreateOnDedicatedThread();
  var queue = queueController.DispatcherQueue;
  bool isQueued = queue.TryEnqueue(() =>
  {
    // What to do here?
    //var callbackParams = new ApplicationInitializationCallbackParams
    //var callback = new ApplicationInitializationCallback(callbackParams);
    //WinUIApp.Start(callback);		
  });

I got System.TypeInitializationException in runtime when executing CreateOnDedicatedThread() above, but when I added <WindowsPackageType>None</WindowsPackageType> to the WinForms project the exception did not occur! Thanks!

Not sure what to do next.

• How so I implement IXamlMetadataProvider
• How do I instantiate and open the WinUI Window.

Thank You

[karmeye]

I managed to get much further thanks to @castorix 's CSharp_WinUI3_DesktopWindowXamlSource example!

I replaced my program.cs with Program.cs

Then from my MainForm I call this method (code got from Form1.cs):

private Microsoft.UI.Xaml.Hosting.DesktopWindowXamlSource dwxs = null;
public Microsoft.UI.Windowing.AppWindow MainFormAppWindow { get; set; }
private Microsoft.UI.Xaml.Window window;

public void OpenWinUIWindow(MainForm mainForm)
{
	if (MainFormAppWindow == null)
	{
		IntPtr hwnd = mainForm.Handle;
		WindowId mainFormWindowId = Win32Interop.GetWindowIdFromWindow(hwnd);
		MainFormAppWindow = Microsoft.UI.Windowing.AppWindow.GetFromWindowId(mainFormWindowId);
	}

	if (dwxs == null)
	{
		// https://github.com/castorix/CSharp_WinUI3_DesktopWindowXamlSource/blob/master/Form1.cs
		Microsoft.UI.Xaml.Hosting.WindowsXamlManager.InitializeForCurrentThread();
		dwxs = new Microsoft.UI.Xaml.Hosting.DesktopWindowXamlSource();
		dwxs.Initialize(MainFormAppWindow.Id);
	}

	if (window == null)
	{
		var window = new MyWinUIWindow();
		window.Title = "MyWinUI";
		window.AppWindow.ResizeClient(new SizeInt32(600, 400));
		window.Activate();			
	};
}

And now the WinUI window opens. However there are still some issues:

• When I close the WinUI window the MainForm window also closes --- the application quits. How do I open the WinUI window so that the MainForm is its owner and only if the MainForm window is closed should the application quit.
• Only the titlebar of the MainForm responds to mouse clicks. I can move it around and resize it, and when its, e.g., behind another window I can click on it to bring it to front, but the content area of the window does not take mouse input (and perhaps not keyboard input)
• The WinUI contains a TextBox that can be clicked on (the caret is blinking) but it doesn't receive keyboard input (running this from an WinUI project it does). I can right-click and past something into it, but not use the keyboard.
  • There is also a Button which seems to work.

I'd be grateful for any pointers to get further.

[DarranRowe]

Okay. What exactly is your goal? If your ultimate goal is to display WinUI 3 content in a WinForms window then just give up on trying to create the instance of Microsoft.UI.Xaml.Window. It is unneeded to display Xaml content when you are hosting it.

To show a little example of what I mean, I will show you some C++ code. Unfortunately, I can't really show C# here because I'm mostly a C++ developer and I haven't implemented this in C#.

The function that I use to load the Xaml content into a DesktopWindowXamlSource is:

muxh::DesktopWindowXamlSource main_window::load_xaml_content(const std::filesystem::path &content_path)
{
	auto desktop_source = muxh::DesktopWindowXamlSource();

	desktop_source.Initialize(m_window_id);

	std::filesystem::path absolute_content_path;
		
	if (!content_path.is_absolute())
	{
		//Use the executable path as the base for relative paths.
		//The working directory is never guaranteed to be
		//correctly set, and if packaged it will be
		//C:\Windows\System32
		auto executable_path = wil::GetModuleFileNameW();
		absolute_content_path = executable_path.get();
		absolute_content_path.remove_filename();

		absolute_content_path /= content_path;
	}
	else
	{
		absolute_content_path = content_path;
	}

	auto file_content = xaml_helper::details::load_xaml_file(absolute_content_path);
	auto xaml_content = xaml_helper::details::load_xaml_content(file_content);

	desktop_source.Content(xaml_content);

	return desktop_source;
}

The function creates and initialises the DesktopWindowXamlSource instance, loads the Xaml content from file into memory, and then parses the Xaml into actual content. The Xaml content is then added as the content of the DesktopWindowXamlSource instance. As a note, the content that is loaded into this is:

<Page
    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"
    mc:Ignorable="d">
    <Grid Background="Transparent" ColumnDefinitions="Auto" RowDefinitions="Auto,Auto,Auto">
        <Button Grid.Row="0" Grid.Column="0"  x:Name="myButton">Click Me!</Button>
        <Button Grid.Row="1" Grid.Column="1"  x:Name="myButton2">Me Too!</Button>
    </Grid>
</Page>

To display this Xaml in my main application's window is then relatively easy. One of the things that DesktopWindowXamlSource.Initialize does is to set the window that you passed in as the parent. What you need to do is to obtain the handle to the window that DesktopWindowXamlSource is rendering the content and show it.

auto temp_source = load_xaml_content(content_relative);
auto take_focus_requested_revoker = temp_source.TakeFocusRequested(winrt::auto_revoke, { this, &main_window::on_take_focus_requested });
auto got_focus_revoker = temp_source.GotFocus(winrt::auto_revoke, { this, &main_window::on_got_focus });

HWND island_window = mu::GetWindowFromWindowId(temp_source.SiteBridge().WindowId());

auto ws = GetWindowLongPtrW(island_window, GWL_STYLE);
SetWindowLongPtrW(island_window, GWL_STYLE, ws | WS_TABSTOP);
ShowWindow(island_window, SW_SHOW);
SetFocus(island_window);

RECT client_rect{};

GetClientRect(get_handle(), &client_rect);
auto hint_rect = wf::Rect({ static_cast<float>(client_rect.left), static_cast<float>(client_rect.top), static_cast<float>(client_rect.right - client_rect.left), static_cast<float>(client_rect.bottom - client_rect.top) });
auto nav_request = muxh::XamlSourceFocusNavigationRequest(muxh::XamlSourceFocusNavigationReason::First, hint_rect);
temp_source.NavigateFocus(nav_request);

The gist of the above code is:

1. I call my own load_xaml_content to instantiate a new DesktopWindowXamlSource, load the provided Xaml content and then set it as the content of the DesktopWindowXamlSource.
2. I wire up the DesktopWindowXamlSource events. This allows for tabbing into and out of the Xaml content.
3. I use DesktopWindowXamlSource.SiteBridge to obtain the instance of the content of DesktopWindowXamlSource. This is an instance of DesktopChildSiteBridge. DesktopChildSiteBridge.WindowId is then used to get the WindowId of the Xaml content window. I then use GetWindowFromWindowId to give me the HWND of the Xaml content. The code then adds the WS_TABSTOP style to the Xaml content window, shows the window and sets focus on the window. Finally, I tell the window that I want it to set the first Xaml button as the focused control.This is what the navigation is there for.

As you can see, this is showing the Xaml content in the main window of a Windows API application. This did not create a new instance of Microsoft.UI.Xaml.Window at all. There is more to go over in general, however, knowing what you are actually trying to do is important here.

[karmeye]

My goal is to open a WinUI window from my current WinForms application. This as a way to gradually migrate to WinUI, moving one view/dialog/form at the time to the WinUI window, which in the end would serve as the new main window of the application.

My code looks pretty much as what you kindly shown.

I actually just realized I could open a WinForms window and then put the main UserControl of the WinUI MainWindow into that. Doing that now it solves the text input problem (2 above) and seems to also solve the "closing problem" (1 above).

I would have preferred opening the whole Window to get the custom title bar, etc, but this is a good enough compromise.

Here's the code:

Program.cs looks like this

MainForm.cs

Here, to get this working, I still have to call new Microsoft.UI.Xaml.Hosting.DesktopWindowXamlSource() in the MainForm, before the Form which hosts the XML Island can open. Otherwise the Microsoft.UI.Xaml.Application OnLaunched is not called and I get null reference exception when IXamlMetadataProvider methods are called.

public Microsoft.UI.Xaml.Hosting.DesktopWindowXamlSource Dwxs { get; private set; }

OnLoadMainForm() {  
  Microsoft.UI.Xaml.Hosting.WindowsXamlManager.InitializeForCurrentThread();
  
  Dwxs = new Microsoft.UI.Xaml.Hosting.DesktopWindowXamlSource();		
  //AppWindow appWindow = ... GetAppWindowFromWindowHandle(Handle);
  //Dwxs.Initialize(appWindow.Id);
  //Dwxs.SiteBridge.MoveAndResize(new Windows.Graphics.RectInt32(0, 0, 0, 0));
}

The form that I open to host the root control taken from my WinUI MainWindow:

public partial class WinUIForm : Form
{
	private MainViewModel mainViewModel;
	public Microsoft.UI.Xaml.Controls.UserControl UserControl { get; private set; }

	public WinUIForm(MainViewModel mainViewModel, Microsoft.UI.Xaml.Controls.UserControl userControl)
	{
		InitializeComponent();

		this.mainViewModel = mainViewModel;
		UserControl = userControl;

		Load += OnLoad;
		SizeChanged += OnSizeChanged;		
	}

	private void OnSizeChanged(object sender, EventArgs e)
	{
		Dwxs.SiteBridge.MoveAndResize(new Windows.Graphics.RectInt32(0, 0, Size.Width, Size.Height));
	}

	private void OnLoad(object sender, EventArgs e)
	{
		InitXmlIslands();
		CenterToScreen();
	}

	public Microsoft.UI.Xaml.Hosting.DesktopWindowXamlSource Dwxs { get; private set; }
	
	private void InitXmlIslands()
	{
		Dwxs = new Microsoft.UI.Xaml.Hosting.DesktopWindowXamlSource();
		Microsoft.UI.WindowId windowID = Microsoft.UI.Win32Interop.GetWindowIdFromWindow(Handle);
		Dwxs.Initialize(windowID);
		Dwxs.SiteBridge.MoveAndResize(new Windows.Graphics.RectInt32(0, 0, Size.Width, Size.Height));

		Dwxs.Content = UserControl;		
	}
}

I'm still curious though why I get those two problems when opening a WinUI window. Seems like it should work this way. I even tried to put a UserControl in the XAML hosted by the MainForm, and have a button on that that opened the Window, but I got exactly the same problems.

• Perhaps this is something to be reported as a bug?
• Does it work for you? For example, on the Click event for the Click Me button in your example, open a Window with a TextBox somewhere inside and see if you can
  • Close the Window without the whole application closing
  • Add text into the TextBox (backspace and delete works, as well as right-clicking and pasting, but not directly typing)

[DarranRowe]

I'm still curious though why I get those two problems when opening a WinUI window. Seems like it should work this way. I even tried to put a UserControl in the XAML hosted by the MainForm, and have a button on that that opened the Window, but I got exactly the same problems.

Here is a question then, what event loop is controlling the WinUI 3 window here, the WinForms one started by System.Windows.Forms.Application.Run, or the one started by Microsoft.UI.Xaml.Application.Start. Both of these are documented start an event loop (message loop/message pump in the documentation) and they both return to the basic:

MSG msg{};
while (GetMessage(&msg, nullptr, 0, 0)
{
    DispatchMessage(&msg);
}

loop, as written out using C++ and the Windows API. If you believe that it is the one started by WinForms, please tell me why you believe that it is able to do everything required to handle WinUI 3 windows properly. If you believe that it is the one started by WinUI 3, please tell me why you believe that it is able to do everything required to handle WinForms windows properly.
The big thing , especially in relation to the keyboard issues, is that when using Xaml Islands, you really need to filter messages using the ContentPreTranslateMessage function. The C++ sample application uses this too. As a counter to this, since WinUI 3 uses composition then it only uses some child windows in special circumstances. This means that the WinUI 3 event loop should never need to call functions like IsDialogMessage. This would be vital for the forms/message box like layout of Windows forms.

I would have preferred opening the whole Window to get the custom title bar, etc, but this is a good enough compromise.

AppWindow is able to customise the title bar of any top level desktop window. You would need to use some other method to draw into the title bar area, but it certainly works.

Close the Window without the whole application closing

The issue here is that there is never going to be any coordination between WinForms and WinUI 3. Both of these expect to be the only framework active. With how it is programmed, Microsoft.UI.Xaml.Window should only keep track of how many WinUI 3 windows are active and then post WM_QUIT when all WinUI 3 windows exit.
In the end, the simple fact that both of these frameworks expect to be the only framework active is one of the reasons why I originally stated that you should place the WinForms content on one thread and the WinUI 3 on a different thread. You won't have them fighting over the control of the event loop as one example. But I honestly don't know how well WinForms and WinUI 3 would coexist anyway.

[DarranRowe]

Well I wrote a quick and dirty C++ example of how to separate things.

wuiinterop.zip

While it is C++ and doesn't use Windows forms, the concept itself works.

There are a couple of notes on this.

First, the WinUI 3 Xaml compiler is enabled. This mean the automatic generation of App and the Window runtime classes is enabled. This is easy to do in the case of the Windows API and most likely WinForms. If you want to do this with WPF then you would likely also need to separate out the WPF or WinUI 3 into a separate library.
Second, the event loops for WinUI 3 and the Windows API are completely independent. The biggest issue this causes is that you must create the windows on the appropriate threads. This would extend to different frameworks other than the Windows API too. WinUI 3 automatically creates a dispatcher queue, so we can obtain a reference to that. I also create an explicit dispatcher queue on the Windows API thread too. This makes the creation of windows on the appropriate threads easier.
Third, the WinUI 3 thread is kept alive by creating an instance of Window on that thread and keeping it alive until the thread needs to close. This instance of Window is never shown or used for anything more than keeping the thread alive.. This is really the easiest way to stop the WinUI 3 from closing prematurely. From what I can see, to do something similar for WinForms, you would want to use the ApplicationContext overload of System.Windows.Forms.Application.Run. The Windows API version is easy, you just don't send WM_QUIT until there are no longer any windows left alive.

I'm not stating that this is the only way to do something like use multiple frameworks in the same application.

Finally, this is a C++ example since I find it easier to think in C++ due to experience. For C#, you should be able to figure out what you need to do to enable the Xaml code generation by looking at the C# project file. If someone else wants to use the ideas in the sample above to create a C# sample then please go ahead.
It is possible to also start from the WinUI 3 project templates and add the WinForms functionality. I think this only requires selecting the correct option in the project properties. Either way, you want to disable any generated main functions since you need to control it to make everything work together.

[karmeye]

If you believe that it is the one started by WinForms, please tell me why you believe that it is able to do everything required to handle WinUI 3 windows properly.

I naively assumed that it was supported out of the box by XML Islands to open a WinUI window. But as I understand now it is only for defining an area in another window (thus island 🤦 ).

The big thing , especially in relation to the keyboard issues, is that when using Xaml Islands, you really need to filter messages using the ContentPreTranslateMessage function.

Ah, ok. That must've been the problem then.

AppWindow is able to customise the title bar of any top level desktop window. You would need to use some other method to draw into the title bar area, but it certainly works.

Ah, good point.

Well I wrote a quick and dirty C++ example of how to separate things.

Wow, thanks a lot for taking your time to do this. I tried it, and it certainly works. I would need some time to dig into it. As for now I will mark this as answered.

Thanks again for your answers!

[myth384]

Hi @karmeye, I've just created a feature request that may interest you. I've aimed to define the scope of the use case as broadly as possible.