From 18207ac477a94c3808b2eda170c83ed0b3e54653 Mon Sep 17 00:00:00 2001
From: Oleksandr Liakhevych <liakh.oleksandr32@gmail.com>
Date: Mon, 11 Nov 2024 00:27:16 +0200
Subject: [PATCH] Support Window control

---
 samples/ControlGallery/AppShell.razor         | 133 ++++----
 .../Views/Menus/ContextMenuPage.razor         |   2 +-
 .../ControlGallery/Views/WindowExample.razor  |   7 +
 .../ControlGallery/Views/WindowsPage.razor    |  14 +
 .../BlazorBindingsApplication.cs              |  21 +-
 .../Handlers/ApplicationWindowHandler.cs      |  51 ++++
 .../Elements/Handlers/WindowHandler.cs        |  25 --
 .../Elements/Window.generated.cs              | 289 ++++++++++++++++++
 .../MauiBlazorBindingsRenderer.cs             |  18 --
 .../Navigation/INavigation.cs                 |   2 +-
 .../Navigation/Navigation.cs                  |  11 +-
 .../Properties/AttributeInfo.cs               |   2 +
 .../BlazorBindingsApplicationTests.cs         |  32 ++
 .../Components/WindowWithPageContent.razor    |  17 ++
 .../MauiBlazorBindingsRendererTests.cs        |  55 ----
 15 files changed, 507 insertions(+), 172 deletions(-)
 create mode 100644 samples/ControlGallery/Views/WindowExample.razor
 create mode 100644 samples/ControlGallery/Views/WindowsPage.razor
 create mode 100644 src/BlazorBindings.Maui/Elements/Handlers/ApplicationWindowHandler.cs
 delete mode 100644 src/BlazorBindings.Maui/Elements/Handlers/WindowHandler.cs
 create mode 100644 src/BlazorBindings.Maui/Elements/Window.generated.cs
 create mode 100644 src/BlazorBindings.UnitTests/Components/WindowWithPageContent.razor
 delete mode 100644 src/BlazorBindings.UnitTests/MauiBlazorBindingsRendererTests.cs

diff --git a/samples/ControlGallery/AppShell.razor b/samples/ControlGallery/AppShell.razor
index 208aa846..1b8771db 100644
--- a/samples/ControlGallery/AppShell.razor
+++ b/samples/ControlGallery/AppShell.razor
@@ -13,82 +13,85 @@
 @using ControlGallery.Views.Shell
 @using ControlGallery.Views.Menus
 
-<Shell BackgroundColor="_backgroundColor"
-       ForegroundColor="_foregroundColor"
-       UnselectedColor="_unselectedColor"
-       TabBarTitleColor="_tabBarTitleColor">
+<Window Title="Main Window">
+    <Shell BackgroundColor="_backgroundColor"
+           ForegroundColor="_foregroundColor"
+           UnselectedColor="_unselectedColor"
+           TabBarTitleColor="_tabBarTitleColor">
 
-    @*Present data*@
-    <BoxViewPage />
-    <LabelPage />
-    <Shapes />
+        @*Present data*@
+        <BoxViewPage />
+        <LabelPage />
+        <Shapes />
 
-    @*Initiate commands*@
-    <ButtonPage />
-    <RefreshViewPage />
-    <SearchBarPage />
-    <SwipeViewPage />
+        @*Initiate commands*@
+        <ButtonPage />
+        <RefreshViewPage />
+        <SearchBarPage />
+        <SwipeViewPage />
 
-    @*Set values*@
-    <SliderPage />
-    <CheckboxPage />
-    <SwitchPage />
-    <RadioButtonPage />
-    <DatePickerPage />
-    <TimePickerPage />
+        @*Set values*@
+        <SliderPage />
+        <CheckboxPage />
+        <SwitchPage />
+        <RadioButtonPage />
+        <DatePickerPage />
+        <TimePickerPage />
 
-    @*Edit text*@
-    <EntryPage />
-    <EditorPage />
+        @*Edit text*@
+        <EntryPage />
+        <EditorPage />
 
-    @*Display collections*@
-    <CarouselViewPage />
-    <ShellSection Title="CollectionView">
-        <AddRemovePage />
-        <GridLayoutPage />
-        <SelectionPage />
-        <InfiniteScrollPage />
-        <DynamicItemsPage />
-    </ShellSection>
-    <PickerPage />
-    <TableViewPage />
-    <ListViewPage />
+        @*Display collections*@
+        <CarouselViewPage />
+        <ShellSection Title="CollectionView">
+            <AddRemovePage />
+            <GridLayoutPage />
+            <SelectionPage />
+            <InfiniteScrollPage />
+            <DynamicItemsPage />
+        </ShellSection>
+        <PickerPage />
+        <TableViewPage />
+        <ListViewPage />
 
-    @*Layouts*@
-    <AbsoluteLayoutPage />
-    <GridPage />
-    <FlexLayoutPage />
+        @*Layouts*@
+        <AbsoluteLayoutPage />
+        <GridPage />
+        <FlexLayoutPage />
 
-    @*Shell*@
-    <ShellContent Title="Shell Properties">
-        <ContentTemplate>
-            <ShellPropertiesPage @bind-ShellBackgroundColor="_backgroundColor"
-            @bind-ShellForegroundColor="_foregroundColor"
-            @bind-ShellUnselectedColor="_unselectedColor"
-            @bind-ShellTabBarTitleColor="_tabBarTitleColor" />
-        </ContentTemplate>
-    </ShellContent>
+        @*Shell*@
+        <ShellContent Title="Shell Properties">
+            <ContentTemplate>
+                <ShellPropertiesPage @bind-ShellBackgroundColor="_backgroundColor"
+                                     @bind-ShellForegroundColor="_foregroundColor"
+                                     @bind-ShellUnselectedColor="_unselectedColor"
+                                     @bind-ShellTabBarTitleColor="_tabBarTitleColor" />
+            </ContentTemplate>
+        </ShellContent>
 
-    <ShellItemsPage />
+        <ShellItemsPage />
 
-    @*Navigation*@
-    <ShellSection Title="Navigation">
-        <NavigationPage />
-        <UriNavigationPage />
-    </ShellSection>
+        @*Navigation*@
+        <ShellSection Title="Navigation">
+            <NavigationPage />
+            <UriNavigationPage />
+        </ShellSection>
 
-    @*Other*@
-    <ShadowsPage />
-    <GestureEvents />
-    <GestureRecognizersPage />
-    <ErrorBoundariesPage />
+        @*Other*@
+        <ShadowsPage />
+        <GestureEvents />
+        <GestureRecognizersPage />
+        <ErrorBoundariesPage />
 
-    @if (DeviceInfo.Platform == DevicePlatform.WinUI || DeviceInfo.Platform == DevicePlatform.MacCatalyst)
-    {
-        <ContextMenuPage />
-        <MenuBarPage />
-    }
-</Shell>
+        @if (DeviceInfo.Platform == DevicePlatform.WinUI || DeviceInfo.Platform == DevicePlatform.MacCatalyst)
+        {
+            <ContextMenuPage />
+            <MenuBarPage />
+            <WindowsPage />
+        }
+    </Shell>
+</Window>
 
 @code {
     Color _backgroundColor;
diff --git a/samples/ControlGallery/Views/Menus/ContextMenuPage.razor b/samples/ControlGallery/Views/Menus/ContextMenuPage.razor
index 91deecde..fce80df2 100644
--- a/samples/ControlGallery/Views/Menus/ContextMenuPage.razor
+++ b/samples/ControlGallery/Views/Menus/ContextMenuPage.razor
@@ -24,7 +24,7 @@
 </ContentPage>
 
 @code {
-    Color? _selectedColor = null;
+    Color _selectedColor = null;
 
     void SelectColor(Color color) => _selectedColor = color;
 }
diff --git a/samples/ControlGallery/Views/WindowExample.razor b/samples/ControlGallery/Views/WindowExample.razor
new file mode 100644
index 00000000..d16c898f
--- /dev/null
+++ b/samples/ControlGallery/Views/WindowExample.razor
@@ -0,0 +1,7 @@
+<Window Title="New window">
+    <ContentPage>
+        <VerticalStackLayout>
+            <Label>Newly opened window.</Label>
+        </VerticalStackLayout>
+    </ContentPage>
+</Window>
\ No newline at end of file
diff --git a/samples/ControlGallery/Views/WindowsPage.razor b/samples/ControlGallery/Views/WindowsPage.razor
new file mode 100644
index 00000000..c6a4141f
--- /dev/null
+++ b/samples/ControlGallery/Views/WindowsPage.razor
@@ -0,0 +1,14 @@
+<ContentPage Title="Windows">
+    <VerticalStackLayout>
+        <Button Text="Open Window" OnClick="OpenWindow" />
+    </VerticalStackLayout>
+</ContentPage>
+
+@code {
+    [Inject] INavigation Navigation { get; set; }
+
+    async Task OpenWindow()
+    {
+        await Navigation.OpenWindow<WindowExample>();
+    }
+}
diff --git a/src/BlazorBindings.Maui/BlazorBindingsApplication.cs b/src/BlazorBindings.Maui/BlazorBindingsApplication.cs
index ec4cecc2..97331f53 100644
--- a/src/BlazorBindings.Maui/BlazorBindingsApplication.cs
+++ b/src/BlazorBindings.Maui/BlazorBindingsApplication.cs
@@ -1,4 +1,6 @@
-using Microsoft.Maui.Controls;
+using BlazorBindings.Maui.Elements.Handlers;
+using Microsoft.Maui.Controls;
+using System.Runtime.ExceptionServices;
 
 namespace BlazorBindings.Maui;
 
@@ -27,12 +29,21 @@ protected override Window CreateWindow(Microsoft.Maui.IActivationState activatio
         }
 
         var (componentType, parameters) = GetComponentToRender();
-        var window = new Window();
-        var task = renderer.AddComponent(componentType, window, parameters);
-        AwaitVoid(task);
 
-        return window;
 
+        var handler = new ApplicationWindowHandler();
+        var addComponentTask = renderer.AddComponent(componentType, handler, parameters);
+
+        if (addComponentTask.Exception != null)
+        {
+            // If exception was thrown during the sync execution - throw it straight away.
+            ExceptionDispatchInfo.Throw(addComponentTask.Exception.InnerException);
+        }
+
+        AwaitVoid(handler.WaitForWindowAsync());
+        return handler.TargetElement;
+
+        // async void is used here to crash the application if rendering fails.
         static async void AwaitVoid(Task task) => await task;
     }
 
diff --git a/src/BlazorBindings.Maui/Elements/Handlers/ApplicationWindowHandler.cs b/src/BlazorBindings.Maui/Elements/Handlers/ApplicationWindowHandler.cs
new file mode 100644
index 00000000..89eacc27
--- /dev/null
+++ b/src/BlazorBindings.Maui/Elements/Handlers/ApplicationWindowHandler.cs
@@ -0,0 +1,51 @@
+using BlazorBindings.Maui.Extensions;
+using MC = Microsoft.Maui.Controls;
+
+namespace BlazorBindings.Maui.Elements.Handlers;
+
+// We allow root component to be either a window, or a page. Therefore, this handler supports both.
+internal class ApplicationWindowHandler : IContainerElementHandler
+{
+    private TaskCompletionSource<object> _taskCompletionSource;
+
+    public void AddChild(object child, int physicalSiblingIndex)
+    {
+        TargetElement = child switch
+        {
+            MC.Window window => window,
+            MC.Page page => new MC.Window(page),
+            _ => throw new InvalidOperationException($"Element '{child.GetType().FullName}' is not supported as an application root.")
+        };
+    }
+
+    public void ReplaceChild(int physicalSiblingIndex, object oldChild, object newChild)
+    {
+        if (oldChild is MC.Window)
+            throw new InvalidOperationException("Removing application root window is not supported.");
+
+        TargetElement.Page = newChild.Cast<MC.Page>();
+    }
+
+    public void RemoveChild(object child, int physicalSiblingIndex)
+    {
+        if (child is MC.Window)
+            throw new InvalidOperationException("Removing application root window is not supported.");
+
+        TargetElement.Page = null;
+    }
+
+    public Task WaitForWindowAsync()
+    {
+        if (TargetElement is not null)
+        {
+            return Task.CompletedTask;
+        }
+
+        _taskCompletionSource ??= new();
+        return _taskCompletionSource.Task;
+    }
+
+    public MC.Window TargetElement { get; private set; }
+
+    object IElementHandler.TargetElement => TargetElement;
+}
diff --git a/src/BlazorBindings.Maui/Elements/Handlers/WindowHandler.cs b/src/BlazorBindings.Maui/Elements/Handlers/WindowHandler.cs
deleted file mode 100644
index 3f59d9f5..00000000
--- a/src/BlazorBindings.Maui/Elements/Handlers/WindowHandler.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-using BlazorBindings.Maui.Extensions;
-using Microsoft.Maui.Controls;
-using MC = Microsoft.Maui.Controls;
-
-namespace BlazorBindings.Maui.Elements.Handlers;
-
-internal class WindowHandler(Window window) : IContainerElementHandler
-{
-    public void AddChild(object child, int physicalSiblingIndex)
-    {
-        window.Page = child.Cast<MC.Page>();
-    }
-
-    public void ReplaceChild(int physicalSiblingIndex, object oldChild, object newChild)
-    {
-        window.Page = newChild.Cast<MC.Page>();
-    }
-
-    public void RemoveChild(object child, int physicalSiblingIndex)
-    {
-        window.Page = null;
-    }
-
-    public object TargetElement => window;
-}
diff --git a/src/BlazorBindings.Maui/Elements/Window.generated.cs b/src/BlazorBindings.Maui/Elements/Window.generated.cs
new file mode 100644
index 00000000..b6b93da6
--- /dev/null
+++ b/src/BlazorBindings.Maui/Elements/Window.generated.cs
@@ -0,0 +1,289 @@
+// <auto-generated>
+//     This code was generated by a BlazorBindings.Maui component generator.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+
+using BlazorBindings.Core;
+using MC = Microsoft.Maui.Controls;
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Rendering;
+using Microsoft.Maui;
+using System;
+using System.Threading.Tasks;
+
+#pragma warning disable MBB001
+
+namespace BlazorBindings.Maui.Elements
+{
+    public partial class Window : NavigableElement
+    {
+        static Window()
+        {
+            RegisterAdditionalHandlers();
+        }
+
+        [Parameter] public FlowDirection? FlowDirection { get; set; }
+        [Parameter] public double? Height { get; set; }
+        [Parameter] public double? MaximumHeight { get; set; }
+        [Parameter] public double? MaximumWidth { get; set; }
+        [Parameter] public double? MinimumHeight { get; set; }
+        [Parameter] public double? MinimumWidth { get; set; }
+        [Parameter] public string Title { get; set; }
+        [Parameter] public double? Width { get; set; }
+        [Parameter] public double? X { get; set; }
+        [Parameter] public double? Y { get; set; }
+        [Parameter] public RenderFragment ChildContent { get; set; }
+        [Parameter] public EventCallback OnSizeChanged { get; set; }
+        [Parameter] public EventCallback<MC.ModalPoppedEventArgs> OnModalPopped { get; set; }
+        [Parameter] public EventCallback<MC.ModalPoppingEventArgs> OnModalPopping { get; set; }
+        [Parameter] public EventCallback<MC.ModalPushedEventArgs> OnModalPushed { get; set; }
+        [Parameter] public EventCallback<MC.ModalPushingEventArgs> OnModalPushing { get; set; }
+        [Parameter] public EventCallback OnPopCanceled { get; set; }
+        [Parameter] public EventCallback OnCreated { get; set; }
+        [Parameter] public EventCallback OnResumed { get; set; }
+        [Parameter] public EventCallback OnActivated { get; set; }
+        [Parameter] public EventCallback OnDeactivated { get; set; }
+        [Parameter] public EventCallback OnStopped { get; set; }
+        [Parameter] public EventCallback OnDestroying { get; set; }
+        [Parameter] public EventCallback<MC.BackgroundingEventArgs> OnBackgrounding { get; set; }
+        [Parameter] public EventCallback<MC.DisplayDensityChangedEventArgs> OnDisplayDensityChanged { get; set; }
+
+        public new MC.Window NativeControl => (MC.Window)((BindableObject)this).NativeControl;
+
+        protected override MC.Window CreateNativeElement() => new();
+
+        protected override void HandleParameter(string name, object value)
+        {
+            switch (name)
+            {
+                case nameof(FlowDirection):
+                    if (!Equals(FlowDirection, value))
+                    {
+                        FlowDirection = (FlowDirection?)value;
+                        NativeControl.FlowDirection = FlowDirection ?? (FlowDirection)MC.Window.FlowDirectionProperty.DefaultValue;
+                    }
+                    break;
+                case nameof(Height):
+                    if (!Equals(Height, value))
+                    {
+                        Height = (double?)value;
+                        NativeControl.Height = Height ?? (double)MC.Window.HeightProperty.DefaultValue;
+                    }
+                    break;
+                case nameof(MaximumHeight):
+                    if (!Equals(MaximumHeight, value))
+                    {
+                        MaximumHeight = (double?)value;
+                        NativeControl.MaximumHeight = MaximumHeight ?? (double)MC.Window.MaximumHeightProperty.DefaultValue;
+                    }
+                    break;
+                case nameof(MaximumWidth):
+                    if (!Equals(MaximumWidth, value))
+                    {
+                        MaximumWidth = (double?)value;
+                        NativeControl.MaximumWidth = MaximumWidth ?? (double)MC.Window.MaximumWidthProperty.DefaultValue;
+                    }
+                    break;
+                case nameof(MinimumHeight):
+                    if (!Equals(MinimumHeight, value))
+                    {
+                        MinimumHeight = (double?)value;
+                        NativeControl.MinimumHeight = MinimumHeight ?? (double)MC.Window.MinimumHeightProperty.DefaultValue;
+                    }
+                    break;
+                case nameof(MinimumWidth):
+                    if (!Equals(MinimumWidth, value))
+                    {
+                        MinimumWidth = (double?)value;
+                        NativeControl.MinimumWidth = MinimumWidth ?? (double)MC.Window.MinimumWidthProperty.DefaultValue;
+                    }
+                    break;
+                case nameof(Title):
+                    if (!Equals(Title, value))
+                    {
+                        Title = (string)value;
+                        NativeControl.Title = Title;
+                    }
+                    break;
+                case nameof(Width):
+                    if (!Equals(Width, value))
+                    {
+                        Width = (double?)value;
+                        NativeControl.Width = Width ?? (double)MC.Window.WidthProperty.DefaultValue;
+                    }
+                    break;
+                case nameof(X):
+                    if (!Equals(X, value))
+                    {
+                        X = (double?)value;
+                        NativeControl.X = X ?? (double)MC.Window.XProperty.DefaultValue;
+                    }
+                    break;
+                case nameof(Y):
+                    if (!Equals(Y, value))
+                    {
+                        Y = (double?)value;
+                        NativeControl.Y = Y ?? (double)MC.Window.YProperty.DefaultValue;
+                    }
+                    break;
+                case nameof(ChildContent):
+                    ChildContent = (RenderFragment)value;
+                    break;
+                case nameof(OnSizeChanged):
+                    if (!Equals(OnSizeChanged, value))
+                    {
+                        void NativeControlSizeChanged(object sender, EventArgs e) => InvokeEventCallback(OnSizeChanged);
+
+                        OnSizeChanged = (EventCallback)value;
+                        NativeControl.SizeChanged -= NativeControlSizeChanged;
+                        NativeControl.SizeChanged += NativeControlSizeChanged;
+                    }
+                    break;
+                case nameof(OnModalPopped):
+                    if (!Equals(OnModalPopped, value))
+                    {
+                        void NativeControlModalPopped(object sender, MC.ModalPoppedEventArgs e) => InvokeEventCallback(OnModalPopped, e);
+
+                        OnModalPopped = (EventCallback<MC.ModalPoppedEventArgs>)value;
+                        NativeControl.ModalPopped -= NativeControlModalPopped;
+                        NativeControl.ModalPopped += NativeControlModalPopped;
+                    }
+                    break;
+                case nameof(OnModalPopping):
+                    if (!Equals(OnModalPopping, value))
+                    {
+                        void NativeControlModalPopping(object sender, MC.ModalPoppingEventArgs e) => InvokeEventCallback(OnModalPopping, e);
+
+                        OnModalPopping = (EventCallback<MC.ModalPoppingEventArgs>)value;
+                        NativeControl.ModalPopping -= NativeControlModalPopping;
+                        NativeControl.ModalPopping += NativeControlModalPopping;
+                    }
+                    break;
+                case nameof(OnModalPushed):
+                    if (!Equals(OnModalPushed, value))
+                    {
+                        void NativeControlModalPushed(object sender, MC.ModalPushedEventArgs e) => InvokeEventCallback(OnModalPushed, e);
+
+                        OnModalPushed = (EventCallback<MC.ModalPushedEventArgs>)value;
+                        NativeControl.ModalPushed -= NativeControlModalPushed;
+                        NativeControl.ModalPushed += NativeControlModalPushed;
+                    }
+                    break;
+                case nameof(OnModalPushing):
+                    if (!Equals(OnModalPushing, value))
+                    {
+                        void NativeControlModalPushing(object sender, MC.ModalPushingEventArgs e) => InvokeEventCallback(OnModalPushing, e);
+
+                        OnModalPushing = (EventCallback<MC.ModalPushingEventArgs>)value;
+                        NativeControl.ModalPushing -= NativeControlModalPushing;
+                        NativeControl.ModalPushing += NativeControlModalPushing;
+                    }
+                    break;
+                case nameof(OnPopCanceled):
+                    if (!Equals(OnPopCanceled, value))
+                    {
+                        void NativeControlPopCanceled(object sender, EventArgs e) => InvokeEventCallback(OnPopCanceled);
+
+                        OnPopCanceled = (EventCallback)value;
+                        NativeControl.PopCanceled -= NativeControlPopCanceled;
+                        NativeControl.PopCanceled += NativeControlPopCanceled;
+                    }
+                    break;
+                case nameof(OnCreated):
+                    if (!Equals(OnCreated, value))
+                    {
+                        void NativeControlCreated(object sender, EventArgs e) => InvokeEventCallback(OnCreated);
+
+                        OnCreated = (EventCallback)value;
+                        NativeControl.Created -= NativeControlCreated;
+                        NativeControl.Created += NativeControlCreated;
+                    }
+                    break;
+                case nameof(OnResumed):
+                    if (!Equals(OnResumed, value))
+                    {
+                        void NativeControlResumed(object sender, EventArgs e) => InvokeEventCallback(OnResumed);
+
+                        OnResumed = (EventCallback)value;
+                        NativeControl.Resumed -= NativeControlResumed;
+                        NativeControl.Resumed += NativeControlResumed;
+                    }
+                    break;
+                case nameof(OnActivated):
+                    if (!Equals(OnActivated, value))
+                    {
+                        void NativeControlActivated(object sender, EventArgs e) => InvokeEventCallback(OnActivated);
+
+                        OnActivated = (EventCallback)value;
+                        NativeControl.Activated -= NativeControlActivated;
+                        NativeControl.Activated += NativeControlActivated;
+                    }
+                    break;
+                case nameof(OnDeactivated):
+                    if (!Equals(OnDeactivated, value))
+                    {
+                        void NativeControlDeactivated(object sender, EventArgs e) => InvokeEventCallback(OnDeactivated);
+
+                        OnDeactivated = (EventCallback)value;
+                        NativeControl.Deactivated -= NativeControlDeactivated;
+                        NativeControl.Deactivated += NativeControlDeactivated;
+                    }
+                    break;
+                case nameof(OnStopped):
+                    if (!Equals(OnStopped, value))
+                    {
+                        void NativeControlStopped(object sender, EventArgs e) => InvokeEventCallback(OnStopped);
+
+                        OnStopped = (EventCallback)value;
+                        NativeControl.Stopped -= NativeControlStopped;
+                        NativeControl.Stopped += NativeControlStopped;
+                    }
+                    break;
+                case nameof(OnDestroying):
+                    if (!Equals(OnDestroying, value))
+                    {
+                        void NativeControlDestroying(object sender, EventArgs e) => InvokeEventCallback(OnDestroying);
+
+                        OnDestroying = (EventCallback)value;
+                        NativeControl.Destroying -= NativeControlDestroying;
+                        NativeControl.Destroying += NativeControlDestroying;
+                    }
+                    break;
+                case nameof(OnBackgrounding):
+                    if (!Equals(OnBackgrounding, value))
+                    {
+                        void NativeControlBackgrounding(object sender, MC.BackgroundingEventArgs e) => InvokeEventCallback(OnBackgrounding, e);
+
+                        OnBackgrounding = (EventCallback<MC.BackgroundingEventArgs>)value;
+                        NativeControl.Backgrounding -= NativeControlBackgrounding;
+                        NativeControl.Backgrounding += NativeControlBackgrounding;
+                    }
+                    break;
+                case nameof(OnDisplayDensityChanged):
+                    if (!Equals(OnDisplayDensityChanged, value))
+                    {
+                        void NativeControlDisplayDensityChanged(object sender, MC.DisplayDensityChangedEventArgs e) => InvokeEventCallback(OnDisplayDensityChanged, e);
+
+                        OnDisplayDensityChanged = (EventCallback<MC.DisplayDensityChangedEventArgs>)value;
+                        NativeControl.DisplayDensityChanged -= NativeControlDisplayDensityChanged;
+                        NativeControl.DisplayDensityChanged += NativeControlDisplayDensityChanged;
+                    }
+                    break;
+
+                default:
+                    base.HandleParameter(name, value);
+                    break;
+            }
+        }
+
+        protected override void RenderAdditionalElementContent(RenderTreeBuilder builder, ref int sequence)
+        {
+            base.RenderAdditionalElementContent(builder, ref sequence);
+            RenderTreeBuilderHelper.AddContentProperty<MC.Window>(builder, sequence++, ChildContent, (x, value) => x.Page = (MC.Page)value);
+        }
+
+        static partial void RegisterAdditionalHandlers();
+    }
+}
diff --git a/src/BlazorBindings.Maui/MauiBlazorBindingsRenderer.cs b/src/BlazorBindings.Maui/MauiBlazorBindingsRenderer.cs
index a4f9bd5d..22a306ae 100644
--- a/src/BlazorBindings.Maui/MauiBlazorBindingsRenderer.cs
+++ b/src/BlazorBindings.Maui/MauiBlazorBindingsRenderer.cs
@@ -4,7 +4,6 @@
 using BlazorBindings.Maui.Elements.Handlers;
 using Microsoft.Extensions.Logging;
 using System.Runtime.ExceptionServices;
-using MC = Microsoft.Maui.Controls;
 
 namespace BlazorBindings.Maui;
 
@@ -22,23 +21,6 @@ internal MauiBlazorBindingsRenderer(MauiBlazorBindingsServiceProvider servicePro
 
     public override Dispatcher Dispatcher { get; } = new MauiDeviceDispatcher();
 
-    internal Task AddComponent(
-        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type componentType,
-        MC.Window parent,
-        Dictionary<string, object> parameters = null)
-    {
-        var handler = new WindowHandler(parent);
-        var addComponentTask = AddComponent(componentType, handler, parameters);
-
-        if (addComponentTask.Exception != null)
-        {
-            // If exception was thrown during the sync execution - throw it straight away.
-            ExceptionDispatchInfo.Throw(addComponentTask.Exception.InnerException);
-        }
-
-        return addComponentTask;
-    }
-
     protected override void HandleException(Exception exception)
     {
         ExceptionDispatchInfo.Throw(exception);
diff --git a/src/BlazorBindings.Maui/Navigation/INavigation.cs b/src/BlazorBindings.Maui/Navigation/INavigation.cs
index e70c6dc9..6ed96246 100644
--- a/src/BlazorBindings.Maui/Navigation/INavigation.cs
+++ b/src/BlazorBindings.Maui/Navigation/INavigation.cs
@@ -8,7 +8,7 @@ public interface INavigation
     /// <param name="uri">URI to navigate to.</param>
     /// <param name="parameters">Additional parameters to set for component.</param>
     Task NavigateToAsync(string uri, Dictionary<string, object> parameters = null);
-
+    Task OpenWindow<T>(Dictionary<string, object> arguments = null) where T : IComponent;
     Task PopAsync(bool animated = true);
 
     Task PopModalAsync(bool animated = true);
diff --git a/src/BlazorBindings.Maui/Navigation/Navigation.cs b/src/BlazorBindings.Maui/Navigation/Navigation.cs
index 030b2415..d8af7779 100644
--- a/src/BlazorBindings.Maui/Navigation/Navigation.cs
+++ b/src/BlazorBindings.Maui/Navigation/Navigation.cs
@@ -75,6 +75,13 @@ public async Task PopToRootAsync(bool animated = true)
         await MauiNavigation.PopToRootAsync(animated);
     }
 
+    public async Task OpenWindow<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] T>
+        (Dictionary<string, object> arguments = null) where T : IComponent
+    {
+        var window = await BuildElement<MC.Window>(typeof(T), arguments);
+        Application.Current.OpenWindow(window);
+    }
+
     /// <summary>
     /// Returns rendered MAUI element from component <typeparamref name="T"/>.
     /// This method is exposed for extensibility purposes, and shouldn't be used directly.
@@ -82,7 +89,7 @@ public async Task PopToRootAsync(bool animated = true)
     /// <remarks>Experimental API, subject to change.</remarks>
     [Experimental("MBB001")]
     public async Task<T> BuildElement<T>(
-        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type componentType, 
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type componentType,
         Dictionary<string, object> arguments) where T : Element
     {
         var (bindableObject, componentTask) = await _renderer.GetElementFromRenderedComponent(componentType, arguments);
@@ -114,7 +121,7 @@ private Task Navigate(RenderFragment renderFragment, NavigationTarget target, bo
     }
 
     private async Task Navigate(
-        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type componentType, 
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type componentType,
         Dictionary<string, object> arguments, NavigationTarget target, bool animated)
     {
         if (_wrapperComponentType != null)
diff --git a/src/BlazorBindings.Maui/Properties/AttributeInfo.cs b/src/BlazorBindings.Maui/Properties/AttributeInfo.cs
index 6e078aff..5f3c977f 100644
--- a/src/BlazorBindings.Maui/Properties/AttributeInfo.cs
+++ b/src/BlazorBindings.Maui/Properties/AttributeInfo.cs
@@ -163,6 +163,8 @@
 [assembly: GenerateComponent(typeof(MenuFlyoutSeparator))]
 [assembly: GenerateComponent(typeof(MenuFlyoutSubItem))]
 
+[assembly: GenerateComponent(typeof(Window))]
+
 // Cells
 [assembly: GenerateComponent(typeof(TextCell))]
 [assembly: GenerateComponent(typeof(ImageCell))]
diff --git a/src/BlazorBindings.UnitTests/BlazorBindingsApplicationTests.cs b/src/BlazorBindings.UnitTests/BlazorBindingsApplicationTests.cs
index d328f1c8..976e543e 100644
--- a/src/BlazorBindings.UnitTests/BlazorBindingsApplicationTests.cs
+++ b/src/BlazorBindings.UnitTests/BlazorBindingsApplicationTests.cs
@@ -21,6 +21,38 @@ public void SetsTheMainPage_WithRootWrapper()
         PageContentWithCascadingParameter.ValidateContent(application.MainPage, WrapperWithCascadingValue.Value);
     }
 
+    [Test]
+    public void SetsMainWindow()
+    {
+        var application = CreateApplication<WindowWithPageContent>();
+        WindowWithPageContent.ValidateContent(application.Windows.Single());
+    }
+
+    [Test]
+    public void ShouldBeAbleToReplaceMainPage()
+    {
+        var application = CreateApplication<SwitchablePages>();
+
+        Assert.That(application.MainPage.Title, Is.EqualTo("Page1"));
+
+        var switchButton = (MC.Button)((MC.ContentPage)application.MainPage).Content;
+        switchButton.SendClicked();
+
+        Assert.That(application.MainPage.Title, Is.EqualTo("Page2"));
+
+        switchButton = (MC.Button)((MC.ContentPage)application.MainPage).Content;
+        switchButton.SendClicked();
+
+        Assert.That(application.MainPage.Title, Is.EqualTo("Page1"));
+    }
+
+    [Test]
+    public void ShouldThrowExceptionIfHappenedDuringSyncRender()
+    {
+        Assert.That(CreateApplication<ComponentWithException>,
+            Throws.InvalidOperationException.With.Message.EqualTo("Should fail here."));
+    }
+
     private static Application CreateApplication<T>() where T : IComponent
     {
         var application = TestApplication.Create<BlazorBindingsApplication<T>>();
diff --git a/src/BlazorBindings.UnitTests/Components/WindowWithPageContent.razor b/src/BlazorBindings.UnitTests/Components/WindowWithPageContent.razor
new file mode 100644
index 00000000..7c7c4c32
--- /dev/null
+++ b/src/BlazorBindings.UnitTests/Components/WindowWithPageContent.razor
@@ -0,0 +1,17 @@
+<Window Title="Test Window" MinimumHeight="100" MinimumWidth="200">
+    <PageContent />
+</Window>
+
+
+@code {
+    public static void ValidateContent(MC.Element content)
+    {
+        var window = content as MC.Window;
+        Assert.That(window, Is.Not.Null);
+        Assert.That(window.Title, Is.EqualTo("Test Window"));
+        Assert.That(window.MinimumHeight, Is.EqualTo(100));
+        Assert.That(window.MinimumWidth, Is.EqualTo(200));
+
+        PageContent.ValidateContent(window.Page);
+    }
+}
\ No newline at end of file
diff --git a/src/BlazorBindings.UnitTests/MauiBlazorBindingsRendererTests.cs b/src/BlazorBindings.UnitTests/MauiBlazorBindingsRendererTests.cs
deleted file mode 100644
index 9ab1dcd9..00000000
--- a/src/BlazorBindings.UnitTests/MauiBlazorBindingsRendererTests.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-using BlazorBindings.Maui;
-using BlazorBindings.UnitTests.Components;
-
-namespace BlazorBindings.UnitTests;
-
-public class MauiBlazorBindingsRendererTests
-{
-    private readonly TestBlazorBindingsRenderer _renderer;
-    private readonly MC.Window _window = new();
-
-    public MauiBlazorBindingsRendererTests()
-    {
-        var services = TestServiceProvider.CreateMauiAppBuilder().Build().Services;
-        _renderer = (TestBlazorBindingsRenderer)services.GetRequiredService<MauiBlazorBindingsRenderer>();
-    }
-
-    [Test]
-    public void ShouldThrowExceptionIfHappenedDuringSyncRender()
-    {
-        void action() => _ = _renderer.AddComponent(typeof(ComponentWithException), _window);
-
-        Assert.That(action, Throws.InvalidOperationException.With.Message.EqualTo("Should fail here."));
-    }
-
-    [Test]
-    public async Task RendererShouldHandleAsyncExceptions()
-    {
-        _renderer.ThrowExceptions = false;
-
-        await _renderer.AddComponent(typeof(PageWithButtonWithExceptionOnClick), _window);
-        var button = (MC.Button)((MC.ContentPage)_window.Page).Content;
-        button.SendClicked();
-
-        Assert.That(() => _renderer.Exceptions, Is.Not.Empty.After(1000, 10));
-        Assert.That(_renderer.Exceptions[0].Message, Is.EqualTo("HandleExceptionTest"));
-    }
-
-    [Test]
-    public async Task RenderedComponentShouldBeAbleToReplaceMainPage()
-    {
-        await _renderer.AddComponent(typeof(SwitchablePages), _window);
-
-        Assert.That(_window.Page.Title, Is.EqualTo("Page1"));
-
-        var switchButton = (MC.Button)((MC.ContentPage)_window.Page).Content;
-        switchButton.SendClicked();
-
-        Assert.That(_window.Page.Title, Is.EqualTo("Page2"));
-
-        switchButton = (MC.Button)((MC.ContentPage)_window.Page).Content;
-        switchButton.SendClicked();
-
-        Assert.That(_window.Page.Title, Is.EqualTo("Page1"));
-    }
-}