From da38a7098ff35e3109e1b11e08957efd9c01dec1 Mon Sep 17 00:00:00 2001
From: FF69B4 <78807100@qq.com>
Date: Sat, 3 Jan 2026 21:39:40 +0800
Subject: [PATCH 1/3] Add WindowedContentDialog

---
 WinUI3Package/ContentDialogContent.cpp        | 541 ++++++++++++
 WinUI3Package/ContentDialogContent.h          | 169 ++++
 WinUI3Package/ContentDialogContent.idl        |  60 ++
 .../ContentDialogContent_Resource.xaml        | 282 +++++++
 WinUI3Package/ContentDialogUtils.h            |  80 ++
 WinUI3Package/ContentDialogWindow.idl         |  79 ++
 WinUI3Package/ContentDialogWindow.xaml        |  36 +
 WinUI3Package/ContentDialogWindow.xaml.cpp    | 798 ++++++++++++++++++
 WinUI3Package/ContentDialogWindow.xaml.h      | 234 +++++
 ...ontentDialogWindowButtonClickEventArgs.cpp |  34 +
 .../ContentDialogWindowButtonClickEventArgs.h |  30 +
 ...ontentDialogWindowButtonClickEventArgs.idl |  17 +
 WinUI3Package/Underlay.idl                    |  24 +
 WinUI3Package/UnderlaySmokeLayerOptions.cpp   |  19 +
 WinUI3Package/UnderlaySmokeLayerOptions.h     |  24 +
 WinUI3Package/UnderlaySmokeLayerOptions.idl   |  15 +
 .../UnderlaySystemBackdropOptions.cpp         |  18 +
 WinUI3Package/UnderlaySystemBackdropOptions.h |  24 +
 .../UnderlaySystemBackdropOptions.idl         |  14 +
 WinUI3Package/WinUI3Package.vcxproj           |  85 ++
 WinUI3Package/WinUI3Package.vcxproj.filters   |  40 +-
 WinUI3Package/WinUIAsyncEventArgs.cpp         |  20 +
 WinUI3Package/WinUIAsyncEventArgs.h           |  28 +
 WinUI3Package/WinUIAsyncEventArgs.idl         |  13 +
 WinUI3Package/WindowedContentDialog.cpp       | 611 ++++++++++++++
 WinUI3Package/WindowedContentDialog.h         | 240 ++++++
 WinUI3Package/WindowedContentDialog.idl       |  77 ++
 WinUI3Package/include/cppwinrt_utils.h        |  58 ++
 28 files changed, 3665 insertions(+), 5 deletions(-)
 create mode 100644 WinUI3Package/ContentDialogContent.cpp
 create mode 100644 WinUI3Package/ContentDialogContent.h
 create mode 100644 WinUI3Package/ContentDialogContent.idl
 create mode 100644 WinUI3Package/ContentDialogContent_Resource.xaml
 create mode 100644 WinUI3Package/ContentDialogUtils.h
 create mode 100644 WinUI3Package/ContentDialogWindow.idl
 create mode 100644 WinUI3Package/ContentDialogWindow.xaml
 create mode 100644 WinUI3Package/ContentDialogWindow.xaml.cpp
 create mode 100644 WinUI3Package/ContentDialogWindow.xaml.h
 create mode 100644 WinUI3Package/ContentDialogWindowButtonClickEventArgs.cpp
 create mode 100644 WinUI3Package/ContentDialogWindowButtonClickEventArgs.h
 create mode 100644 WinUI3Package/ContentDialogWindowButtonClickEventArgs.idl
 create mode 100644 WinUI3Package/Underlay.idl
 create mode 100644 WinUI3Package/UnderlaySmokeLayerOptions.cpp
 create mode 100644 WinUI3Package/UnderlaySmokeLayerOptions.h
 create mode 100644 WinUI3Package/UnderlaySmokeLayerOptions.idl
 create mode 100644 WinUI3Package/UnderlaySystemBackdropOptions.cpp
 create mode 100644 WinUI3Package/UnderlaySystemBackdropOptions.h
 create mode 100644 WinUI3Package/UnderlaySystemBackdropOptions.idl
 create mode 100644 WinUI3Package/WinUIAsyncEventArgs.cpp
 create mode 100644 WinUI3Package/WinUIAsyncEventArgs.h
 create mode 100644 WinUI3Package/WinUIAsyncEventArgs.idl
 create mode 100644 WinUI3Package/WindowedContentDialog.cpp
 create mode 100644 WinUI3Package/WindowedContentDialog.h
 create mode 100644 WinUI3Package/WindowedContentDialog.idl
 create mode 100644 WinUI3Package/include/cppwinrt_utils.h

diff --git a/WinUI3Package/ContentDialogContent.cpp b/WinUI3Package/ContentDialogContent.cpp
new file mode 100644
index 0000000..f4a11ca
--- /dev/null
+++ b/WinUI3Package/ContentDialogContent.cpp
@@ -0,0 +1,541 @@
+#include "pch.h"
+#include "ContentDialogContent.h"
+#if __has_include("ContentDialogContent.g.cpp")
+#include "ContentDialogContent.g.cpp"
+#endif
+
+#include <winrt/Microsoft.UI.Xaml.Input.h>
+
+#include "include/ScopedButtonDisabler.hpp"
+#include "ContentDialogWindowButtonClickEventArgs.h"
+
+#include "ContentDialogUtils.h"
+
+namespace winrt::WinUI3Package::implementation
+{
+	winrt::Microsoft::UI::Xaml::DependencyProperty ContentDialogContent::_TitleProperty =
+		winrt::Microsoft::UI::Xaml::DependencyProperty::Register(
+			L"Title",
+			xaml_typename<winrt::Windows::Foundation::IInspectable>(),
+			xaml_typename<WinUI3Package::ContentDialogContent>(),
+			winrt::Microsoft::UI::Xaml::PropertyMetadata{ winrt::box_value(L"") });
+
+	winrt::Microsoft::UI::Xaml::DependencyProperty ContentDialogContent::_TitleTemplateProperty =
+		winrt::Microsoft::UI::Xaml::DependencyProperty::Register(
+			L"TitleTemplate",
+			xaml_typename<Microsoft::UI::Xaml::DataTemplate>(),
+			xaml_typename<WinUI3Package::ContentDialogContent>(),
+			winrt::Microsoft::UI::Xaml::PropertyMetadata{ nullptr });
+
+	winrt::Microsoft::UI::Xaml::DependencyProperty ContentDialogContent::_PrimaryButtonTextProperty =
+		winrt::Microsoft::UI::Xaml::DependencyProperty::Register(
+			L"PrimaryButtonText",
+			xaml_typename<winrt::hstring>(),
+			xaml_typename<WinUI3Package::ContentDialogContent>(),
+			winrt::Microsoft::UI::Xaml::PropertyMetadata{ winrt::box_value(L""), OnButtonTextChangedStatic });
+
+	winrt::Microsoft::UI::Xaml::DependencyProperty ContentDialogContent::_SecondaryButtonTextProperty =
+		winrt::Microsoft::UI::Xaml::DependencyProperty::Register(
+			L"SecondaryButtonText",
+			xaml_typename<winrt::hstring>(),
+			xaml_typename<WinUI3Package::ContentDialogContent>(),
+			winrt::Microsoft::UI::Xaml::PropertyMetadata{ winrt::box_value(L""), OnButtonTextChangedStatic });
+
+	winrt::Microsoft::UI::Xaml::DependencyProperty ContentDialogContent::_CloseButtonTextProperty =
+		winrt::Microsoft::UI::Xaml::DependencyProperty::Register(
+			L"CloseButtonText",
+			xaml_typename<winrt::hstring>(),
+			xaml_typename<WinUI3Package::ContentDialogContent>(),
+			winrt::Microsoft::UI::Xaml::PropertyMetadata{ winrt::box_value(L""), OnButtonTextChangedStatic });
+
+	winrt::Microsoft::UI::Xaml::DependencyProperty ContentDialogContent::_IsPrimaryButtonEnabledProperty =
+		winrt::Microsoft::UI::Xaml::DependencyProperty::Register(
+			L"IsPrimaryButtonEnabled",
+			xaml_typename<bool>(),
+			xaml_typename<WinUI3Package::ContentDialogContent>(),
+			winrt::Microsoft::UI::Xaml::PropertyMetadata{ box_value(true), nullptr });
+
+	winrt::Microsoft::UI::Xaml::DependencyProperty ContentDialogContent::_IsSecondaryButtonEnabledProperty =
+		winrt::Microsoft::UI::Xaml::DependencyProperty::Register(
+			L"IsSecondaryButtonEnabled",
+			xaml_typename<bool>(),
+			xaml_typename<WinUI3Package::ContentDialogContent>(),
+			winrt::Microsoft::UI::Xaml::PropertyMetadata{ box_value(true), nullptr });
+
+	winrt::Microsoft::UI::Xaml::DependencyProperty ContentDialogContent::_DefaultButtonProperty =
+		winrt::Microsoft::UI::Xaml::DependencyProperty::Register(
+			L"DefaultButton",
+			xaml_typename<Microsoft::UI::Xaml::Controls::ContentDialogButton>(),
+			xaml_typename<WinUI3Package::ContentDialogContent>(),
+			winrt::Microsoft::UI::Xaml::PropertyMetadata{ winrt::box_value(Microsoft::UI::Xaml::Controls::ContentDialogButton::Close), OnDefaultButtonChangedStatic });
+
+	winrt::Microsoft::UI::Xaml::DependencyProperty ContentDialogContent::_PrimaryButtonStyleProperty =
+		winrt::Microsoft::UI::Xaml::DependencyProperty::Register(
+			L"PrimaryButtonStyle",
+			xaml_typename<Microsoft::UI::Xaml::Style>(),
+			xaml_typename<WinUI3Package::ContentDialogContent>(),
+			winrt::Microsoft::UI::Xaml::PropertyMetadata{ nullptr });
+
+	winrt::Microsoft::UI::Xaml::DependencyProperty ContentDialogContent::_SecondaryButtonStyleProperty =
+		winrt::Microsoft::UI::Xaml::DependencyProperty::Register(
+			L"SecondaryButtonStyle",
+			xaml_typename<Microsoft::UI::Xaml::Style>(),
+			xaml_typename<WinUI3Package::ContentDialogContent>(),
+			winrt::Microsoft::UI::Xaml::PropertyMetadata{ nullptr });
+
+	winrt::Microsoft::UI::Xaml::DependencyProperty ContentDialogContent::_CloseButtonStyleProperty =
+		winrt::Microsoft::UI::Xaml::DependencyProperty::Register(
+			L"CloseButtonStyle",
+			xaml_typename<Microsoft::UI::Xaml::Style>(),
+			xaml_typename<WinUI3Package::ContentDialogContent>(),
+			winrt::Microsoft::UI::Xaml::PropertyMetadata{ nullptr });
+	
+
+	ContentDialogContent::ContentDialogContent() {
+
+		DefaultStyleKey(box_value(winrt::xaml_typename<winrt::WinUI3Package::ContentDialogContent>()));
+
+		isCustomMeasureFinishedAfterLoaded = false;
+
+		PrimaryButtonStyle(ContentDialogUtils::DefaultButtonStyle());
+		SecondaryButtonStyle(ContentDialogUtils::DefaultButtonStyle());
+		CloseButtonStyle(ContentDialogUtils::DefaultButtonStyle());
+
+		IsPrimaryButtonEnabled(true);
+		IsSecondaryButtonEnabled(true);
+
+		Loaded([this](auto&, auto&) {
+
+			buttonsVisibilityState = DetermineButtonsVisibilityState();
+			defaultButtonState = DetermineDefaultButtonState();
+
+			if (IsHeaderImage()) {
+				winrt::Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, L"CommandSpaceExpanded", false);
+			}
+
+		});
+
+		m_OnUnloaded = Unloaded([this](auto&, auto&) {
+
+
+			isCustomMeasureFinishedAfterLoaded = false;
+
+		});
+
+		RightTapped({ this,&ContentDialogContent::m_ContentRightTapped });
+
+
+		m_PrimaryButtonKeyboardAccelerators = (winrt::single_threaded_vector<Microsoft::UI::Xaml::Input::KeyboardAccelerator>());
+		m_SecondaryButtonKeyboardAccelerators = (winrt::single_threaded_vector<Microsoft::UI::Xaml::Input::KeyboardAccelerator>());
+		m_CloseButtonKeyboardAccelerators = (winrt::single_threaded_vector<Microsoft::UI::Xaml::Input::KeyboardAccelerator>());
+
+		//VerticalAlignment(Microsoft::UI::Xaml::VerticalAlignment::Center);
+		//HorizontalAlignment(Microsoft::UI::Xaml::HorizontalAlignment::Center);
+
+		//m_CommandSpace = { nullptr };
+		//PrimaryButton = { nullptr };
+		//SecondaryButton = { nullptr };
+		//CloseButton = { nullptr };
+		//m_TitleArea = {nullptr};
+
+	}
+
+	ContentDialogContent::~ContentDialogContent() {
+
+		Unloaded(m_OnUnloaded);
+
+		PrimaryButton.Click(m_OnPrimaryButtonClick);
+		SecondaryButton.Click(m_OnSecondaryButtonClick);
+		CloseButton.Click(m_OnCloseButtonClick);
+	}
+
+	void ContentDialogContent::OnApplyTemplate()
+	{
+		Super::OnApplyTemplate();
+
+		TitleArea(GetTemplateChild(L"TitleArea").try_as<Microsoft::UI::Xaml::UIElement>());
+		DialogSpace(GetTemplateChild(L"DialogSpace").try_as<Microsoft::UI::Xaml::Controls::Grid>());
+		CommandSpace(GetTemplateChild(L"CommandSpace").try_as<Microsoft::UI::Xaml::Controls::Grid>());
+
+		PrimaryButton = GetTemplateChild(L"PrimaryButton").try_as<Microsoft::UI::Xaml::Controls::Button>();
+		SecondaryButton = GetTemplateChild(L"SecondaryButton").try_as<Microsoft::UI::Xaml::Controls::Button>();
+		CloseButton = GetTemplateChild(L"CloseButton").try_as<Microsoft::UI::Xaml::Controls::Button>();
+
+		if (IsHeaderImage()) {
+			winrt::Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, L"CommandSpaceExpanded", false);
+		}
+
+		m_OnPrimaryButtonClick = PrimaryButton.Click([&](winrt::Windows::Foundation::IInspectable const& sender, auto&)->winrt::Windows::Foundation::IAsyncAction {
+
+			ScopedButtonDisabler disabler{ sender, true };
+
+			auto ContentDialogArgs = WinUI3Package::ContentDialogWindowButtonClickEventArgs();
+
+			m_PrimaryButtonClick(*this, ContentDialogArgs);
+
+			co_await ContentDialogArgs.wait_for_deferrals();
+
+		});
+
+		m_OnSecondaryButtonClick = SecondaryButton.Click([&](auto const& sender, auto&)->winrt::Windows::Foundation::IAsyncAction {
+
+			ScopedButtonDisabler disabler{ sender, true };
+
+			auto ContentDialogArgs = WinUI3Package::ContentDialogWindowButtonClickEventArgs();
+
+			m_SecondaryButtonClick(*this, ContentDialogArgs);
+
+			co_await ContentDialogArgs.wait_for_deferrals();
+		});
+
+		m_OnCloseButtonClick = CloseButton.Click([&](auto const& sender, auto&)->winrt::Windows::Foundation::IAsyncAction {
+
+			ScopedButtonDisabler disabler{ sender, true };
+			auto ContentDialogArgs = WinUI3Package::ContentDialogWindowButtonClickEventArgs();
+			m_CloseButtonClick(*this, ContentDialogArgs);
+
+			co_await ContentDialogArgs.wait_for_deferrals();
+		});
+
+		for (const auto& keyboardAccelerator : PrimaryButtonKeyboardAccelerators()) {
+
+			PrimaryButton.KeyboardAccelerators().Append(keyboardAccelerator);
+		}
+
+		for (const auto& keyboardAccelerator : SecondaryButtonKeyboardAccelerators()) {
+
+			SecondaryButton.KeyboardAccelerators().Append(keyboardAccelerator);
+		}
+
+		for (const auto& keyboardAccelerator : CloseButtonKeyboardAccelerators()) {
+
+			CloseButton.KeyboardAccelerators().Append(keyboardAccelerator);
+		}
+
+		//Microsoft::UI::Xaml::Controls::Image Image = GetTemplateChild(L"ContentImage").try_as<Microsoft::UI::Xaml::Controls::Image>();
+
+		//Image.ImageOpened([this](IInspectable const& sender, Microsoft::UI::Xaml::RoutedEventArgs const& args)
+		//{
+		//	auto image = sender.as<Microsoft::UI::Xaml::Controls::Image>();
+
+		//	if (image)
+		//	{
+		//		// 获取图片源并转换为BitmapImage
+		//		auto bitmapImage = image.Source().as<Microsoft::UI::Xaml::Media::Imaging::BitmapImage>();
+		//		if (bitmapImage)
+		//		{
+		//			// 获取图片实际宽高（像素）
+		//			double width = bitmapImage.PixelWidth();
+		//			double height = bitmapImage.PixelHeight();
+
+		//			// 输出尺寸信息
+		//			//std::wcout << L"图片尺寸: " << width << L" x " << height << std::endl;
+
+		//			// 设置父容器Grid的尺寸为图片尺寸
+		//			if (auto parentGrid = image.Parent().as<Microsoft::UI::Xaml::Controls::Grid>())
+		//			{
+		//				parentGrid.Width(width);
+		//				parentGrid.Height(height);
+		//			}
+		//		}
+		//	}
+		//});
+
+
+		//isCustomMeasureFinishedAfterLoaded = true;
+		//winrt::Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, L"DialogShowingWithoutSmokeLayer", false);
+		//DetermineButtonsVisibilityState();
+		//DetermineDefaultButtonStates();
+		//DetermineWidthLimit();
+
+		//buttonsVisibilityState = DetermineButtonsVisibilityState();
+		//defaultButtonState = DetermineDefaultButtonState();
+		//isCustomMeasureFinishedAfterLoaded = IsLoaded();
+	}
+
+	Windows::Foundation::Size ContentDialogContent::MeasureOverride(Windows::Foundation::Size availableSize)
+	{
+
+		if (isCustomMeasureFinishedAfterLoaded || (IsLoaded()))
+			return base_type::MeasureOverride(CustomMeasure(availableSize));
+
+		isCustomMeasureFinishedAfterLoaded = IsLoaded();
+		return CustomMeasure(availableSize);
+
+	}
+
+	Windows::Foundation::Size ContentDialogContent::CustomMeasure(Windows::Foundation::Size availableSize)
+	{
+		int countButtons = 0;
+		double buttonLongestWidth = 0.0;
+		double buttonMaxWidth = unbox_value<double>(Microsoft::UI::Xaml::Application::Current().Resources().Lookup(box_value(L"ContentDialogButtonMaxWidth")));
+
+		if (PrimaryButton.Visibility() == Microsoft::UI::Xaml::Visibility::Visible)
+		{
+			PrimaryButton.Measure(availableSize);
+			buttonLongestWidth = std::min<double>(std::max<double>(buttonLongestWidth, PrimaryButton.DesiredSize().Width), buttonMaxWidth);
+			countButtons++;
+		}
+
+		if (SecondaryButton.Visibility() == Microsoft::UI::Xaml::Visibility::Visible)
+		{
+			SecondaryButton.Measure(availableSize);
+			buttonLongestWidth = std::min<double>(std::max<double>(buttonLongestWidth, SecondaryButton.DesiredSize().Width), buttonMaxWidth);
+			countButtons++;
+		}
+
+		if (CloseButton.Visibility() == Microsoft::UI::Xaml::Visibility::Visible)
+		{
+			CloseButton.Measure(availableSize);
+			buttonLongestWidth = std::min<double>(std::max<double>(buttonLongestWidth, CloseButton.DesiredSize().Width), buttonMaxWidth);
+			countButtons++;
+		}
+
+		// 假设 CommandSpace 是一个具有 Padding 属性的元素
+		Microsoft::UI::Xaml::Thickness commandSpacePadding = CommandSpace().Padding();
+		double commandSpaceExpectedWidth = commandSpacePadding.Left + commandSpacePadding.Right
+			+ countButtons * buttonLongestWidth
+			+ (countButtons - 1) * winrt::unbox_value<Microsoft::UI::Xaml::GridLength>(Microsoft::UI::Xaml::Application::Current().Resources().Lookup(box_value(L"ContentDialogButtonSpacing"))).Value;
+
+		double minWidth = std::max<double>(
+			unbox_value<double>(Microsoft::UI::Xaml::Application::Current().Resources().Lookup(box_value(L"ContentDialogMinWidth"))),
+			commandSpaceExpectedWidth
+		);
+
+		double maxWidth = std::max<double>(
+			unbox_value<double>(Microsoft::UI::Xaml::Application::Current().Resources().Lookup(box_value(L"ContentDialogMaxWidth"))),
+			commandSpaceExpectedWidth
+		);
+
+		if (availableSize.Width > (float)maxWidth)
+		{
+			availableSize.Width = (float)maxWidth;
+		}
+
+		Windows::Foundation::Size desiredSize = base_type::MeasureOverride(availableSize);
+
+		if (desiredSize.Width < minWidth)
+		{
+			desiredSize.Width = (float)minWidth;
+		}
+
+		return desiredSize;
+	}
+
+	winrt::hstring ContentDialogContent::DetermineButtonsVisibilityState() {
+
+		if (!PrimaryButtonText().empty() && !SecondaryButtonText().empty() && !CloseButtonText().empty())
+		{
+			winrt::Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, L"AllVisible", false);
+
+			//IsPrimaryButtonEnabled(true);
+			//IsSecondaryButtonEnabled(true);
+
+			return L"AllVisible";
+		}
+		else if (!PrimaryButtonText().empty())
+		{
+
+			//IsPrimaryButtonEnabled(true);
+
+			if (!SecondaryButtonText().empty())
+			{
+				winrt::Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, L"PrimaryAndSecondaryVisible", false);
+				IsSecondaryButtonEnabled(true);
+				return L"PrimaryAndSecondaryVisible";
+			}
+			else if (!CloseButtonText().empty())
+			{
+				winrt::Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, L"PrimaryAndCloseVisible", false);
+				IsSecondaryButtonEnabled(false);
+				return L"PrimaryAndCloseVisible";
+			}
+			else
+			{
+				winrt::Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, L"PrimaryVisible", false);
+				IsSecondaryButtonEnabled(false);
+				return L"PrimaryVisible";
+			}
+
+		}
+		else if (!SecondaryButtonText().empty())
+		{
+			//IsSecondaryButtonEnabled(true);
+
+			if (!CloseButtonText().empty())
+			{
+				winrt::Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, L"SecondaryAndCloseVisible", false);
+				return L"SecondaryAndCloseVisible";
+			}
+			else
+			{
+				winrt::Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, L"SecondaryVisible", false);
+				return L"SecondaryAndCloseVisible";
+			}
+
+		}
+		else if (!CloseButtonText().empty())
+		{
+			winrt::Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, L"CloseVisible", false);
+			return L"CloseVisible";
+		}
+		else
+		{
+			winrt::Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, L"NoneVisible", false);
+			IsPrimaryButtonEnabled(false);
+			IsSecondaryButtonEnabled(false);
+			return L"NoneVisible";
+		}
+	}
+
+	winrt::hstring ContentDialogContent::DetermineDefaultButtonState() {
+
+		switch (DefaultButton())
+		{
+			case Microsoft::UI::Xaml::Controls::ContentDialogButton::Primary: {
+
+				Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, L"PrimaryAsDefaultButton", false);
+				winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator keyboardAccelerator = {};
+				keyboardAccelerator.Key(winrt::Windows::System::VirtualKey::Enter);
+				PrimaryButton.KeyboardAccelerators().Append(keyboardAccelerator);
+
+				PrimaryButton.Focus(Microsoft::UI::Xaml::FocusState::Programmatic);
+				return L"PrimaryAsDefaultButton";
+
+			}
+
+			case Microsoft::UI::Xaml::Controls::ContentDialogButton::Secondary: {
+
+				Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, L"SecondaryAsDefaultButton", false);
+
+				winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator keyboardAccelerator = {};
+				keyboardAccelerator.Key(winrt::Windows::System::VirtualKey::Enter);
+				SecondaryButton.KeyboardAccelerators().Append(keyboardAccelerator);
+
+				SecondaryButton.Focus(Microsoft::UI::Xaml::FocusState::Programmatic);
+				return L"SecondaryAsDefaultButton";
+
+			}
+			case Microsoft::UI::Xaml::Controls::ContentDialogButton::Close: {
+
+				Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, L"CloseAsDefaultButton", false);
+
+				winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator keyboardAccelerator = {};
+				keyboardAccelerator.Key(winrt::Windows::System::VirtualKey::Enter);
+				CloseButton.KeyboardAccelerators().Append(keyboardAccelerator);
+				CloseButton.Focus(Microsoft::UI::Xaml::FocusState::Programmatic);
+				return L"CloseAsDefaultButton";
+
+			}
+			case Microsoft::UI::Xaml::Controls::ContentDialogButton::None: {
+				Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, L"NoDefaultButton", false);
+				return L"NoDefaultButton";
+			}
+
+			default: {
+				Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, L"NoDefaultButton", false);
+				return L"NoDefaultButton";
+			}
+
+		}
+	}
+
+	void ContentDialogContent::AfterGotFocus()
+	{
+		if (IsHeaderImage()) return;
+
+		winrt::Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, defaultButtonState, false);
+	}
+
+	void ContentDialogContent::AfterLostFocus()
+	{
+
+		if (IsHeaderImage()) return;
+
+		Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, L"NoDefaultButton", false);
+	}
+
+	void ContentDialogContent::TitleArea(Microsoft::UI::Xaml::UIElement const& Element)
+	{
+		m_TitleArea = Element;
+	}
+	winrt::Microsoft::UI::Xaml::UIElement ContentDialogContent::TitleArea()
+	{
+		return m_TitleArea;
+	}
+
+	void ContentDialogContent::DialogSpace(Microsoft::UI::Xaml::Controls::Grid const& grid)
+	{
+		m_DialogSpace = grid;
+	}
+	winrt::Microsoft::UI::Xaml::Controls::Grid ContentDialogContent::DialogSpace()
+	{
+		return m_DialogSpace;
+	}
+
+	void ContentDialogContent::CommandSpace(Microsoft::UI::Xaml::Controls::Grid const& grid)
+	{
+		m_CommandSpace = grid;
+	}
+	winrt::Microsoft::UI::Xaml::Controls::Grid ContentDialogContent::CommandSpace()
+	{
+		return m_CommandSpace;
+	}
+
+	winrt::event_token ContentDialogContent::PrimaryButtonClick(winrt::Windows::Foundation::EventHandler<WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler)
+	{
+		return m_PrimaryButtonClick.add(handler);
+	}
+	void ContentDialogContent::PrimaryButtonClick(winrt::event_token const& token)
+	{
+		m_PrimaryButtonClick.remove(token);
+	}
+
+	winrt::event_token ContentDialogContent::SecondaryButtonClick(winrt::Windows::Foundation::EventHandler<WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler)
+	{
+		return m_SecondaryButtonClick.add(handler);
+	}
+	void ContentDialogContent::SecondaryButtonClick(winrt::event_token const& token)
+	{
+		m_SecondaryButtonClick.remove(token);
+	}
+
+	winrt::event_token ContentDialogContent::CloseButtonClick(winrt::Windows::Foundation::EventHandler<WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler)
+	{
+		return m_CloseButtonClick.add(handler);
+	}
+	void ContentDialogContent::CloseButtonClick(winrt::event_token const& token)
+	{
+		m_CloseButtonClick.remove(token);
+	}
+
+
+	winrt::event_token ContentDialogContent::ContentRightTapped(Windows::Foundation::TypedEventHandler<Windows::Foundation::IInspectable, Microsoft::UI::Xaml::Input::RightTappedRoutedEventArgs> const& handler)
+	{
+		return m_ContentRightTapped.add(handler);
+	}
+
+	void ContentDialogContent::ContentRightTapped(winrt::event_token const& token)
+	{
+		m_ContentRightTapped.remove(token);
+	}
+
+
+	winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> ContentDialogContent::PrimaryButtonKeyboardAccelerators()
+	{
+		return m_PrimaryButtonKeyboardAccelerators;
+	}
+
+
+	winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> ContentDialogContent::SecondaryButtonKeyboardAccelerators()
+	{
+		return m_SecondaryButtonKeyboardAccelerators;
+	}
+
+
+	winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> ContentDialogContent::CloseButtonKeyboardAccelerators()
+	{
+		return m_CloseButtonKeyboardAccelerators;
+	}
+
+}
diff --git a/WinUI3Package/ContentDialogContent.h b/WinUI3Package/ContentDialogContent.h
new file mode 100644
index 0000000..29d14fa
--- /dev/null
+++ b/WinUI3Package/ContentDialogContent.h
@@ -0,0 +1,169 @@
+#pragma once
+
+#include "ContentDialogContent.g.h"
+
+#include "include/cppwinrt_utils.h"
+
+namespace winrt::WinUI3Package::implementation
+{
+    struct ContentDialogContent : ContentDialogContentT<ContentDialogContent>
+    {
+		using Super = ContentDialogContentT<ContentDialogContent>;
+
+
+		ContentDialogContent();
+		~ContentDialogContent();
+
+		void OnApplyTemplate();
+
+		Windows::Foundation::Size MeasureOverride(Windows::Foundation::Size availableSize);
+
+		Windows::Foundation::Size CustomMeasure(Windows::Foundation::Size availableSize);
+
+		void AfterGotFocus();
+
+		void AfterLostFocus();
+
+		//void DetermineButtonsVisibilityState();
+		//void DetermineDefaultButtonStates();
+		winrt::hstring DetermineButtonsVisibilityState();
+		winrt::hstring DetermineDefaultButtonState();
+
+		void DetermineWidthLimit();
+		void RemoveSizeLimit();
+
+		void TitleArea(Microsoft::UI::Xaml::UIElement const& Element);
+		Microsoft::UI::Xaml::UIElement TitleArea();
+
+		void DialogSpace(Microsoft::UI::Xaml::Controls::Grid const& grid);
+		Microsoft::UI::Xaml::Controls::Grid DialogSpace();
+
+		void CommandSpace(Microsoft::UI::Xaml::Controls::Grid const& grid);
+		Microsoft::UI::Xaml::Controls::Grid CommandSpace();
+
+		winrt::event_token PrimaryButtonClick(winrt::Windows::Foundation::EventHandler<WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler);
+		void PrimaryButtonClick(winrt::event_token const& token);
+
+		winrt::event_token SecondaryButtonClick(winrt::Windows::Foundation::EventHandler<WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler);
+		void SecondaryButtonClick(winrt::event_token const& token);
+
+		winrt::event_token CloseButtonClick(winrt::Windows::Foundation::EventHandler<WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler);
+		void CloseButtonClick(winrt::event_token const& token);
+
+		winrt::event_token ContentRightTapped(Windows::Foundation::TypedEventHandler<Windows::Foundation::IInspectable, Microsoft::UI::Xaml::Input::RightTappedRoutedEventArgs> const& handler);
+		void ContentRightTapped(winrt::event_token const& token);
+
+		static void OnButtonTextChangedStatic(Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::DependencyPropertyChangedEventArgs e)
+		{
+			UNREFERENCED_PARAMETER(sender);
+			UNREFERENCED_PARAMETER(e);
+
+			//winrt::Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, IsEnabled() ? NormalState : DisabledState, true);
+
+			auto self = get_self<ContentDialogContent>(sender.as<winrt::WinUI3Package::ContentDialogContent>());
+
+			if (self->IsLoaded())
+			{
+				self->buttonsVisibilityState = self->DetermineButtonsVisibilityState();
+				self->isCustomMeasureFinishedAfterLoaded = false;
+			}
+
+		}
+
+		static void OnDefaultButtonChangedStatic(Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::DependencyPropertyChangedEventArgs e)
+		{
+			UNREFERENCED_PARAMETER(sender);
+			UNREFERENCED_PARAMETER(e);
+
+			//winrt::Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, IsEnabled() ? NormalState : DisabledState, true);
+
+			auto self = get_self<ContentDialogContent>(sender.as<winrt::WinUI3Package::ContentDialogContent>());
+
+			if (self->IsLoaded())
+			{
+				self->defaultButtonState = self->DetermineDefaultButtonState();
+			}
+
+		}
+
+
+		static winrt::Windows::UI::Xaml::Style DefaultButtonStyle()
+		{
+			static auto style = Microsoft::UI::Xaml::Application::Current().Resources().TryLookup(
+				winrt::box_value(L"DefaultButtonStyle")
+			).as<Windows::UI::Xaml::Style>();
+
+			return style;
+		}
+		//static void OnIsClickEnabledPropertyChangedStatic(Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::DependencyPropertyChangedEventArgs args)
+		//{
+		//	UNREFERENCED_PARAMETER(sender);
+		//	UNREFERENCED_PARAMETER(args);
+		//	get_self<ContentDialogContent>(sender.as<winrt::WinUI3Package::ContentDialogContent>())->OnIsClickEnabledPropertyChanged(args.OldValue().as<bool>(), args.NewValue().as<bool>());
+
+		//}
+
+		winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> PrimaryButtonKeyboardAccelerators();
+		winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> SecondaryButtonKeyboardAccelerators();
+		winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> CloseButtonKeyboardAccelerators();
+
+
+		DEFINE_PROPERTY(bool, IsHeaderImage);
+
+		DEPENDENCY_PROPERTY(winrt::Windows::Foundation::IInspectable, Title);
+		DEPENDENCY_PROPERTY(Microsoft::UI::Xaml::DataTemplate, TitleTemplate);
+		DEPENDENCY_PROPERTY(winrt::hstring, PrimaryButtonText);
+		DEPENDENCY_PROPERTY(winrt::hstring, SecondaryButtonText);
+		DEPENDENCY_PROPERTY(winrt::hstring, CloseButtonText);
+
+		DEPENDENCY_PROPERTY(bool, IsPrimaryButtonEnabled);
+		DEPENDENCY_PROPERTY(bool, IsSecondaryButtonEnabled);
+
+		DEPENDENCY_PROPERTY(Microsoft::UI::Xaml::Controls::ContentDialogButton, DefaultButton);
+
+		DEPENDENCY_PROPERTY(Microsoft::UI::Xaml::Style, PrimaryButtonStyle);
+		DEPENDENCY_PROPERTY(Microsoft::UI::Xaml::Style, SecondaryButtonStyle);
+		DEPENDENCY_PROPERTY(Microsoft::UI::Xaml::Style, CloseButtonStyle);
+
+	private:
+
+		bool isCustomMeasureFinishedAfterLoaded;
+
+		Microsoft::UI::Xaml::Controls::Button PrimaryButton{ nullptr };
+		Microsoft::UI::Xaml::Controls::Button SecondaryButton{ nullptr };
+		Microsoft::UI::Xaml::Controls::Button CloseButton{ nullptr };
+
+		winrt::event<Windows::Foundation::EventHandler<WinUI3Package::ContentDialogWindowButtonClickEventArgs>> m_PrimaryButtonClick;
+		winrt::event<Windows::Foundation::EventHandler<WinUI3Package::ContentDialogWindowButtonClickEventArgs>> m_SecondaryButtonClick;
+		winrt::event<Windows::Foundation::EventHandler<WinUI3Package::ContentDialogWindowButtonClickEventArgs>> m_CloseButtonClick;
+
+		winrt::event<Windows::Foundation::TypedEventHandler<Windows::Foundation::IInspectable, Microsoft::UI::Xaml::Input::RightTappedRoutedEventArgs>> m_ContentRightTapped;
+
+
+		Microsoft::UI::Xaml::UIElement m_TitleArea{ nullptr };
+		Microsoft::UI::Xaml::Controls::Grid m_DialogSpace{ nullptr };
+		Microsoft::UI::Xaml::Controls::Grid m_CommandSpace{ nullptr };
+
+		winrt::hstring buttonsVisibilityState;
+		winrt::hstring defaultButtonState;
+
+		winrt::event_token m_OnUnloaded;
+
+		winrt::event_token m_OnPrimaryButtonClick;
+		winrt::event_token m_OnSecondaryButtonClick;
+		winrt::event_token m_OnCloseButtonClick;
+
+
+		winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> m_PrimaryButtonKeyboardAccelerators{ nullptr };
+		winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> m_SecondaryButtonKeyboardAccelerators{ nullptr };
+		winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> m_CloseButtonKeyboardAccelerators{ nullptr };
+
+    };
+}
+
+namespace winrt::WinUI3Package::factory_implementation
+{
+    struct ContentDialogContent : ContentDialogContentT<ContentDialogContent, implementation::ContentDialogContent>
+    {
+    };
+}
diff --git a/WinUI3Package/ContentDialogContent.idl b/WinUI3Package/ContentDialogContent.idl
new file mode 100644
index 0000000..4efbbc0
--- /dev/null
+++ b/WinUI3Package/ContentDialogContent.idl
@@ -0,0 +1,60 @@
+import "ContentDialogWindowButtonClickEventArgs.idl";
+
+
+namespace WinUI3Package
+{
+    [bindable]
+    [default_interface]
+    runtimeclass ContentDialogContent : Microsoft.UI.Xaml.Controls.ContentControl
+    {
+        ContentDialogContent();
+
+        void AfterGotFocus();
+        void AfterLostFocus();
+
+        Microsoft.UI.Xaml.UIElement TitleArea{ get; set; };
+        Microsoft.UI.Xaml.Controls.Grid DialogSpace{ get; set; };
+        Microsoft.UI.Xaml.Controls.Grid CommandSpace{ get; set; };
+
+        Object Title;
+        Microsoft.UI.Xaml.DataTemplate TitleTemplate;
+
+
+        Boolean IsHeaderImage;
+
+        String PrimaryButtonText;
+        String SecondaryButtonText;
+        String CloseButtonText;
+
+        Boolean IsPrimaryButtonEnabled;
+        Boolean IsSecondaryButtonEnabled;
+
+        Microsoft.UI.Xaml.Controls.ContentDialogButton DefaultButton;
+
+        Microsoft.UI.Xaml.Style PrimaryButtonStyle;
+        Microsoft.UI.Xaml.Style SecondaryButtonStyle;
+        Microsoft.UI.Xaml.Style CloseButtonStyle;
+
+        Windows.Foundation.Collections.IVector<Microsoft.UI.Xaml.Input.KeyboardAccelerator> PrimaryButtonKeyboardAccelerators{ get; };
+        Windows.Foundation.Collections.IVector<Microsoft.UI.Xaml.Input.KeyboardAccelerator> SecondaryButtonKeyboardAccelerators{ get; };
+        Windows.Foundation.Collections.IVector<Microsoft.UI.Xaml.Input.KeyboardAccelerator> CloseButtonKeyboardAccelerators{ get; };
+
+
+        static Microsoft.UI.Xaml.DependencyProperty TitleProperty{ get; };
+        static Microsoft.UI.Xaml.DependencyProperty PrimaryButtonTextProperty{ get; };
+        static Microsoft.UI.Xaml.DependencyProperty SecondaryButtonTextProperty{ get; };
+        static Microsoft.UI.Xaml.DependencyProperty CloseButtonTextProperty{ get; };
+        static Microsoft.UI.Xaml.DependencyProperty IsPrimaryButtonEnabledProperty{ get; };
+        static Microsoft.UI.Xaml.DependencyProperty DefaultButtonProperty{ get; };
+        static Microsoft.UI.Xaml.DependencyProperty PrimaryButtonStyleProperty{ get; };
+        static Microsoft.UI.Xaml.DependencyProperty SecondaryButtonStyleProperty{ get; };
+        static Microsoft.UI.Xaml.DependencyProperty CloseButtonStyleProperty{ get; };
+
+
+        event Windows.Foundation.TypedEventHandler<Object, Microsoft.UI.Xaml.Input.RightTappedRoutedEventArgs> ContentRightTapped;
+
+        event Windows.Foundation.EventHandler<ContentDialogWindowButtonClickEventArgs> PrimaryButtonClick;
+        event Windows.Foundation.EventHandler<ContentDialogWindowButtonClickEventArgs> SecondaryButtonClick;
+        event Windows.Foundation.EventHandler<ContentDialogWindowButtonClickEventArgs> CloseButtonClick;
+    }
+}
diff --git a/WinUI3Package/ContentDialogContent_Resource.xaml b/WinUI3Package/ContentDialogContent_Resource.xaml
new file mode 100644
index 0000000..89b8a7e
--- /dev/null
+++ b/WinUI3Package/ContentDialogContent_Resource.xaml
@@ -0,0 +1,282 @@
+<ResourceDictionary
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:local="using:WinUI3Package">
+
+    <ResourceDictionary.ThemeDictionaries>
+        <ResourceDictionary x:Key="Default">
+            <Color x:Key="LayerFillColorDefault">#4C3A3A3A</Color>
+            <SolidColorBrush x:Key="LayerFillColorDefaultBrush" Color="{StaticResource LayerFillColorDefault}" />
+
+            <StaticResource x:Key="ContentDialogWindowTopOverlay" ResourceKey="LayerFillColorDefaultBrush" />
+        </ResourceDictionary>
+
+        <ResourceDictionary x:Key="Light">
+            <Color x:Key="LayerFillColorDefault">#80FFFFFF</Color>
+            <SolidColorBrush x:Key="LayerFillColorDefaultBrush" Color="{StaticResource LayerFillColorDefault}" />
+
+            <StaticResource x:Key="ContentDialogWindowTopOverlay" ResourceKey="LayerFillColorDefaultBrush" />
+        </ResourceDictionary>
+
+        <ResourceDictionary x:Key="HighContrast">
+            <StaticResource x:Key="ContentDialogWindowTopOverlay" ResourceKey="SystemControlTransparentBrush" />
+        </ResourceDictionary>
+    </ResourceDictionary.ThemeDictionaries>
+
+    <!--<FontFamily x:Key="HarmonyOSSans">ms-appx:///WinUIToolKit/Assets/Fonts/HarmonyOS.ttf#HarmonyOS Sans SC</FontFamily>-->
+
+
+    <Thickness x:Key="ContentDialogWindowTitlePadding">24,24,24,0</Thickness>
+    <Thickness x:Key="ContentDialogWindowContentPadding">24,0,24,24</Thickness>
+    <Color x:Key="ContentDialogWindowCommandSpaceBackground">#0F000000</Color>
+    <Color x:Key="ContentDialogWindowSeparatorBorderColor">#19000000</Color>
+    <SolidColorBrush
+        x:Key="ContentDialogWindowCommandSpaceBackgroundBrush"
+        Opacity="0.5"
+        Color="{StaticResource ContentDialogWindowCommandSpaceBackground}" />
+    <SolidColorBrush x:Key="ContentDialogWindowSeparatorBorderBrush" Color="{StaticResource ContentDialogWindowSeparatorBorderColor}" />
+
+
+    <Style x:Key="DefaultContentDialogContentStyle" TargetType="local:ContentDialogContent">
+        <Setter Property="Foreground" Value="{ThemeResource ContentDialogForeground}" />
+        <Setter Property="Background" Value="Transparent" />
+        <Setter Property="BorderThickness" Value="0" />
+        <Setter Property="BorderBrush" Value="{ThemeResource ContentDialogBorderBrush}" />
+        <Setter Property="IsTabStop" Value="True" />
+        <Setter Property="PrimaryButtonStyle" Value="{ThemeResource DefaultButtonStyle}" />
+        <Setter Property="SecondaryButtonStyle" Value="{ThemeResource DefaultButtonStyle}" />
+        <Setter Property="CloseButtonStyle" Value="{ThemeResource DefaultButtonStyle}" />
+        <Setter Property="CornerRadius" Value="0" />
+        <Setter Property="MinWidth" Value="{StaticResource ContentDialogMinWidth}" />
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="local:ContentDialogContent">
+                    <Border
+                        x:Name="BackgroundElement"
+                        HorizontalAlignment="Stretch"
+                        VerticalAlignment="Stretch"
+                        Background="{TemplateBinding Background}"
+                        BackgroundSizing="InnerBorderEdge"
+                        BorderBrush="{TemplateBinding BorderBrush}"
+                        BorderThickness="{TemplateBinding BorderThickness}"
+                        FlowDirection="{TemplateBinding FlowDirection}"
+                        RequestedTheme="{TemplateBinding RequestedTheme}"
+                        TabFocusNavigation="Cycle">
+                        <Grid x:Name="DialogSpace">
+                            <Grid.RowDefinitions>
+                                <RowDefinition Height="*" />
+                                <RowDefinition Height="Auto" />
+                            </Grid.RowDefinitions>
+                            <Grid
+                                Background="{ThemeResource ContentDialogWindowTopOverlay}"
+                                BorderBrush="{ThemeResource ContentDialogWindowSeparatorBorderBrush}"
+                                BorderThickness="{StaticResource ContentDialogSeparatorThickness}">
+                                <Grid.RowDefinitions>
+                                    <RowDefinition Height="Auto" />
+                                    <RowDefinition Height="*" />
+                                </Grid.RowDefinitions>
+                                <Border
+                                    x:Name="TitleArea"
+                                    Grid.Row="0"
+                                    HorizontalAlignment="Stretch"
+                                    x:FieldModifier="private">
+                                    <ContentControl
+                                        x:Name="Title"
+                                        Margin="{StaticResource ContentDialogTitleMargin}"
+                                        Padding="{StaticResource ContentDialogWindowTitlePadding}"
+                                        HorizontalAlignment="Left"
+                                        VerticalAlignment="Top"
+                                        Content="{TemplateBinding Title}"
+                                        ContentTemplate="{TemplateBinding TitleTemplate}"
+                                        FontFamily="{StaticResource ContentControlThemeFontFamily}"
+                                        FontSize="20"
+                                        FontWeight="SemiBold"
+                                        Foreground="{TemplateBinding Foreground}"
+                                        IsTabStop="True">
+                                        <ContentControl.Template>
+                                            <ControlTemplate TargetType="ContentControl">
+                                                <ContentPresenter
+                                                    Margin="{TemplateBinding Padding}"
+                                                    HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
+                                                    VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
+                                                    Content="{TemplateBinding Content}"
+                                                    ContentTemplate="{TemplateBinding ContentTemplate}"
+                                                    ContentTransitions="{TemplateBinding ContentTransitions}"
+                                                    MaxLines="2"
+                                                    TextWrapping="Wrap" />
+                                            </ControlTemplate>
+                                        </ContentControl.Template>
+                                    </ContentControl>
+                                </Border>
+                                <ScrollViewer
+                                    x:Name="ContentScrollViewer"
+                                    Grid.Row="1"
+                                    HorizontalScrollBarVisibility="Disabled"
+                                    IsTabStop="False"
+                                    VerticalScrollBarVisibility="Auto"
+                                    ZoomMode="Disabled">
+                                    <ContentPresenter
+                                        x:Name="ContentArea"
+                                        Padding="{StaticResource ContentDialogWindowContentPadding}"
+                                        Content="{TemplateBinding Content}"
+                                        ContentTemplate="{TemplateBinding ContentTemplate}"
+                                        FontFamily="{StaticResource ContentControlThemeFontFamily}"
+                                        FontSize="{StaticResource ControlContentThemeFontSize}"
+                                        Foreground="{TemplateBinding Foreground}"
+                                        TextWrapping="Wrap" />
+                                </ScrollViewer>
+                            </Grid>
+
+                            <Grid
+                                x:Name="CommandSpace"
+                                Grid.Row="1"
+                                Padding="{StaticResource ContentDialogPadding}"
+                                HorizontalAlignment="Stretch"
+                                VerticalAlignment="Bottom"
+                                Background="{StaticResource ContentDialogWindowCommandSpaceBackgroundBrush}"
+                                XYFocusKeyboardNavigation="Enabled">
+                                <Grid.ColumnDefinitions>
+                                    <ColumnDefinition x:Name="PrimaryColumn" Width="*" />
+                                    <ColumnDefinition x:Name="FirstSpacer" Width="0" />
+                                    <ColumnDefinition x:Name="SecondaryColumn" Width="0" />
+                                    <ColumnDefinition x:Name="SecondSpacer" Width="{StaticResource ContentDialogButtonSpacing}" />
+                                    <ColumnDefinition x:Name="CloseColumn" Width="*" />
+                                </Grid.ColumnDefinitions>
+                                <Button
+                                    x:Name="PrimaryButton"
+                                    HorizontalAlignment="Stretch"
+                                    Content="{TemplateBinding PrimaryButtonText}"
+                                    ElementSoundMode="FocusOnly"
+                                    IsEnabled="{TemplateBinding IsPrimaryButtonEnabled}"
+                                    IsTabStop="True"
+                                    Style="{TemplateBinding PrimaryButtonStyle}" />
+                                <Button
+                                    x:Name="SecondaryButton"
+                                    HorizontalAlignment="Stretch"
+                                    Content="{TemplateBinding SecondaryButtonText}"
+                                    ElementSoundMode="FocusOnly"
+                                    IsEnabled="{TemplateBinding IsSecondaryButtonEnabled}"
+                                    IsTabStop="True"
+                                    Style="{TemplateBinding SecondaryButtonStyle}" />
+                                <Button
+                                    x:Name="CloseButton"
+                                    Grid.Column="4"
+                                    HorizontalAlignment="Stretch"
+                                    Content="{TemplateBinding CloseButtonText}"
+                                    ElementSoundMode="FocusOnly"
+                                    IsTabStop="True"
+                                    KeyboardAcceleratorPlacementMode="Hidden"
+                                    Style="{TemplateBinding CloseButtonStyle}">
+                                    <Button.KeyboardAccelerators>
+                                        <KeyboardAccelerator Key="Escape" />
+                                    </Button.KeyboardAccelerators>
+                                </Button>
+                            </Grid>
+                        </Grid>
+
+                        <VisualStateManager.VisualStateGroups>
+                            <VisualStateGroup x:Name="DialogShowingStates">
+                                <VisualState x:Name="DialogHidden" />
+                            </VisualStateGroup>
+                            <VisualStateGroup x:Name="ButtonsVisibilityStates">
+                                <VisualState x:Name="AllVisible">
+                                    <VisualState.Setters>
+                                        <Setter Target="FirstSpacer.Width" Value="{ThemeResource ContentDialogButtonSpacing}" />
+                                        <Setter Target="SecondaryColumn.Width" Value="*" />
+                                        <Setter Target="SecondaryButton.(Grid.Column)" Value="2" />
+                                    </VisualState.Setters>
+                                </VisualState>
+                                <VisualState x:Name="NoneVisible">
+                                    <VisualState.Setters>
+                                        <Setter Target="CommandSpace.Visibility" Value="Collapsed" />
+                                    </VisualState.Setters>
+                                </VisualState>
+                                <VisualState x:Name="PrimaryVisible">
+                                    <VisualState.Setters>
+                                        <Setter Target="PrimaryButton.(Grid.Column)" Value="4" />
+                                        <Setter Target="SecondaryButton.Visibility" Value="Collapsed" />
+                                        <Setter Target="CloseButton.Visibility" Value="Collapsed" />
+                                    </VisualState.Setters>
+                                </VisualState>
+                                <VisualState x:Name="SecondaryVisible">
+                                    <VisualState.Setters>
+                                        <Setter Target="SecondaryButton.(Grid.Column)" Value="4" />
+                                        <Setter Target="PrimaryButton.Visibility" Value="Collapsed" />
+                                        <Setter Target="CloseButton.Visibility" Value="Collapsed" />
+                                    </VisualState.Setters>
+                                </VisualState>
+                                <VisualState x:Name="CloseVisible">
+                                    <VisualState.Setters>
+                                        <Setter Target="PrimaryButton.Visibility" Value="Collapsed" />
+                                        <Setter Target="SecondaryButton.Visibility" Value="Collapsed" />
+                                    </VisualState.Setters>
+                                </VisualState>
+                                <VisualState x:Name="PrimaryAndSecondaryVisible">
+                                    <VisualState.Setters>
+                                        <Setter Target="SecondaryButton.(Grid.Column)" Value="4" />
+                                        <Setter Target="CloseButton.Visibility" Value="Collapsed" />
+                                    </VisualState.Setters>
+                                </VisualState>
+                                <VisualState x:Name="PrimaryAndCloseVisible">
+                                    <VisualState.Setters>
+                                        <Setter Target="SecondaryButton.Visibility" Value="Collapsed" />
+                                    </VisualState.Setters>
+                                </VisualState>
+                                <VisualState x:Name="SecondaryAndCloseVisible">
+                                    <VisualState.Setters>
+                                        <Setter Target="PrimaryButton.Visibility" Value="Collapsed" />
+                                    </VisualState.Setters>
+                                </VisualState>
+                            </VisualStateGroup>
+                            <VisualStateGroup x:Name="DefaultButtonStates">
+                                <VisualState x:Name="NoDefaultButton" />
+                                <VisualState x:Name="PrimaryAsDefaultButton">
+                                    <VisualState.Setters>
+                                        <Setter Target="PrimaryButton.Style" Value="{StaticResource AccentButtonStyle}" />
+                                    </VisualState.Setters>
+                                </VisualState>
+                                <VisualState x:Name="SecondaryAsDefaultButton">
+                                    <VisualState.Setters>
+                                        <Setter Target="SecondaryButton.Style" Value="{StaticResource AccentButtonStyle}" />
+                                    </VisualState.Setters>
+                                </VisualState>
+                                <VisualState x:Name="CloseAsDefaultButton">
+                                    <VisualState.Setters>
+                                        <Setter Target="CloseButton.Style" Value="{StaticResource AccentButtonStyle}" />
+                                    </VisualState.Setters>
+                                </VisualState>
+
+                                <VisualState x:Name="CommandSpaceExpanded">
+                                    <VisualState.Setters>
+                                        <Setter Target="PrimaryColumn.Width" Value="Auto" />
+                                        <Setter Target="FirstSpacer.Width" Value="*" />
+                                        <Setter Target="SecondaryColumn.Width" Value="Auto" />
+                                        <Setter Target="SecondSpacer.Width" Value="20" />
+                                        <Setter Target="CloseColumn.Width" Value="Auto" />
+
+                                        <!--  修改按钮的列位置和对齐方式  -->
+                                        <Setter Target="PrimaryButton.(Grid.Column)" Value="0" />
+                                        <Setter Target="PrimaryButton.HorizontalAlignment" Value="Left" />
+
+                                        <Setter Target="SecondaryButton.(Grid.Column)" Value="2" />
+                                        <Setter Target="SecondaryButton.HorizontalAlignment" Value="Right" />
+
+                                        <Setter Target="CloseButton.(Grid.Column)" Value="4" />
+                                        <Setter Target="CloseButton.HorizontalAlignment" Value="Right" />
+                                    </VisualState.Setters>
+                                </VisualState>
+
+
+                            </VisualStateGroup>
+
+
+                        </VisualStateManager.VisualStateGroups>
+                    </Border>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style BasedOn="{StaticResource DefaultContentDialogContentStyle}" TargetType="local:ContentDialogContent" />
+
+</ResourceDictionary>
\ No newline at end of file
diff --git a/WinUI3Package/ContentDialogUtils.h b/WinUI3Package/ContentDialogUtils.h
new file mode 100644
index 0000000..1fbea57
--- /dev/null
+++ b/WinUI3Package/ContentDialogUtils.h
@@ -0,0 +1,80 @@
+#pragma once
+
+
+namespace ContentDialogUtils {
+
+
+	static winrt::Microsoft::UI::Xaml::Style DefaultButtonStyle()
+	{
+		// 获取应用程序当前实例
+		auto application = winrt::Microsoft::UI::Xaml::Application::Current();
+
+		// 检查应用程序资源中是否有 DefaultButtonStyle
+		if (application && application.Resources().HasKey(winrt::box_value(L"DefaultButtonStyle")))
+		{
+			return application.Resources().TryLookup(winrt::box_value(L"DefaultButtonStyle")).as<winrt::Microsoft::UI::Xaml::Style>();
+		}
+
+		// 如果没有找到，返回 null 或默认样式
+		return nullptr;
+	}
+
+	static winrt::Windows::UI::Color SmokeFillColor()
+	{
+		if (auto current = winrt::Microsoft::UI::Xaml::Application::Current())
+		{
+			if (auto resources = current.Resources())
+			{
+				if (auto color = resources.TryLookup(winrt::box_value(L"SmokeFillColorDefault")))
+				{
+					return color.try_as<winrt::Windows::UI::Color>().value_or(winrt::Microsoft::UI::Colors::Black()); // Default fallback
+				}
+			}
+		}
+		return winrt::Microsoft::UI::Colors::Black(); // Default fallback color
+	}
+
+	static winrt::Microsoft::UI::Xaml::Controls::Primitives::Popup CreatePopup(winrt::Microsoft::UI::Xaml::XamlRoot xamlRoot, bool isFullCover, double verticalOffset) {
+
+		winrt::Microsoft::UI::Xaml::Controls::Primitives::Popup popup = {};
+		popup.IsLightDismissEnabled(false);
+		popup.XamlRoot(xamlRoot);
+		popup.ShouldConstrainToRootBounds(false);
+
+		// Create the overlay Border
+		winrt::Microsoft::UI::Xaml::Controls::Border overlay = {};
+		overlay.HorizontalAlignment(winrt::Microsoft::UI::Xaml::HorizontalAlignment::Stretch);
+		overlay.VerticalAlignment(winrt::Microsoft::UI::Xaml::VerticalAlignment::Stretch);
+		overlay.Width(xamlRoot.Size().Width);
+		overlay.Height(isFullCover ? xamlRoot.Size().Height : xamlRoot.Size().Height - verticalOffset);
+		overlay.Opacity(0.0);
+
+		if (isFullCover)
+		{
+			overlay.CornerRadius(winrt::Microsoft::UI::Xaml::CornerRadiusHelper::FromUniformRadius(8));
+			popup.Margin(winrt::Microsoft::UI::Xaml::ThicknessHelper::FromUniformLength(0));
+		}
+		else
+		{
+			if (verticalOffset == 0)
+			{
+				overlay.CornerRadius(winrt::Microsoft::UI::Xaml::CornerRadiusHelper::FromUniformRadius(8));
+			}
+			else
+			{
+				overlay.CornerRadius(winrt::Microsoft::UI::Xaml::CornerRadiusHelper::FromRadii(0, 0, 8, 8));
+			}
+			popup.Margin(winrt::Microsoft::UI::Xaml::ThicknessHelper::FromLengths(0, verticalOffset, 0, 0));
+		}
+
+
+		// Set system backdrop
+		//PopupBackdropManager::TrySetSystemBackdrop(popup, backdropType);
+
+		// Set the child and return
+		popup.Child(overlay);
+		return popup;
+
+	}
+
+};
diff --git a/WinUI3Package/ContentDialogWindow.idl b/WinUI3Package/ContentDialogWindow.idl
new file mode 100644
index 0000000..b7082de
--- /dev/null
+++ b/WinUI3Package/ContentDialogWindow.idl
@@ -0,0 +1,79 @@
+
+import "ContentDialogWindowButtonClickEventArgs.idl";
+import "ContentDialogContent.idl";
+
+namespace WinUI3Package
+{
+    [default_interface]
+    runtimeclass ContentDialogWindow : Microsoft.UI.Xaml.Window
+    {
+        ContentDialogWindow();
+
+        void Open();
+
+        void Hide();
+
+        void UpdateWindowSize();
+
+        void SetParent(Microsoft.UI.Xaml.Window parent, Boolean modal, Boolean center);
+
+        Windows.Foundation.IAsyncOperation<Microsoft.UI.Xaml.Controls.ContentDialogResult> ShowAsync();
+
+        WinUI3Package.ContentDialogContent ContentDialogContent();
+
+        Microsoft.UI.Xaml.Media.Imaging.BitmapImage HeaderImage{ get; set; };
+        String HeaderImageUri{ get; set; };
+
+        Microsoft.UI.Xaml.Media.Brush Foreground{ get; set; };
+        Microsoft.UI.Xaml.Media.Brush Background{ get; set; };
+        Microsoft.UI.Xaml.Media.Brush BorderBrush{ get; set; };
+
+        Microsoft.UI.Xaml.Thickness BorderThickness{ get; set; };
+
+        Microsoft.UI.Xaml.FlowDirection FlowDirection{ get; set; };
+
+        Microsoft.UI.Xaml.DataTemplate TitleTemplate{ get; set; };
+        Microsoft.UI.Xaml.DataTemplate ContentTemplate{ get; set; };
+
+        String PrimaryButtonText{ get; set; };
+        String SecondaryButtonText{ get; set; };
+        String CloseButtonText{ get; set; };
+
+        Boolean IsPrimaryButtonEnabled{ get; set; };
+        Boolean IsSecondaryButtonEnabled{ get; set; };
+
+
+        Microsoft.UI.Xaml.Controls.ContentDialogButton DefaultButton{ get; set; };
+
+        Microsoft.UI.Xaml.Style PrimaryButtonStyle{ get; set; };
+        Microsoft.UI.Xaml.Style SecondaryButtonStyle{ get; set; };
+        Microsoft.UI.Xaml.Style CloseButtonStyle{ get; set; };
+
+        Object DialogTitle{ get; set; };
+        Object DialogContent{ get; set; };
+
+        Microsoft.UI.Xaml.Controls.ContentDialogResult Result{ get; set; };
+
+        Boolean HasTitleBar{ get; set; };
+        Boolean IsResizable{ get; set; };
+
+        Microsoft.UI.Xaml.ElementTheme RequestedTheme{ get; set; };
+
+
+        Windows.Foundation.Collections.IVector<Microsoft.UI.Xaml.Input.KeyboardAccelerator> PrimaryButtonKeyboardAccelerators{ get; };
+        Windows.Foundation.Collections.IVector<Microsoft.UI.Xaml.Input.KeyboardAccelerator> SecondaryButtonKeyboardAccelerators{ get; };
+        Windows.Foundation.Collections.IVector<Microsoft.UI.Xaml.Input.KeyboardAccelerator> CloseButtonKeyboardAccelerators{ get; };
+
+
+        event Windows.Foundation.TypedEventHandler<WinUI3Package.ContentDialogWindow, Object> Loaded;
+        event Windows.Foundation.TypedEventHandler<WinUI3Package.ContentDialogWindow, Object> Opened;
+
+        event Windows.Foundation.TypedEventHandler<Object, Microsoft.UI.Xaml.Input.RightTappedRoutedEventArgs> ContentRightTapped;
+
+
+        event Windows.Foundation.TypedEventHandler<WinUI3Package.ContentDialogWindow, WinUI3Package.ContentDialogWindowButtonClickEventArgs> PrimaryButtonClick;
+        event Windows.Foundation.TypedEventHandler<WinUI3Package.ContentDialogWindow, WinUI3Package.ContentDialogWindowButtonClickEventArgs> SecondaryButtonClick;
+        event Windows.Foundation.TypedEventHandler<WinUI3Package.ContentDialogWindow, WinUI3Package.ContentDialogWindowButtonClickEventArgs> CloseButtonClick;
+
+    }
+}
diff --git a/WinUI3Package/ContentDialogWindow.xaml b/WinUI3Package/ContentDialogWindow.xaml
new file mode 100644
index 0000000..ccef6bd
--- /dev/null
+++ b/WinUI3Package/ContentDialogWindow.xaml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<Window
+    x:Class="WinUI3Package.ContentDialogWindow"
+    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:local="using:WinUI3Package"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    Title="ContentDialogWindow"
+    mc:Ignorable="d">
+
+    <Grid x:Name="ContentDialogGrid">
+
+
+        <StackPanel>
+
+            <Grid
+                x:Name="ImageGrid"
+                Width="0"
+                Height="0"
+                Visibility="Collapsed">
+
+                <Image x:Name="WindowImage" />
+
+            </Grid>
+
+            <local:ContentDialogContent
+                x:Name="ContentDialogContentControl"
+                CloseButtonClick="OnCloseButtonClick"
+                Loaded="OnContentLoaded"
+                PrimaryButtonClick="OnPrimaryButtonClick"
+                SecondaryButtonClick="OnSecondaryButtonClick" />
+        </StackPanel>
+
+    </Grid>
+</Window>
diff --git a/WinUI3Package/ContentDialogWindow.xaml.cpp b/WinUI3Package/ContentDialogWindow.xaml.cpp
new file mode 100644
index 0000000..7f570a4
--- /dev/null
+++ b/WinUI3Package/ContentDialogWindow.xaml.cpp
@@ -0,0 +1,798 @@
+#include "pch.h"
+#include "ContentDialogWindow.xaml.h"
+#if __has_include("ContentDialogWindow.g.cpp")
+#include "ContentDialogWindow.g.cpp"
+#endif
+
+
+#include <winrt/Microsoft.UI.Xaml.Media.Imaging.h>
+#include <winrt/Microsoft.UI.Interop.h>
+#include <winrt/Microsoft.UI.Input.h>
+#include <winrt/Microsoft.UI.Windowing.h>
+#include <Microsoft.UI.Xaml.Window.h>
+
+#include <windows.h>
+#include <commctrl.h>
+
+#include "ContentDialogWindowButtonClickEventArgs.h"
+
+namespace winrt::WinUI3Package::implementation
+{
+	LRESULT CALLBACK TitleBarSubclassProc(
+		HWND hWnd,
+		UINT uMsg,
+		WPARAM wParam,
+		LPARAM lParam,
+		UINT_PTR uIdSubclass,
+		DWORD_PTR dwRefData
+	)
+	{
+		// 拦截非客户区双击消息
+		if (uMsg == WM_NCLBUTTONDBLCLK)
+		{
+			// 只在标题栏区域拦截双击
+			if (wParam == HTCAPTION)
+			{
+				// 返回 0 表示已处理，阻止默认行为
+				return 0;
+			}
+		}
+		else if ((uMsg == WM_NCRBUTTONDOWN || uMsg == WM_NCRBUTTONUP) && wParam == HTCAPTION)
+		{
+			// 返回 0 表示已处理，阻止系统菜单弹出
+			return 0;
+		}
+		// 其他消息传递给默认窗口过程
+		return DefSubclassProc(hWnd, uMsg, wParam, lParam);
+	}
+
+	ContentDialogWindow::ContentDialogWindow() {
+
+		InitializeComponent();
+
+		ExtendsContentIntoTitleBar(true);
+
+		_presenter = Microsoft::UI::Windowing::OverlappedPresenter::CreateForDialog();
+
+		_presenter.IsResizable(true);
+		//_presenter.IsAlwaysOnTop(true);
+		//_presenter.SetBorderAndTitleBar(true, false);
+
+		AppWindow().SetPresenter(_presenter);
+
+		NonMaximizableWindowWorkaround m_windowWorkaround = {};
+
+		m_windowWorkaround.IsMaximizable(false);
+		m_windowWorkaround.Window(*this);
+
+
+		//HWND hwnd = (HWND)WindowHelper::GetWindowHandle(*this);
+
+		//SetWindowLongPtr(hwnd, GWL_STYLE, GetWindowLongPtr(hwnd, GWL_STYLE) & ~WS_DLGFRAME);
+
+		//Result(Microsoft::UI::Xaml::Controls::ContentDialogResult::None);
+
+		//auto hWnd = (HWND)WinUI3Package::WindowHelper::GetWindowHandle(*this);
+
+		//auto controlsHwnd = FindWindowEx(hWnd, 0, L"ReunionWindowingCaptionControls", L"ReunionCaptionControlsWindow");
+
+		//if (controlsHwnd != nullptr) DestroyWindow(controlsHwnd);
+
+		//m_Activated = Activated({ this, &ContentDialogWindow::OnActivated });;
+
+
+		m_OnPrimaryButtonClick = this->ContentDialogContent().PrimaryButtonClick({ this, &ContentDialogWindow::OnPrimaryButtonClick });
+		m_OnSecondaryButtonClick = this->ContentDialogContent().SecondaryButtonClick({ this, &ContentDialogWindow::OnSecondaryButtonClick });
+		m_OnCloseButtonClick = this->ContentDialogContent().CloseButtonClick({ this, &ContentDialogWindow::OnCloseButtonClick });
+
+		this->ContentDialogContent().ContentRightTapped({ this, &ContentDialogWindow::OnContentRightTapped });
+
+		//this->ContentDialogContent().Loaded([&](auto&, auto&) {
+		//	DetermineTitleBarButtonForegroundColor();
+		//});
+
+		m_ActualThemeChanged = this->ContentDialogContent().ActualThemeChanged([&](auto&, auto&) {
+			DetermineTitleBarButtonForegroundColor();
+		});
+
+		//Microsoft::UI::Xaml::Media::ImageSource ImageSource = {};
+
+		//Microsoft::UI::Xaml::Media::Imaging::BitmapImage bitmapImage = {};
+		//bitmapImage.UriSource(Windows::Foundation::Uri(L"https://shared.fastly.steamstatic.com/store_item_assets/steam/apps/1364780/header.jpg"));
+
+		//WindowImage().Source(bitmapImage);
+
+
+		m_Closing = AppWindow().Closing([&](auto&, auto&) {
+
+			AppWindow().Closing(m_Closing);
+
+			OnClosingRequestedBySystem();
+
+			//OutputDebugStringA("11111\r\n");
+
+			//RemoveWindowSubclass(
+			//	(HWND)WindowHelper::GetWindowHandle(*this),  // 窗口句柄
+			//	TitleBarSubclassProc,                        // 子类过程函数
+			//	0xFF69B4                                             // 子类ID（与SetWindowSubclass时的参数一致）
+			//);
+		});
+
+		m_Closed = Closed([&](auto&, auto&) {
+
+			Closed(m_Closed);
+
+			if (_parent != nullptr) 	_parent.Closed(m_OnParentClosed);
+
+			WindowImage().ImageOpened(m_ImageOpened);
+
+			this->ContentDialogContent().PrimaryButtonClick(m_OnPrimaryButtonClick);
+			this->ContentDialogContent().SecondaryButtonClick(m_OnSecondaryButtonClick);
+			this->ContentDialogContent().CloseButtonClick(m_OnCloseButtonClick);
+			this->ContentDialogContent().ActualThemeChanged(m_ActualThemeChanged);
+
+			Deferral.Complete();
+
+		});
+
+		//SetWindowSubclass((HWND)WindowHelper::GetWindowHandle(*this), TitleBarSubclassProc, 0xFF69B4, 0);
+
+		//this->ContentDialogContent() = WinUI3Package::ContentDialogthis->ContentDialogContent();
+		this->ContentDialogContent().Loaded({ this, &ContentDialogWindow::OnContentLoaded });;
+
+		m_ImageOpened = WindowImage().ImageOpened([this](IInspectable const& sender, Microsoft::UI::Xaml::RoutedEventArgs const& args)
+		{
+			auto image = sender.as<Microsoft::UI::Xaml::Controls::Image>();
+
+			if (image)
+			{
+				// 获取图片源并转换为BitmapImage
+				auto bitmapImage = image.Source().as<Microsoft::UI::Xaml::Media::Imaging::BitmapImage>();
+				if (bitmapImage)
+				{
+					// 获取图片实际宽高（像素）
+					double width = bitmapImage.PixelWidth();
+					double height = bitmapImage.PixelHeight();
+
+
+					if (auto parentGrid = image.Parent().as<Microsoft::UI::Xaml::Controls::Grid>())
+					{
+						parentGrid.Width(width);
+						parentGrid.Height(height);
+					}
+
+					UpdateWindowSize();
+				}
+			}
+		});
+
+	}
+
+	ContentDialogWindow::~ContentDialogWindow() {
+
+		//Closed(m_Closed);
+		//if (_parent != nullptr) _parent.Closed(m_OnParentClosed);
+
+		//this->ContentDialogContent().PrimaryButtonClick(m_OnPrimaryButtonClick);
+		//this->ContentDialogContent().SecondaryButtonClick(m_OnSecondaryButtonClick);
+		//this->ContentDialogContent().CloseButtonClick(m_OnCloseButtonClick);
+	}
+
+	void ContentDialogWindow::InitializeContentDialog(WinUI3Package::ContentDialogContent& component)
+	{
+
+	}
+
+	winrt::Windows::Foundation::IAsyncOperation<Microsoft::UI::Xaml::Controls::ContentDialogResult> ContentDialogWindow::ShowAsync()
+	{
+
+		Deferral = AsyncEventArgs.GetDeferral();
+
+		//Open();
+
+		co_await AsyncEventArgs.wait_for_deferrals();
+
+		co_return Result();
+
+		co_return{};
+
+	}
+
+	void ContentDialogWindow::UpdateWindowSize() {
+
+
+		// 计算基础窗口宽度（未应用缩放）
+		int baseWidth = ImageGrid().Width() ?
+			(int)ImageGrid().Width() :
+			(int)(this->ContentDialogContent().DesiredSize().Width + 1);
+
+		// 计算基础窗口高度（未应用缩放）
+		int baseHeight =
+			(int)(this->ContentDialogContent().DesiredSize().Height - 30) +
+			(int)ImageGrid().Height();
+
+		// 获取缩放比例
+		float scale = (float)this->ContentDialogContent().XamlRoot().RasterizationScale();
+
+		// 在ResizeClient中应用缩放比例
+		AppWindow().ResizeClient(Windows::Graphics::SizeInt32(
+			(int)(baseWidth * scale) + 1,
+			(int)(baseHeight * scale) + 1
+		));
+
+
+		//AppWindow().ResizeClient(Windows::Graphics::SizeInt32(
+		//	((int)((this->ContentDialogContent().DesiredSize().Width + 1) * this->ContentDialogContent().XamlRoot().RasterizationScale()) + 1) + ImageGrid().Width(),
+		//	((int)((this->ContentDialogContent().DesiredSize().Height - 30) * this->ContentDialogContent().XamlRoot().RasterizationScale()) + 1) + ImageGrid().Height()));
+
+
+		if (_center)
+		{
+			if (_parent != nullptr)
+			{
+				AppWindow().Move(Windows::Graphics::PointInt32(
+					_parent.AppWindow().Position().X + (_parent.AppWindow().Size().Width - AppWindow().Size().Width) / 2,
+					_parent.AppWindow().Position().Y + (_parent.AppWindow().Size().Height - AppWindow().Size().Height) / 2));
+			}
+			else
+			{
+				auto displayArea = Microsoft::UI::Windowing::DisplayArea::GetFromWindowId(AppWindow().Id(), Microsoft::UI::Windowing::DisplayAreaFallback::Primary);
+				AppWindow().Move(Windows::Graphics::PointInt32(
+					(displayArea.OuterBounds().Width - AppWindow().Size().Width) / 2,
+					(displayArea.OuterBounds().Height - AppWindow().Size().Height) / 2));
+			}
+		}
+
+	}
+
+	void ContentDialogWindow::OnContentLoaded(winrt::Windows::Foundation::IInspectable const& sender, Microsoft::UI::Xaml::RoutedEventArgs const& e)
+	{
+		//SetForegroundWindow((HWND)WinUI3Package::WindowHelper::GetWindowHandle(*this));
+
+		UpdateWindowSize();
+
+		SetTitleBar(this->ContentDialogContent().TitleArea());
+
+
+		if (SystemBackdrop() == nullptr)
+		{
+			auto requestedTheme = RequestedTheme();
+
+			// 根据主题设置不同的背景色
+			switch (requestedTheme)
+			{
+				case Microsoft::UI::Xaml::ElementTheme::Light:
+					Background(Microsoft::UI::Xaml::Media::SolidColorBrush(Microsoft::UI::Colors::White()));
+					break;
+				case Microsoft::UI::Xaml::ElementTheme::Dark:
+					// ARGB值: 0xFF (不透明), 0x20, 0x20, 0x20 (深灰色)
+					Background(Microsoft::UI::Xaml::Media::SolidColorBrush(
+						Windows::UI::ColorHelper::FromArgb(0xFF, 0x20, 0x20, 0x20)));
+					break;
+				default:
+					Background(nullptr);
+					break;
+			}
+		}
+
+		if (SystemBackdrop() == nullptr || SystemBackdrop().try_as<Microsoft::UI::Xaml::Media::DesktopAcrylicBackdrop>() != nullptr)
+		{
+			// 如果系统背景为空或为DesktopAcrylicBackdrop，将透明度设为1.0
+			this->ContentDialogContent().CommandSpace().Background().Opacity(1.0);
+		}
+		else
+		{
+			// 其他情况透明度设为0.5
+			this->ContentDialogContent().CommandSpace().Background().Opacity(0.5);
+		}
+
+
+		DetermineTitleBarButtonForegroundColor();
+
+		//std::list<Microsoft::UI::Xaml::FrameworkElement> ElementsList = {};
+
+		//ElementsList.push_back(_content.TitleArea().as<Microsoft::UI::Xaml::FrameworkElement>());
+
+		//UpdateDragRegion(ElementsList);
+
+		DispatcherQueue().TryEnqueue([this]()
+		{
+			// 触发 Loaded 事件（如果有订阅者）
+			m_Loaded(*this, nullptr);
+		});
+
+		Open();
+		//sizeChangedToken = this->ContentDialogContent().SizeChanged([&](auto&, auto&) {
+
+
+		//	InitializeWindow();
+
+
+		//});
+		//this->ContentDialogContent().SizeChanged([&](auto&, auto&) {
+
+		//	UpdateWindowSize();
+		//});
+	}
+
+	void ContentDialogWindow::Open()
+	{
+		AppWindow().Show();
+
+		DispatcherQueue().TryEnqueue([this]()
+		{
+			// 触发 Loaded 事件（如果有订阅者）
+			m_Opened(*this, nullptr);
+		});
+	}
+
+	void ContentDialogWindow::Hide()
+	{
+		AppWindow().Hide();
+	}
+
+	void ContentDialogWindow::OnActivated(winrt::Windows::Foundation::IInspectable const& sender, Microsoft::UI::Xaml::WindowActivatedEventArgs args)
+	{
+		//if (!this->ContentDialogContent().IsLoaded()) return;
+
+		//if (args.WindowActivationState() == Microsoft::UI::Xaml::WindowActivationState::Deactivated)
+		//{
+		//	this->ContentDialogContent().AfterLostFocus();
+		//}
+		//else
+		//{
+		//	this->ContentDialogContent().AfterGotFocus();
+		//}
+	}
+
+	void ContentDialogWindow::OnClosingRequestedBySystem()
+	{
+		if (_parent) {
+			_parent.Activate();
+			//_parent.Closed(m_OnParentClosed);
+		}
+		if (AppWindow()) AppWindow().Hide();
+
+		//Close();
+	}
+
+	void ContentDialogWindow::OnClosingRequstedByCode()
+	{
+		if (_parent) {
+			_parent.Activate();
+			//_parent.Closed(m_OnParentClosed);
+		}
+
+		if (AppWindow()) AppWindow().Hide();
+
+		//Close();
+	}
+
+	void ContentDialogWindow::OnParentClosed(winrt::Windows::Foundation::IInspectable const& sender, Microsoft::UI::Xaml::WindowEventArgs args)
+	{
+		//if (_parent != nullptr) _parent.Closed(m_OnParentClosed);
+
+		_parent = nullptr;
+
+		//DispatcherQueue().TryEnqueue([&] {
+
+		//	Close();
+		//});
+	}
+
+	winrt::Windows::Foundation::IAsyncAction ContentDialogWindow::OnPrimaryButtonClick(winrt::Windows::Foundation::IInspectable const& sender, WinUI3Package::ContentDialogWindowButtonClickEventArgs const& args)
+	{
+		if (args.Handled()) co_return;
+
+		args.Handled(true);
+
+		auto ButtonDeferral = args.GetDeferral();
+
+		Result(Microsoft::UI::Xaml::Controls::ContentDialogResult::Primary);
+
+		auto Args = WinUI3Package::ContentDialogWindowButtonClickEventArgs();
+
+		m_PrimaryButtonClick(*this, Args);
+
+		co_await Args.wait_for_deferrals();
+
+		AfterCommandSpaceButtonClick(Args);
+
+		ButtonDeferral.Complete();
+
+	}
+
+	winrt::Windows::Foundation::IAsyncAction ContentDialogWindow::OnSecondaryButtonClick(winrt::Windows::Foundation::IInspectable const& sender, WinUI3Package::ContentDialogWindowButtonClickEventArgs const& args)
+	{
+
+		if (args.Handled()) co_return;
+
+		args.Handled(true);
+
+		auto ButtonDeferral = args.GetDeferral();
+
+		Result(Microsoft::UI::Xaml::Controls::ContentDialogResult::Secondary);
+
+		auto Args = WinUI3Package::ContentDialogWindowButtonClickEventArgs();
+
+		m_SecondaryButtonClick(*this, Args);
+
+		co_await Args.wait_for_deferrals();
+
+		AfterCommandSpaceButtonClick(Args);
+
+		ButtonDeferral.Complete();
+	}
+
+	winrt::Windows::Foundation::IAsyncAction ContentDialogWindow::OnCloseButtonClick(winrt::Windows::Foundation::IInspectable const& sender, WinUI3Package::ContentDialogWindowButtonClickEventArgs const& args)
+	{
+
+
+		if (args.Handled()) co_return;
+
+		args.Handled(true);
+
+		auto ButtonDeferral = args.GetDeferral();
+
+		Result(Microsoft::UI::Xaml::Controls::ContentDialogResult::None);
+
+		auto Args = WinUI3Package::ContentDialogWindowButtonClickEventArgs();
+
+		m_CloseButtonClick(*this, Args);
+
+		co_await Args.wait_for_deferrals();
+
+		AfterCommandSpaceButtonClick(Args);
+
+		ButtonDeferral.Complete();
+
+	}
+
+	void ContentDialogWindow::DetermineTitleBarButtonForegroundColor()
+	{
+		switch (this->ContentDialogContent().ActualTheme())
+		{
+			case Microsoft::UI::Xaml::ElementTheme::Light: {
+				AppWindow().TitleBar().ButtonForegroundColor(Microsoft::UI::Colors::Black());
+				break;
+			}
+
+			case Microsoft::UI::Xaml::ElementTheme::Dark: {
+				AppWindow().TitleBar().ButtonForegroundColor(Microsoft::UI::Colors::White());
+				break;
+			}
+		}
+	}
+
+	void ContentDialogWindow::AfterCommandSpaceButtonClick(WinUI3Package::ContentDialogWindowButtonClickEventArgs const& args)
+	{
+
+		if (args.Cancel()) {
+
+
+			//Result(Microsoft::UI::Xaml::Controls::ContentDialogResult::None);
+			return;
+
+		}
+
+		OnClosingRequstedByCode();
+
+
+		this->DispatcherQueue().TryEnqueue([this] {
+
+			Close();
+		});
+
+	}
+
+	void ContentDialogWindow::SetParent(Microsoft::UI::Xaml::Window const& parent, bool modal /*= true*/, bool center /*= true*/)
+	{
+		_center = center;
+
+		if (_parent == parent) return;
+
+		if (_parent != nullptr) _parent.Closed(m_OnParentClosed);
+
+		_parent = parent;
+
+		if (_parent != nullptr) m_OnParentClosed = _parent.Closed({ this, &ContentDialogWindow::OnParentClosed });;
+
+		HWND ownerHwnd = parent ?
+			winrt::Microsoft::UI::GetWindowFromWindowId(parent.AppWindow().Id()) :
+			nullptr;
+		HWND ownedHwnd = GetWindowFromWindowId(AppWindow().Id());
+
+		if (ownedHwnd)
+		{
+			SetWindowLongPtr(ownedHwnd, -8, reinterpret_cast<LONG_PTR>(ownerHwnd));
+		}
+
+		_presenter.IsModal(parent && modal);
+	}
+
+	void ContentDialogWindow::Foreground(Microsoft::UI::Xaml::Media::Brush const& brush) {
+
+		this->ContentDialogContent().Foreground(brush);
+	}
+	Microsoft::UI::Xaml::Media::Brush ContentDialogWindow::Foreground() {
+
+		return this->ContentDialogContent().Foreground();
+	}
+
+	void ContentDialogWindow::Background(Microsoft::UI::Xaml::Media::Brush const& brush) {
+
+		this->ContentDialogContent().Background(brush);
+	}
+	Microsoft::UI::Xaml::Media::Brush ContentDialogWindow::Background() {
+
+		return this->ContentDialogContent().Background();
+	}
+
+	void ContentDialogWindow::BorderBrush(Microsoft::UI::Xaml::Media::Brush const& brush) {
+
+		this->ContentDialogContent().BorderBrush(brush);
+	}
+	Microsoft::UI::Xaml::Media::Brush ContentDialogWindow::BorderBrush() {
+
+		return this->ContentDialogContent().BorderBrush();
+	}
+
+
+	void ContentDialogWindow::BorderThickness(Microsoft::UI::Xaml::Thickness const& thickness) {
+		this->ContentDialogContent().BorderThickness(thickness);
+	}
+	Microsoft::UI::Xaml::Thickness ContentDialogWindow::BorderThickness() {
+
+		return this->ContentDialogContent().BorderThickness();
+	}
+
+	void ContentDialogWindow::FlowDirection(Microsoft::UI::Xaml::FlowDirection const& direction) {
+		this->ContentDialogContent().FlowDirection(direction);
+	}
+	Microsoft::UI::Xaml::FlowDirection ContentDialogWindow::FlowDirection() {
+		return this->ContentDialogContent().FlowDirection();
+	}
+
+	void ContentDialogWindow::TitleTemplate(Microsoft::UI::Xaml::DataTemplate const& value) {
+		this->ContentDialogContent().TitleTemplate(value);
+	}
+	Microsoft::UI::Xaml::DataTemplate ContentDialogWindow::TitleTemplate() {
+		return this->ContentDialogContent().TitleTemplate();
+	}
+
+	void ContentDialogWindow::ContentTemplate(Microsoft::UI::Xaml::DataTemplate const& value) {
+		this->ContentDialogContent().ContentTemplate(value);
+	}
+	Microsoft::UI::Xaml::DataTemplate ContentDialogWindow::ContentTemplate() {
+		return this->ContentDialogContent().ContentTemplate();
+	}
+
+	void ContentDialogWindow::PrimaryButtonText(winrt::hstring const& text) {
+		this->ContentDialogContent().PrimaryButtonText(text);
+	}
+	winrt::hstring ContentDialogWindow::PrimaryButtonText() {
+		return this->ContentDialogContent().PrimaryButtonText();
+	}
+
+	void ContentDialogWindow::SecondaryButtonText(winrt::hstring const& text) {
+		this->ContentDialogContent().SecondaryButtonText(text);
+	}
+	winrt::hstring ContentDialogWindow::SecondaryButtonText() {
+		return this->ContentDialogContent().SecondaryButtonText();
+	}
+
+	void ContentDialogWindow::CloseButtonText(winrt::hstring const& text) {
+		this->ContentDialogContent().CloseButtonText(text);
+	}
+	winrt::hstring ContentDialogWindow::CloseButtonText() {
+		return this->ContentDialogContent().CloseButtonText();
+	}
+
+	void ContentDialogWindow::IsPrimaryButtonEnabled(bool enabled) {
+		this->ContentDialogContent().IsPrimaryButtonEnabled(enabled);
+
+	}
+	bool ContentDialogWindow::IsPrimaryButtonEnabled() {
+		return this->ContentDialogContent().IsPrimaryButtonEnabled();
+	}
+
+	void ContentDialogWindow::IsSecondaryButtonEnabled(bool enabled) {
+		this->ContentDialogContent().IsSecondaryButtonEnabled(enabled);
+	}
+	bool ContentDialogWindow::IsSecondaryButtonEnabled() {
+		return this->ContentDialogContent().IsSecondaryButtonEnabled();
+	}
+
+	void ContentDialogWindow::DefaultButton(Microsoft::UI::Xaml::Controls::ContentDialogButton button) {
+		this->ContentDialogContent().DefaultButton(button);
+	}
+	Microsoft::UI::Xaml::Controls::ContentDialogButton ContentDialogWindow::DefaultButton() {
+		return this->ContentDialogContent().DefaultButton();
+	}
+
+	void ContentDialogWindow::PrimaryButtonStyle(Microsoft::UI::Xaml::Style const& style) {
+		this->ContentDialogContent().PrimaryButtonStyle(style);
+	}
+	Microsoft::UI::Xaml::Style ContentDialogWindow::PrimaryButtonStyle() {
+		return this->ContentDialogContent().PrimaryButtonStyle();
+	}
+
+	void ContentDialogWindow::SecondaryButtonStyle(Microsoft::UI::Xaml::Style const& style) {
+		this->ContentDialogContent().SecondaryButtonStyle(style);
+	}
+	Microsoft::UI::Xaml::Style ContentDialogWindow::SecondaryButtonStyle() {
+		return this->ContentDialogContent().SecondaryButtonStyle();
+	}
+
+	void ContentDialogWindow::CloseButtonStyle(Microsoft::UI::Xaml::Style const& style) {
+		this->ContentDialogContent().CloseButtonStyle(style);
+	}
+	Microsoft::UI::Xaml::Style ContentDialogWindow::CloseButtonStyle() {
+		return this->ContentDialogContent().CloseButtonStyle();
+	}
+
+	void ContentDialogWindow::DialogTitle(winrt::Windows::Foundation::IInspectable const& title) {
+		this->ContentDialogContent().Title(title);
+	}
+	winrt::Windows::Foundation::IInspectable ContentDialogWindow::DialogTitle() {
+		return this->ContentDialogContent().Title();
+	}
+
+	void ContentDialogWindow::DialogContent(winrt::Windows::Foundation::IInspectable const& Value) {
+		this->ContentDialogContent().Content(Value);
+	}
+	winrt::Windows::Foundation::IInspectable ContentDialogWindow::DialogContent() {
+		return this->ContentDialogContent().Content();
+	}
+
+	//void ContentDialogWindow::Result(Microsoft::UI::Xaml::Controls::ContentDialogResult result) {
+	//	_content.Result(result);
+	//}
+	//Microsoft::UI::Xaml::Controls::ContentDialogResult ContentDialogWindow::Result() {
+	//	return _content.Result();
+	//}
+
+	void ContentDialogWindow::HasTitleBar(bool value) {
+		m_hasTitleBar = value;
+		if (_presenter) _presenter.SetBorderAndTitleBar(true, value);
+	}
+	bool ContentDialogWindow::HasTitleBar() {
+		return m_hasTitleBar;
+	}
+
+	void ContentDialogWindow::IsResizable(bool value) {
+		m_isResizable = value;
+		if (_presenter) _presenter.IsResizable(value);
+	}
+	bool ContentDialogWindow::IsResizable() {
+
+		return m_isResizable;
+	}
+
+	void ContentDialogWindow::RequestedTheme(Microsoft::UI::Xaml::ElementTheme theme) {
+		this->ContentDialogContent().RequestedTheme(theme);
+	}
+	Microsoft::UI::Xaml::ElementTheme ContentDialogWindow::RequestedTheme() {
+		return this->ContentDialogContent().RequestedTheme();
+	}
+
+	winrt::event_token ContentDialogWindow::Loaded(Windows::Foundation::TypedEventHandler<WinUI3Package::ContentDialogWindow, Windows::Foundation::IInspectable> const& handler)
+	{
+		return m_Loaded.add(handler);
+	}
+	void ContentDialogWindow::Loaded(winrt::event_token const& token)
+	{
+		m_Loaded.remove(token);
+	}
+
+	winrt::event_token ContentDialogWindow::Opened(Windows::Foundation::TypedEventHandler<WinUI3Package::ContentDialogWindow, Windows::Foundation::IInspectable> const& handler)
+	{
+		return m_Opened.add(handler);
+	}
+	void ContentDialogWindow::Opened(winrt::event_token const& token)
+	{
+		m_Opened.remove(token);
+	}
+
+	winrt::event_token ContentDialogWindow::PrimaryButtonClick(Windows::Foundation::TypedEventHandler<WinUI3Package::ContentDialogWindow, WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler)
+	{
+		return m_PrimaryButtonClick.add(handler);
+	}
+	void ContentDialogWindow::PrimaryButtonClick(winrt::event_token const& token)
+	{
+		m_PrimaryButtonClick.remove(token);
+	}
+
+	winrt::event_token ContentDialogWindow::SecondaryButtonClick(Windows::Foundation::TypedEventHandler<WinUI3Package::ContentDialogWindow, WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler)
+	{
+		return m_SecondaryButtonClick.add(handler);
+	}
+	void ContentDialogWindow::SecondaryButtonClick(winrt::event_token const& token)
+	{
+		m_SecondaryButtonClick.remove(token);
+	}
+
+	winrt::event_token ContentDialogWindow::CloseButtonClick(Windows::Foundation::TypedEventHandler<WinUI3Package::ContentDialogWindow, WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler)
+	{
+		return m_CloseButtonClick.add(handler);
+	}
+	void ContentDialogWindow::CloseButtonClick(winrt::event_token const& token)
+	{
+		m_CloseButtonClick.remove(token);
+	}
+
+
+	winrt::event_token ContentDialogWindow::ContentRightTapped(Windows::Foundation::TypedEventHandler<Windows::Foundation::IInspectable, winrt::Microsoft::UI::Xaml::Input::RightTappedRoutedEventArgs> const& handler)
+	{
+		return m_ContentRightTapped.add(handler);
+	}
+
+	void ContentDialogWindow::ContentRightTapped(winrt::event_token const& token)
+	{
+		m_ContentRightTapped.remove(token);
+	}
+
+	winrt::hstring ContentDialogWindow::HeaderImageUri()
+	{
+		return m_HeaderImageUri;
+	}
+
+	void ContentDialogWindow::HeaderImageUri(winrt::hstring const& Value)
+	{
+		if (m_HeaderImageUri != Value) {
+
+			m_HeaderImageUri = Value;
+
+			if (!Value.empty()) {
+
+				Microsoft::UI::Xaml::Media::Imaging::BitmapImage bitmapImage = {};
+				bitmapImage.UriSource(Windows::Foundation::Uri(m_HeaderImageUri));
+				WindowImage().Source(bitmapImage);
+				this->ContentDialogContent().IsHeaderImage(true);
+				ImageGrid().Visibility(Microsoft::UI::Xaml::Visibility::Visible);
+			}
+		}
+	}
+
+	winrt::Microsoft::UI::Xaml::Media::Imaging::BitmapImage ContentDialogWindow::HeaderImage()
+	{
+		return m_HeaderImage;
+	}
+
+	void ContentDialogWindow::HeaderImage(Microsoft::UI::Xaml::Media::Imaging::BitmapImage const& Value)
+	{
+		if (Value && m_HeaderImage != Value) {
+
+			m_HeaderImage = Value;
+
+			//Microsoft::UI::Xaml::Media::Imaging::BitmapImage bitmapImage = {};
+			//bitmapImage.UriSource(Windows::Foundation::Uri(L"https://shared.fastly.steamstatic.com/store_item_assets/steam/apps/1364780/header.jpg"));
+			WindowImage().Source(Value);
+
+			this->ContentDialogContent().IsHeaderImage(true);
+		}
+	}
+
+	winrt::Windows::Foundation::Collections::IVector<winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator> ContentDialogWindow::PrimaryButtonKeyboardAccelerators() {
+
+		return this->ContentDialogContent().PrimaryButtonKeyboardAccelerators();
+	}
+
+	winrt::Windows::Foundation::Collections::IVector<winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator> ContentDialogWindow::SecondaryButtonKeyboardAccelerators() {
+
+		return this->ContentDialogContent().SecondaryButtonKeyboardAccelerators();
+	}
+
+	winrt::Windows::Foundation::Collections::IVector<winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator> ContentDialogWindow::CloseButtonKeyboardAccelerators() {
+
+		return this->ContentDialogContent().CloseButtonKeyboardAccelerators();
+	}
+
+
+
+	void ContentDialogWindow::OnContentRightTapped(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::Input::RightTappedRoutedEventArgs const& e)
+	{
+		m_ContentRightTapped(*this, e);
+	}
+
+}
diff --git a/WinUI3Package/ContentDialogWindow.xaml.h b/WinUI3Package/ContentDialogWindow.xaml.h
new file mode 100644
index 0000000..ece3a91
--- /dev/null
+++ b/WinUI3Package/ContentDialogWindow.xaml.h
@@ -0,0 +1,234 @@
+#pragma once
+
+#include "ContentDialogWindow.g.h"
+
+#include <winrt/Microsoft.UI.Windowing.h>
+#include "include/cppwinrt_utils.h"
+
+namespace winrt::WinUI3Package::implementation
+{
+	struct ContentDialogWindow : ContentDialogWindowT<ContentDialogWindow>
+	{
+		ContentDialogWindow();
+		~ContentDialogWindow();
+
+		void InitializeContentDialog(WinUI3Package::ContentDialogContent& component);
+
+		winrt::WinUI3Package::ContentDialogContent ContentDialogContent() {
+
+			return this->ContentDialogContentControl();
+		}
+
+
+		winrt::Windows::Foundation::IAsyncOperation<Microsoft::UI::Xaml::Controls::ContentDialogResult> ShowAsync();
+
+		void UpdateWindowSize();
+
+
+		//void UpdateWindowSize1();
+
+		void OnContentLoaded(winrt::Windows::Foundation::IInspectable const& sender, Microsoft::UI::Xaml::RoutedEventArgs const& e);
+
+		void OnActivated(winrt::Windows::Foundation::IInspectable const& sender, Microsoft::UI::Xaml::WindowActivatedEventArgs args);
+
+		void Open();
+
+		void Hide();
+
+		void OnClosingRequestedBySystem();
+
+		void OnClosingRequstedByCode();
+
+		void OnParentClosed(winrt::Windows::Foundation::IInspectable const& sender, Microsoft::UI::Xaml::WindowEventArgs args);
+
+		winrt::Windows::Foundation::IAsyncAction OnPrimaryButtonClick(winrt::Windows::Foundation::IInspectable const& sender, WinUI3Package::ContentDialogWindowButtonClickEventArgs const& e);
+		winrt::Windows::Foundation::IAsyncAction OnSecondaryButtonClick(winrt::Windows::Foundation::IInspectable const& sender, WinUI3Package::ContentDialogWindowButtonClickEventArgs const& e);
+		winrt::Windows::Foundation::IAsyncAction OnCloseButtonClick(winrt::Windows::Foundation::IInspectable const& sender, WinUI3Package::ContentDialogWindowButtonClickEventArgs const& e);
+
+		void OnContentRightTapped(winrt::Windows::Foundation::IInspectable const& sender, Microsoft::UI::Xaml::Input::RightTappedRoutedEventArgs const& e);
+
+
+		winrt::event_token ContentRightTapped(Windows::Foundation::TypedEventHandler<Windows::Foundation::IInspectable, Microsoft::UI::Xaml::Input::RightTappedRoutedEventArgs> const& handler);
+		void ContentRightTapped(winrt::event_token const& token);
+
+
+		void UpdateDragRegion(std::list<Microsoft::UI::Xaml::FrameworkElement> const& ElementsList);
+
+		void DetermineTitleBarButtonForegroundColor();
+		void AfterCommandSpaceButtonClick(WinUI3Package::ContentDialogWindowButtonClickEventArgs const& args);
+		void SetParent(Microsoft::UI::Xaml::Window const& parent, bool modal, bool center);
+
+		winrt::event_token Loaded(Windows::Foundation::TypedEventHandler<WinUI3Package::ContentDialogWindow, Windows::Foundation::IInspectable> const& handler);
+		void Loaded(winrt::event_token const& token);
+
+		winrt::event_token Opened(Windows::Foundation::TypedEventHandler<WinUI3Package::ContentDialogWindow, Windows::Foundation::IInspectable> const& handler);
+		void Opened(winrt::event_token const& token);
+
+		winrt::event_token PrimaryButtonClick(Windows::Foundation::TypedEventHandler<WinUI3Package::ContentDialogWindow, WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler);
+		void PrimaryButtonClick(winrt::event_token const& token);
+
+		winrt::event_token SecondaryButtonClick(Windows::Foundation::TypedEventHandler<WinUI3Package::ContentDialogWindow, WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler);
+		void SecondaryButtonClick(winrt::event_token const& token);
+
+		winrt::event_token CloseButtonClick(Windows::Foundation::TypedEventHandler<WinUI3Package::ContentDialogWindow, WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler);
+		void CloseButtonClick(winrt::event_token const& token);
+
+		void Foreground(Microsoft::UI::Xaml::Media::Brush const& brush);
+		Microsoft::UI::Xaml::Media::Brush Foreground();
+
+		void Background(Microsoft::UI::Xaml::Media::Brush const& brush);
+		Microsoft::UI::Xaml::Media::Brush Background();
+
+		void BorderBrush(Microsoft::UI::Xaml::Media::Brush const& brush);
+		Microsoft::UI::Xaml::Media::Brush BorderBrush();
+
+		void BorderThickness(Microsoft::UI::Xaml::Thickness const& thickness);
+		Microsoft::UI::Xaml::Thickness BorderThickness();
+
+		void FlowDirection(Microsoft::UI::Xaml::FlowDirection const& direction);
+		Microsoft::UI::Xaml::FlowDirection FlowDirection();
+
+		void TitleTemplate(Microsoft::UI::Xaml::DataTemplate const& dataTemplate);
+		Microsoft::UI::Xaml::DataTemplate TitleTemplate();
+
+		void ContentTemplate(Microsoft::UI::Xaml::DataTemplate const& dataTemplate);
+		Microsoft::UI::Xaml::DataTemplate ContentTemplate();
+
+		void PrimaryButtonText(winrt::hstring const& text);
+		winrt::hstring PrimaryButtonText();
+
+		void SecondaryButtonText(winrt::hstring const& text);
+		winrt::hstring SecondaryButtonText();
+
+		void CloseButtonText(winrt::hstring const& text);
+		winrt::hstring CloseButtonText();
+
+		void IsPrimaryButtonEnabled(bool enabled);
+		bool IsPrimaryButtonEnabled();
+
+		void IsSecondaryButtonEnabled(bool enabled);
+		bool IsSecondaryButtonEnabled();
+
+		void DefaultButton(Microsoft::UI::Xaml::Controls::ContentDialogButton button);
+		Microsoft::UI::Xaml::Controls::ContentDialogButton DefaultButton();
+
+		void PrimaryButtonStyle(Microsoft::UI::Xaml::Style const& style);
+		Microsoft::UI::Xaml::Style PrimaryButtonStyle();
+
+		void SecondaryButtonStyle(Microsoft::UI::Xaml::Style const& style);
+		Microsoft::UI::Xaml::Style SecondaryButtonStyle();
+
+		void CloseButtonStyle(Microsoft::UI::Xaml::Style const& style);
+		Microsoft::UI::Xaml::Style CloseButtonStyle();
+
+		void DialogTitle(winrt::Windows::Foundation::IInspectable const& title);
+		winrt::Windows::Foundation::IInspectable DialogTitle();
+
+		void DialogContent(winrt::Windows::Foundation::IInspectable const& content);
+		winrt::Windows::Foundation::IInspectable DialogContent();
+
+		void HasTitleBar(bool hasTitleBar);
+		bool HasTitleBar();
+
+		void IsResizable(bool isResizable);
+		bool IsResizable();
+
+		void RequestedTheme(Microsoft::UI::Xaml::ElementTheme theme);
+		Microsoft::UI::Xaml::ElementTheme RequestedTheme();
+
+		winrt::hstring HeaderImageUri();
+		void HeaderImageUri(winrt::hstring const& Value);
+
+		Microsoft::UI::Xaml::Media::Imaging::BitmapImage HeaderImage();
+		void HeaderImage(Microsoft::UI::Xaml::Media::Imaging::BitmapImage const& Value);
+
+		Microsoft::UI::Xaml::Controls::ContentDialogResult Result() const {
+
+			return _Result;
+		}
+
+		void Result(const Microsoft::UI::Xaml::Controls::ContentDialogResult& value) {
+			if (_Result != value) {
+				_Result = value;
+			}
+
+		}
+
+		winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> PrimaryButtonKeyboardAccelerators();
+		winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> SecondaryButtonKeyboardAccelerators();
+		winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> CloseButtonKeyboardAccelerators();
+
+
+		//DEFINE_PROPERTY2(winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator>, PrimaryButtonKeyboardAccelerators);
+		//DEFINE_PROPERTY2(winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator>, SecondaryButtonKeyboardAccelerators);
+		//DEFINE_PROPERTY2(winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator>, CloseButtonKeyboardAccelerators);
+
+	//	DEFINE_PROPERTY2(Microsoft::UI::Xaml::Media::Imaging::BitmapImage, HeaderImage);
+		//DEFINE_PROPERTY(winrt::hstring, HeaderImageUri);
+
+
+	private:
+		bool m_hasTitleBar = true;
+		bool m_isResizable;
+
+		winrt::hstring m_HeaderImageUri;
+
+		Microsoft::UI::Xaml::Media::Imaging::BitmapImage m_HeaderImage{ nullptr };
+
+		//WinUI3Package::ContentDialogContent content{ nullptr };;
+
+		//winrt::Windows::Foundation::IInspectable m_DialogContent{ nullptr };
+
+		Microsoft::UI::Windowing::OverlappedPresenter _presenter{ nullptr };
+
+		Microsoft::UI::Xaml::Window _parent{ nullptr };
+
+		bool _center;
+
+
+		Microsoft::UI::Xaml::Controls::ContentDialogResult _Result;
+
+		winrt::event<Windows::Foundation::TypedEventHandler<WinUI3Package::ContentDialogWindow, Windows::Foundation::IInspectable>> m_Loaded;
+		winrt::event<Windows::Foundation::TypedEventHandler<WinUI3Package::ContentDialogWindow, Windows::Foundation::IInspectable>> m_Opened;
+
+		winrt::event<Windows::Foundation::TypedEventHandler<Windows::Foundation::IInspectable, Microsoft::UI::Xaml::Input::RightTappedRoutedEventArgs>> m_ContentRightTapped;
+
+
+		winrt::event<Windows::Foundation::TypedEventHandler<WinUI3Package::ContentDialogWindow, WinUI3Package::ContentDialogWindowButtonClickEventArgs>> m_PrimaryButtonClick;
+		winrt::event<Windows::Foundation::TypedEventHandler<WinUI3Package::ContentDialogWindow, WinUI3Package::ContentDialogWindowButtonClickEventArgs>> m_SecondaryButtonClick;
+		winrt::event<Windows::Foundation::TypedEventHandler<WinUI3Package::ContentDialogWindow, WinUI3Package::ContentDialogWindowButtonClickEventArgs>> m_CloseButtonClick;
+
+
+		//public event TypedEventHandler<ContentDialogWindow, ContentDialogWindowButtonClickEventArgs>? PrimaryButtonClick;
+
+		winrt::event_token m_OnParentClosed;
+
+		winrt::event_token m_OnPrimaryButtonClick;
+		winrt::event_token m_OnSecondaryButtonClick;
+		winrt::event_token m_OnCloseButtonClick;
+
+
+		//winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> m_PrimaryButtonKeyboardAccelerators{ nullptr };
+		//winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> m_SecondaryButtonKeyboardAccelerators{ nullptr };
+		//winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> m_CloseButtonKeyboardAccelerators{ nullptr };
+		winrt::event_token m_Closing;
+		winrt::event_token m_Closed;
+		winrt::event_token m_Activated;
+		winrt::event_token m_ImageOpened;
+
+		winrt::event_token m_ActualThemeChanged;
+
+		WinUI3Package::WinUIAsyncEventArgs AsyncEventArgs;
+		winrt::Windows::Foundation::Deferral Deferral{ nullptr };
+		//TypedEventHandler<ContentDialogWindow, EventArgs> Loaded;
+		//TypedEventHandler<ContentDialogWindow, EventArgs> Opened;
+		//winrt::event<Microsoft::UI::Xaml::Data::PropertyChangedEventHandler> m_propertyChanged;
+	};
+}
+
+namespace winrt::WinUI3Package::factory_implementation
+{
+    struct ContentDialogWindow : ContentDialogWindowT<ContentDialogWindow, implementation::ContentDialogWindow>
+    {
+    };
+}
diff --git a/WinUI3Package/ContentDialogWindowButtonClickEventArgs.cpp b/WinUI3Package/ContentDialogWindowButtonClickEventArgs.cpp
new file mode 100644
index 0000000..3664f04
--- /dev/null
+++ b/WinUI3Package/ContentDialogWindowButtonClickEventArgs.cpp
@@ -0,0 +1,34 @@
+#include "pch.h"
+#include "ContentDialogWindowButtonClickEventArgs.h"
+#if __has_include("ContentDialogWindowButtonClickEventArgs.g.cpp")
+#include "ContentDialogWindowButtonClickEventArgs.g.cpp"
+#endif
+
+namespace winrt::WinUI3Package::implementation
+{
+	ContentDialogWindowButtonClickEventArgs::ContentDialogWindowButtonClickEventArgs() {
+
+		Cancel(false);
+		Handled(false);
+	}
+
+	bool ContentDialogWindowButtonClickEventArgs::Cancel()
+	{
+		return m_Cancel;
+	}
+
+	void ContentDialogWindowButtonClickEventArgs::Cancel(bool Value)
+	{
+		m_Cancel = Value;
+	}
+
+	bool ContentDialogWindowButtonClickEventArgs::Handled()
+	{
+		return m_Handled;
+	}
+
+	void ContentDialogWindowButtonClickEventArgs::Handled(bool Value)
+	{
+		m_Handled = Value;
+	}
+}
diff --git a/WinUI3Package/ContentDialogWindowButtonClickEventArgs.h b/WinUI3Package/ContentDialogWindowButtonClickEventArgs.h
new file mode 100644
index 0000000..229c474
--- /dev/null
+++ b/WinUI3Package/ContentDialogWindowButtonClickEventArgs.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "ContentDialogWindowButtonClickEventArgs.g.h"
+
+namespace winrt::WinUI3Package::implementation
+{
+	struct ContentDialogWindowButtonClickEventArgs : ContentDialogWindowButtonClickEventArgsT<ContentDialogWindowButtonClickEventArgs>,
+		deferrable_event_args<ContentDialogWindowButtonClickEventArgs>
+	{
+		ContentDialogWindowButtonClickEventArgs();
+
+
+		bool Cancel();
+		void Cancel(bool Value);
+
+		bool Handled();
+		void Handled(bool Value);
+
+	private:
+		bool m_Cancel{};
+		bool m_Handled{};
+	};
+}
+
+namespace winrt::WinUI3Package::factory_implementation
+{
+    struct ContentDialogWindowButtonClickEventArgs : ContentDialogWindowButtonClickEventArgsT<ContentDialogWindowButtonClickEventArgs, implementation::ContentDialogWindowButtonClickEventArgs>
+    {
+    };
+}
diff --git a/WinUI3Package/ContentDialogWindowButtonClickEventArgs.idl b/WinUI3Package/ContentDialogWindowButtonClickEventArgs.idl
new file mode 100644
index 0000000..4a7ed2d
--- /dev/null
+++ b/WinUI3Package/ContentDialogWindowButtonClickEventArgs.idl
@@ -0,0 +1,17 @@
+namespace WinUI3Package
+{
+    [bindable]
+    [default_interface]
+    runtimeclass ContentDialogWindowButtonClickEventArgs 
+    {
+        ContentDialogWindowButtonClickEventArgs();
+
+
+        Windows.Foundation.Deferral GetDeferral();
+
+        Windows.Foundation.IAsyncAction wait_for_deferrals();
+
+        Boolean Cancel{ get; set; };
+        Boolean Handled{ get; set; };
+    }
+}
diff --git a/WinUI3Package/Underlay.idl b/WinUI3Package/Underlay.idl
new file mode 100644
index 0000000..f8d7baa
--- /dev/null
+++ b/WinUI3Package/Underlay.idl
@@ -0,0 +1,24 @@
+namespace WinUI3Package
+{
+
+    enum UnderlayCoverMode
+    {
+        ClientArea,
+        Full
+    };
+
+    enum UnderlayMode
+    {
+        None,
+        SmokeLayer,
+        SystemBackdrop
+    };
+
+    enum WindowedContentDialogSmokeLayerKind
+    {
+        None = 0,
+        Darken = 1,
+        Custom = -1
+    };
+
+}
\ No newline at end of file
diff --git a/WinUI3Package/UnderlaySmokeLayerOptions.cpp b/WinUI3Package/UnderlaySmokeLayerOptions.cpp
new file mode 100644
index 0000000..ef7f0ce
--- /dev/null
+++ b/WinUI3Package/UnderlaySmokeLayerOptions.cpp
@@ -0,0 +1,19 @@
+#include "pch.h"
+#include "UnderlaySmokeLayerOptions.h"
+#if __has_include("UnderlaySmokeLayerOptions.g.cpp")
+#include "UnderlaySmokeLayerOptions.g.cpp"
+#endif
+
+namespace winrt::WinUI3Package::implementation
+{
+	UnderlaySmokeLayerOptions::UnderlaySmokeLayerOptions() {
+
+		SmokeLayerKind(WinUI3Package::WindowedContentDialogSmokeLayerKind::Darken);
+
+
+		auto Transition = Microsoft::UI::Xaml::ScalarTransition();
+		Transition.Duration(std::chrono::milliseconds(250));
+
+		OpacityTransition(Transition);
+	}
+}
diff --git a/WinUI3Package/UnderlaySmokeLayerOptions.h b/WinUI3Package/UnderlaySmokeLayerOptions.h
new file mode 100644
index 0000000..a2d77e3
--- /dev/null
+++ b/WinUI3Package/UnderlaySmokeLayerOptions.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "UnderlaySmokeLayerOptions.g.h"
+#include "include/cppwinrt_utils.h"
+
+namespace winrt::WinUI3Package::implementation
+{
+    struct UnderlaySmokeLayerOptions : UnderlaySmokeLayerOptionsT<UnderlaySmokeLayerOptions>
+    {
+        UnderlaySmokeLayerOptions();
+
+
+		DEFINE_PROPERTY(WinUI3Package::WindowedContentDialogSmokeLayerKind, SmokeLayerKind);
+		DEFINE_PROPERTY2(Microsoft::UI::Xaml::UIElement, CustomSmokeLayer);
+		DEFINE_PROPERTY(Microsoft::UI::Xaml::ScalarTransition, OpacityTransition);
+    };
+}
+
+namespace winrt::WinUI3Package::factory_implementation
+{
+    struct UnderlaySmokeLayerOptions : UnderlaySmokeLayerOptionsT<UnderlaySmokeLayerOptions, implementation::UnderlaySmokeLayerOptions>
+    {
+    };
+}
diff --git a/WinUI3Package/UnderlaySmokeLayerOptions.idl b/WinUI3Package/UnderlaySmokeLayerOptions.idl
new file mode 100644
index 0000000..d793ed8
--- /dev/null
+++ b/WinUI3Package/UnderlaySmokeLayerOptions.idl
@@ -0,0 +1,15 @@
+import "Underlay.idl";
+
+namespace WinUI3Package
+{
+    [bindable]
+    [default_interface]
+    runtimeclass UnderlaySmokeLayerOptions 
+    {
+        UnderlaySmokeLayerOptions();
+
+        WinUI3Package.WindowedContentDialogSmokeLayerKind SmokeLayerKind;
+        Microsoft.UI.Xaml.UIElement CustomSmokeLayer;
+        Microsoft.UI.Xaml.ScalarTransition OpacityTransition;
+    }
+}
diff --git a/WinUI3Package/UnderlaySystemBackdropOptions.cpp b/WinUI3Package/UnderlaySystemBackdropOptions.cpp
new file mode 100644
index 0000000..e77fcda
--- /dev/null
+++ b/WinUI3Package/UnderlaySystemBackdropOptions.cpp
@@ -0,0 +1,18 @@
+#include "pch.h"
+#include "UnderlaySystemBackdropOptions.h"
+#if __has_include("UnderlaySystemBackdropOptions.g.cpp")
+#include "UnderlaySystemBackdropOptions.g.cpp"
+#endif
+
+namespace winrt::WinUI3Package::implementation
+{
+	UnderlaySystemBackdropOptions::UnderlaySystemBackdropOptions() {
+
+		CoverMode(winrt::WinUI3Package::UnderlayCoverMode::ClientArea);
+
+		auto Transition = Microsoft::UI::Xaml::ScalarTransition();
+		Transition.Duration(std::chrono::milliseconds(150));
+
+		OpacityTransition(Transition);
+	}
+}
diff --git a/WinUI3Package/UnderlaySystemBackdropOptions.h b/WinUI3Package/UnderlaySystemBackdropOptions.h
new file mode 100644
index 0000000..2f49717
--- /dev/null
+++ b/WinUI3Package/UnderlaySystemBackdropOptions.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "UnderlaySystemBackdropOptions.g.h"
+
+#include "include/cppwinrt_utils.h"
+
+namespace winrt::WinUI3Package::implementation
+{
+    struct UnderlaySystemBackdropOptions : UnderlaySystemBackdropOptionsT<UnderlaySystemBackdropOptions>
+    {
+        UnderlaySystemBackdropOptions();
+
+
+		DEFINE_PROPERTY(WinUI3Package::UnderlayCoverMode, CoverMode);
+		DEFINE_PROPERTY(winrt::Microsoft::UI::Xaml::ScalarTransition, OpacityTransition);
+    };
+}
+
+namespace winrt::WinUI3Package::factory_implementation
+{
+    struct UnderlaySystemBackdropOptions : UnderlaySystemBackdropOptionsT<UnderlaySystemBackdropOptions, implementation::UnderlaySystemBackdropOptions>
+    {
+    };
+}
diff --git a/WinUI3Package/UnderlaySystemBackdropOptions.idl b/WinUI3Package/UnderlaySystemBackdropOptions.idl
new file mode 100644
index 0000000..a04e695
--- /dev/null
+++ b/WinUI3Package/UnderlaySystemBackdropOptions.idl
@@ -0,0 +1,14 @@
+import "Underlay.idl";
+
+namespace WinUI3Package
+{
+    [bindable]
+    [default_interface]
+    runtimeclass UnderlaySystemBackdropOptions 
+    {
+        UnderlaySystemBackdropOptions();
+
+        WinUI3Package.UnderlayCoverMode  CoverMode;
+        Microsoft.UI.Xaml.ScalarTransition OpacityTransition;
+    }
+}
diff --git a/WinUI3Package/WinUI3Package.vcxproj b/WinUI3Package/WinUI3Package.vcxproj
index 35d28b5..6fdc7b0 100644
--- a/WinUI3Package/WinUI3Package.vcxproj
+++ b/WinUI3Package/WinUI3Package.vcxproj
@@ -293,6 +293,19 @@
       <DependentUpon>ContainerToBoolConverter.idl</DependentUpon>
       <SubType>Code</SubType>
     </ClInclude>
+    <ClInclude Include="ContentDialogContent.h">
+      <DependentUpon>ContentDialogContent.idl</DependentUpon>
+      <SubType>Code</SubType>
+    </ClInclude>
+    <ClInclude Include="ContentDialogUtils.h" />
+    <ClInclude Include="ContentDialogWindow.xaml.h">
+      <DependentUpon>ContentDialogWindow.xaml</DependentUpon>
+      <SubType>Code</SubType>
+    </ClInclude>
+    <ClInclude Include="ContentDialogWindowButtonClickEventArgs.h">
+      <DependentUpon>ContentDialogWindowButtonClickEventArgs.idl</DependentUpon>
+      <SubType>Code</SubType>
+    </ClInclude>
     <ClInclude Include="ControlSizeTrigger.h">
       <DependentUpon>ControlSizeTrigger.idl</DependentUpon>
       <SubType>Code</SubType>
@@ -354,6 +367,7 @@
     <ClInclude Include="IconUtils.h" />
     <ClInclude Include="include\BadgeGlyphs.hpp" />
     <ClInclude Include="include\BuiltInUris.hpp" />
+    <ClInclude Include="include\cppwinrt_utils.h" />
     <ClInclude Include="include\DependentValue.h">
       <DependentUpon>include\DependentValue.idl</DependentUpon>
       <SubType>Code</SubType>
@@ -556,6 +570,14 @@
       <DependentUpon>UIElementExtension.idl</DependentUpon>
       <SubType>Code</SubType>
     </ClInclude>
+    <ClInclude Include="UnderlaySmokeLayerOptions.h">
+      <DependentUpon>UnderlaySmokeLayerOptions.idl</DependentUpon>
+      <SubType>Code</SubType>
+    </ClInclude>
+    <ClInclude Include="UnderlaySystemBackdropOptions.h">
+      <DependentUpon>UnderlaySystemBackdropOptions.idl</DependentUpon>
+      <SubType>Code</SubType>
+    </ClInclude>
     <ClInclude Include="UnsupportedImageTypeError.hpp" />
     <ClInclude Include="UxThemeWrapper.h" />
     <ClInclude Include="VersionInfo.h">
@@ -571,11 +593,19 @@
       <SubType>Code</SubType>
     </ClInclude>
     <ClInclude Include="WindowContextMenuUtils.h" />
+    <ClInclude Include="WindowedContentDialog.h">
+      <DependentUpon>WindowedContentDialog.idl</DependentUpon>
+      <SubType>Code</SubType>
+    </ClInclude>
     <ClInclude Include="WindowEx.h">
       <DependentUpon>WindowEx.idl</DependentUpon>
       <SubType>Code</SubType>
     </ClInclude>
     <ClInclude Include="WindowsVersion.hpp" />
+    <ClInclude Include="WinUIAsyncEventArgs.h">
+      <DependentUpon>WinUIAsyncEventArgs.idl</DependentUpon>
+      <SubType>Code</SubType>
+    </ClInclude>
     <ClInclude Include="WinUIEssentialError.hpp" />
     <ClInclude Include="WrapPanel.h">
       <DependentUpon>WrapPanel.idl</DependentUpon>
@@ -619,6 +649,18 @@
       <DependentUpon>ContainerToBoolConverter.idl</DependentUpon>
       <SubType>Code</SubType>
     </ClCompile>
+    <ClCompile Include="ContentDialogContent.cpp">
+      <DependentUpon>ContentDialogContent.idl</DependentUpon>
+      <SubType>Code</SubType>
+    </ClCompile>
+    <ClCompile Include="ContentDialogWindow.xaml.cpp">
+      <DependentUpon>ContentDialogWindow.xaml</DependentUpon>
+      <SubType>Code</SubType>
+    </ClCompile>
+    <ClCompile Include="ContentDialogWindowButtonClickEventArgs.cpp">
+      <DependentUpon>ContentDialogWindowButtonClickEventArgs.idl</DependentUpon>
+      <SubType>Code</SubType>
+    </ClCompile>
     <ClCompile Include="ControlSizeTrigger.cpp">
       <DependentUpon>ControlSizeTrigger.idl</DependentUpon>
       <SubType>Code</SubType>
@@ -850,6 +892,14 @@
       <DependentUpon>UIElementExtension.idl</DependentUpon>
       <SubType>Code</SubType>
     </ClCompile>
+    <ClCompile Include="UnderlaySmokeLayerOptions.cpp">
+      <DependentUpon>UnderlaySmokeLayerOptions.idl</DependentUpon>
+      <SubType>Code</SubType>
+    </ClCompile>
+    <ClCompile Include="UnderlaySystemBackdropOptions.cpp">
+      <DependentUpon>UnderlaySystemBackdropOptions.idl</DependentUpon>
+      <SubType>Code</SubType>
+    </ClCompile>
     <ClCompile Include="VersionInfo.cpp">
       <DependentUpon>VersionInfo.idl</DependentUpon>
       <SubType>Code</SubType>
@@ -863,10 +913,18 @@
       <SubType>Code</SubType>
     </ClCompile>
     <ClCompile Include="WindowContextMenuUtils.cpp" />
+    <ClCompile Include="WindowedContentDialog.cpp">
+      <DependentUpon>WindowedContentDialog.idl</DependentUpon>
+      <SubType>Code</SubType>
+    </ClCompile>
     <ClCompile Include="WindowEx.cpp">
       <DependentUpon>WindowEx.idl</DependentUpon>
       <SubType>Code</SubType>
     </ClCompile>
+    <ClCompile Include="WinUIAsyncEventArgs.cpp">
+      <DependentUpon>WinUIAsyncEventArgs.idl</DependentUpon>
+      <SubType>Code</SubType>
+    </ClCompile>
     <ClCompile Include="WrapPanel.cpp">
       <DependentUpon>WrapPanel.idl</DependentUpon>
       <SubType>Code</SubType>
@@ -907,6 +965,16 @@
     <Midl Include="ContainerToBoolConverter.idl">
       <SubType>Designer</SubType>
     </Midl>
+    <Midl Include="ContentDialogContent.idl">
+      <SubType>Designer</SubType>
+    </Midl>
+    <Midl Include="ContentDialogWindow.idl">
+      <DependentUpon>ContentDialogWindow.xaml</DependentUpon>
+      <SubType>Code</SubType>
+    </Midl>
+    <Midl Include="ContentDialogWindowButtonClickEventArgs.idl">
+      <SubType>Designer</SubType>
+    </Midl>
     <Midl Include="ControlSizeTrigger.idl">
       <SubType>Designer</SubType>
     </Midl>
@@ -1069,6 +1137,13 @@
     <Midl Include="UIElementExtension.idl">
       <SubType>Designer</SubType>
     </Midl>
+    <Midl Include="Underlay.idl" />
+    <Midl Include="UnderlaySmokeLayerOptions.idl">
+      <SubType>Designer</SubType>
+    </Midl>
+    <Midl Include="UnderlaySystemBackdropOptions.idl">
+      <SubType>Designer</SubType>
+    </Midl>
     <Midl Include="VersionInfo.idl">
       <SubType>Designer</SubType>
     </Midl>
@@ -1078,14 +1153,24 @@
     <Midl Include="WindowContextMenu.idl">
       <SubType>Designer</SubType>
     </Midl>
+    <Midl Include="WindowedContentDialog.idl">
+      <SubType>Designer</SubType>
+    </Midl>
     <Midl Include="WindowEx.idl">
       <SubType>Designer</SubType>
     </Midl>
+    <Midl Include="WinUIAsyncEventArgs.idl">
+      <SubType>Designer</SubType>
+    </Midl>
     <Midl Include="WrapPanel.idl">
       <SubType>Designer</SubType>
     </Midl>
   </ItemGroup>
   <ItemGroup>
+    <Page Include="ContentDialogContent_Resource.xaml" />
+    <Page Include="ContentDialogWindow.xaml">
+      <SubType>Designer</SubType>
+    </Page>
     <Page Include="FlyoutWindow.xaml">
       <SubType>Designer</SubType>
     </Page>
diff --git a/WinUI3Package/WinUI3Package.vcxproj.filters b/WinUI3Package/WinUI3Package.vcxproj.filters
index 264a454..b6c4944 100644
--- a/WinUI3Package/WinUI3Package.vcxproj.filters
+++ b/WinUI3Package/WinUI3Package.vcxproj.filters
@@ -219,6 +219,12 @@
     <ClInclude Include="Shimmer.DefaultGradientColor.h">
       <Filter>Controls\Shimmer</Filter>
     </ClInclude>
+    <ClInclude Include="include\cppwinrt_utils.h">
+      <Filter>include</Filter>
+    </ClInclude>
+    <ClInclude Include="ContentDialogUtils.h">
+      <Filter>Controls\WindowedContentDialog</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="WinUI3Package.def" />
@@ -315,6 +321,9 @@
     <Filter Include="Controls\Helpers">
       <UniqueIdentifier>{1e6dcb42-f11c-454a-ba47-4d5dc1735958}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Controls\WindowedContentDialog">
+      <UniqueIdentifier>{25cd8eb6-3fd6-476a-a500-4a3441f22f88}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <Midl Include="Placeholder.idl" />
@@ -499,8 +508,26 @@
     <Midl Include="ToolTipHelper.idl">
       <Filter>Controls\Helpers</Filter>
     </Midl>
-    <Midl Include="WindowBackgroundHelper.idl">
-      <Filter>Windows</Filter>
+    <Midl Include="ContentDialogWindowButtonClickEventArgs.idl">
+      <Filter>Controls\WindowedContentDialog</Filter>
+    </Midl>
+    <Midl Include="ContentDialogContent.idl">
+      <Filter>Controls\WindowedContentDialog</Filter>
+    </Midl>
+    <Midl Include="WinUIAsyncEventArgs.idl">
+      <Filter>Controls\WindowedContentDialog</Filter>
+    </Midl>
+    <Midl Include="Underlay.idl">
+      <Filter>Controls\WindowedContentDialog</Filter>
+    </Midl>
+    <Midl Include="UnderlaySmokeLayerOptions.idl">
+      <Filter>Controls\WindowedContentDialog</Filter>
+    </Midl>
+    <Midl Include="UnderlaySystemBackdropOptions.idl">
+      <Filter>Controls\WindowedContentDialog</Filter>
+    </Midl>
+    <Midl Include="WindowedContentDialog.idl">
+      <Filter>Controls\WindowedContentDialog</Filter>
     </Midl>
   </ItemGroup>
   <ItemGroup>
@@ -540,8 +567,11 @@
     <Page Include="Shimmer_Resource.xaml">
       <Filter>Controls\Shimmer</Filter>
     </Page>
-  </ItemGroup>
-  <ItemGroup>
-    <Natvis Include="$(MSBuildThisFileDirectory)..\..\natvis\wil.natvis" />
+    <Page Include="ContentDialogWindow.xaml">
+      <Filter>Controls\WindowedContentDialog</Filter>
+    </Page>
+    <Page Include="ContentDialogContent_Resource.xaml">
+      <Filter>Controls\WindowedContentDialog</Filter>
+    </Page>
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/WinUI3Package/WinUIAsyncEventArgs.cpp b/WinUI3Package/WinUIAsyncEventArgs.cpp
new file mode 100644
index 0000000..b66f9af
--- /dev/null
+++ b/WinUI3Package/WinUIAsyncEventArgs.cpp
@@ -0,0 +1,20 @@
+#include "pch.h"
+#include "WinUIAsyncEventArgs.h"
+#if __has_include("WinUIAsyncEventArgs.g.cpp")
+#include "WinUIAsyncEventArgs.g.cpp"
+#endif
+
+namespace winrt::WinUI3Package::implementation
+{
+ 
+	bool WinUIAsyncEventArgs::Cancel()
+	{
+		return m_Cancel;
+	}
+
+	void WinUIAsyncEventArgs::Cancel(bool Value)
+	{
+		m_Cancel = Value;
+	}
+
+}
diff --git a/WinUI3Package/WinUIAsyncEventArgs.h b/WinUI3Package/WinUIAsyncEventArgs.h
new file mode 100644
index 0000000..42d5d73
--- /dev/null
+++ b/WinUI3Package/WinUIAsyncEventArgs.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "WinUIAsyncEventArgs.g.h"
+
+namespace winrt::WinUI3Package::implementation
+{
+    struct WinUIAsyncEventArgs : WinUIAsyncEventArgsT<WinUIAsyncEventArgs>, winrt::deferrable_event_args<WinUIAsyncEventArgs>
+    {
+        WinUIAsyncEventArgs() = default;
+
+
+        bool Cancel();
+        void Cancel(bool Value);
+
+
+
+    private:
+
+        bool m_Cancel{};
+    };
+}
+
+namespace winrt::WinUI3Package::factory_implementation
+{
+    struct WinUIAsyncEventArgs : WinUIAsyncEventArgsT<WinUIAsyncEventArgs, implementation::WinUIAsyncEventArgs>
+    {
+    };
+}
diff --git a/WinUI3Package/WinUIAsyncEventArgs.idl b/WinUI3Package/WinUIAsyncEventArgs.idl
new file mode 100644
index 0000000..db8d1dc
--- /dev/null
+++ b/WinUI3Package/WinUIAsyncEventArgs.idl
@@ -0,0 +1,13 @@
+namespace WinUI3Package
+{
+    [bindable]
+    [default_interface]
+    runtimeclass WinUIAsyncEventArgs 
+    {
+        WinUIAsyncEventArgs();
+
+        Windows.Foundation.Deferral GetDeferral();
+        Windows.Foundation.IAsyncAction wait_for_deferrals();
+        Boolean Cancel;
+    }
+}
diff --git a/WinUI3Package/WindowedContentDialog.cpp b/WinUI3Package/WindowedContentDialog.cpp
new file mode 100644
index 0000000..2db6c34
--- /dev/null
+++ b/WinUI3Package/WindowedContentDialog.cpp
@@ -0,0 +1,611 @@
+#include "pch.h"
+#include "WindowedContentDialog.h"
+#if __has_include("WindowedContentDialog.g.cpp")
+#include "WindowedContentDialog.g.cpp"
+#endif
+
+
+#include <winrt/Microsoft.UI.Windowing.h>
+
+#include "ContentDialogUtils.h"
+
+namespace winrt::WinUI3Package::implementation
+{
+
+
+
+	winrt::Microsoft::UI::Xaml::DependencyProperty WindowedContentDialog::_IsPrimaryButtonEnabledProperty =
+		winrt::Microsoft::UI::Xaml::DependencyProperty::Register(
+			L"IsPrimaryButtonEnabled",
+			xaml_typename<bool>(),
+			xaml_typename<WinUI3Package::WindowedContentDialog>(),
+			winrt::Microsoft::UI::Xaml::PropertyMetadata{ nullptr, OnIsPrimaryButtonEnabledChangedStatic });
+
+	winrt::Microsoft::UI::Xaml::DependencyProperty WindowedContentDialog::_IsSecondaryButtonEnabledProperty =
+		winrt::Microsoft::UI::Xaml::DependencyProperty::Register(
+			L"IsSecondaryButtonEnabled",
+			xaml_typename<bool>(),
+			xaml_typename<WinUI3Package::WindowedContentDialog>(),
+			winrt::Microsoft::UI::Xaml::PropertyMetadata{ nullptr, OnIsSecondaryButtonEnabledChangedStatic });
+
+	winrt::Microsoft::UI::Xaml::DependencyProperty WindowedContentDialog::_ContentFlowDirectionProperty =
+		winrt::Microsoft::UI::Xaml::DependencyProperty::Register(
+			L"ContentFlowDirection",
+			xaml_typename<winrt::Microsoft::UI::Xaml::FlowDirection>(),
+			xaml_typename<WinUI3Package::WindowedContentDialog>(),
+			winrt::Microsoft::UI::Xaml::PropertyMetadata{
+				winrt::box_value(winrt::Microsoft::UI::Xaml::FlowDirection::LeftToRight),
+				[](winrt::Microsoft::UI::Xaml::DependencyObject const& obj, winrt::Microsoft::UI::Xaml::DependencyPropertyChangedEventArgs const& args)
+				{
+					auto self = winrt::get_self<WindowedContentDialog>(obj.as<WinUI3Package::WindowedContentDialog>());
+
+					auto m_ContentDialogContent = self->m_ContentDialogWindow.ContentDialogContent();
+
+					if (m_ContentDialogContent) {
+
+						m_ContentDialogContent.FlowDirection(args.NewValue().as<winrt::Microsoft::UI::Xaml::FlowDirection>());
+					}
+				}
+			}
+		);
+
+	winrt::Microsoft::UI::Xaml::DependencyProperty WindowedContentDialog::_ContentMinWidthProperty =
+		winrt::Microsoft::UI::Xaml::DependencyProperty::Register(
+			L"ContentMinWidth",
+			xaml_typename<double>(),
+			xaml_typename<WinUI3Package::WindowedContentDialog>(),
+			winrt::Microsoft::UI::Xaml::PropertyMetadata{
+				winrt::box_value(double(320.0f)),
+				[](winrt::Microsoft::UI::Xaml::DependencyObject const& obj, winrt::Microsoft::UI::Xaml::DependencyPropertyChangedEventArgs const& args)
+				{
+					auto self = winrt::get_self<WindowedContentDialog>(obj.as<WinUI3Package::WindowedContentDialog>());
+
+					auto m_ContentDialogContent = self->m_ContentDialogWindow.ContentDialogContent();
+
+					if (m_ContentDialogContent) {
+
+						m_ContentDialogContent.MinWidth(args.NewValue().as<double>());
+					}
+				}
+			}
+		);
+
+
+	WindowedContentDialog::WindowedContentDialog() {
+
+
+		m_ContentDialogWindow = WinUI3Package::ContentDialogWindow();
+
+		IsPrimaryButtonEnabled(true);
+		IsSecondaryButtonEnabled(true);
+
+		RequestedTheme(Microsoft::UI::Xaml::ElementTheme::Default);
+		//SystemBackdrop(Microsoft::UI::Xaml::Media::MicaBackdrop());
+
+		//BackdropType(WinUI3Package::BackdropType::Mica);
+
+		PrimaryButtonText(L"");
+		SecondaryButtonText(L"");
+		CloseButtonText(L"");
+
+		Underlay(WinUI3Package::UnderlayMode::SmokeLayer);
+
+		UnderlaySystemBackdrop(WinUI3Package::UnderlaySystemBackdropOptions());
+		//UnderlaySmokeLayer(WinUI3Package::UnderlaySmokeLayerOptions());
+
+		CenterInParent(true);
+
+
+		PrimaryButtonStyle(ContentDialogUtils::DefaultButtonStyle());
+		SecondaryButtonStyle(ContentDialogUtils::DefaultButtonStyle());
+		CloseButtonStyle(ContentDialogUtils::DefaultButtonStyle());
+		HasTitleBar(true);
+
+	}
+
+	WindowedContentDialog::~WindowedContentDialog() {
+
+
+		//Close();
+
+		if (OwnerWindow()) OwnerWindow().SizeChanged(m_OnOwnerWindowSizeChanged);
+
+		OwnerWindow(nullptr);
+	}
+
+	void WindowedContentDialog::Close()
+	{
+		if (m_ContentDialogWindow) {
+
+			m_ContentDialogWindow.Close();
+			m_ContentDialogWindow = nullptr;
+		}
+
+	}
+
+	void WindowedContentDialog::InitializeContentDialogWindow()
+	{
+
+		if (HeaderImage()) m_ContentDialogWindow.HeaderImage(HeaderImage());
+		if (!HeaderImageUri().empty()) m_ContentDialogWindow.HeaderImageUri(HeaderImageUri());
+
+		m_ContentDialogWindow.Title(WindowTitle());
+		m_ContentDialogWindow.DialogTitle(Title());
+		m_ContentDialogWindow.DialogContent(Content());
+		m_ContentDialogWindow.HasTitleBar(HasTitleBar());
+		m_ContentDialogWindow.IsResizable(IsResizable());
+
+		m_ContentDialogWindow.TitleTemplate(TitleTemplate());
+		m_ContentDialogWindow.ContentTemplate(ContentTemplate());
+
+
+		m_ContentDialogWindow.PrimaryButtonText(PrimaryButtonText());
+		m_ContentDialogWindow.SecondaryButtonText(SecondaryButtonText());
+		m_ContentDialogWindow.CloseButtonText(CloseButtonText());
+		m_ContentDialogWindow.DefaultButton(DefaultButton());
+		m_ContentDialogWindow.IsPrimaryButtonEnabled(IsPrimaryButtonEnabled());
+		m_ContentDialogWindow.IsSecondaryButtonEnabled(IsSecondaryButtonEnabled());
+
+		m_ContentDialogWindow.PrimaryButtonStyle(PrimaryButtonStyle());
+		m_ContentDialogWindow.SecondaryButtonStyle(SecondaryButtonStyle());
+		m_ContentDialogWindow.CloseButtonStyle(CloseButtonStyle());
+
+		m_ContentDialogWindow.SystemBackdrop(SystemBackdrop());
+
+		m_ContentDialogWindow.RequestedTheme(RequestedTheme());
+
+
+
+		m_ContentDialogWindow.PrimaryButtonClick([this](auto& sender, auto& args) {
+
+
+			m_PrimaryButtonClick(*this, args);
+
+		});
+		m_ContentDialogWindow.SecondaryButtonClick([this](auto& sender, auto& args) {
+
+
+			m_SecondaryButtonClick(*this, args);
+
+		});
+		m_ContentDialogWindow.CloseButtonClick([this](auto& sender, auto& args) {
+
+
+			m_CloseButtonClick(*this, args);
+
+		});
+
+		//m_ContentDialogWindow.ContentRightTapped();
+
+		m_ContentDialogWindow.ContentRightTapped([this](auto& sender, auto& args) {
+
+
+			m_ContentRightTapped(*this, args);
+
+		});
+
+		//m_ContentDialogWindow.ContentRightTapped({this, &WindowedContentDialog::m_ContentRightTapped });
+
+		//Content().as<winrt::Microsoft::UI::Xaml::UIElement>().RightTapped(winrt::Microsoft::UI::Xaml::Input::RightTappedEventHandler());
+
+		//m_dialogWindow.SecondaryButtonClick({ this, &WindowedContentDialog::m_SecondaryButtonClick });
+		//m_dialogWindow.CloseButtonClick({ this, &WindowedContentDialog::m_CloseButtonClick });
+
+	}
+
+	winrt::Windows::Foundation::IAsyncOperation<winrt::Microsoft::UI::Xaml::Controls::ContentDialogResult> WindowedContentDialog::ShowAsync()
+	{
+		co_return co_await ShowAsync(true);
+	}
+
+	winrt::Windows::Foundation::IAsyncOperation<winrt::Microsoft::UI::Xaml::Controls::ContentDialogResult> WindowedContentDialog::ShowAsync(bool isModal)
+	{
+
+		InitializeContentDialogWindow();
+		m_ContentDialogWindow.SetParent(OwnerWindow(), isModal, CenterInParent());
+		SetUnderlay(m_ContentDialogWindow);
+
+		//winrt::awaitable_event DialogEvent = {};
+
+		winrt::event_token WindowLoadedEvent;
+		winrt::event_token WindowClosedEvent;
+
+		WindowLoadedEvent = m_ContentDialogWindow.Loaded([&](WinUI3Package::ContentDialogWindow const& Window, winrt::Windows::Foundation::IInspectable const& args)
+		{
+
+			m_Loaded(*this, args);
+
+		});
+
+		WindowClosedEvent = m_ContentDialogWindow.Closed([&](Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::WindowEventArgs const& args) ->winrt::Windows::Foundation::IAsyncAction
+		{
+
+			m_Closed(*this, args);
+
+			co_return;
+		});
+
+		auto Result = co_await m_ContentDialogWindow.ShowAsync();;
+
+		//OwnerWindow(nullptr);
+
+		//auto Result = m_ContentDialogWindow.Result();
+
+		m_ContentDialogWindow.Loaded(WindowLoadedEvent);
+		m_ContentDialogWindow.Closed(WindowClosedEvent);
+
+
+		//m_ContentDialogWindow.Opened(m_onPopupOpened);
+		//m_ContentDialogWindow.Loaded(m_onPopupLoaded);
+		//m_ContentDialogWindow.Closed(m_onPopupClosed);
+
+		//if (OwnerWindow()) OwnerWindow().SizeChanged(m_OnOwnerWindowSizeChanged);
+
+		//OwnerWindow(nullptr);
+
+		//m_ContentDialogWindow = nullptr;
+
+		co_return Result;
+
+	}
+
+	void WindowedContentDialog::UpdateWindowSize() {
+
+		//m_dialogWindow.DialogContent();
+
+	}
+
+	void WindowedContentDialog::SetUnderlay(WinUI3Package::ContentDialogWindow const& dialogWindow)
+	{
+
+		if (!OwnerWindow() || !OwnerWindow().Content() || !OwnerWindow().Content().XamlRoot())
+		{
+			return;
+		}
+
+		switch (Underlay())
+		{
+			case UnderlayMode::SmokeLayer:
+				HandleSmokeLayer(dialogWindow);
+				break;
+
+			case UnderlayMode::SystemBackdrop:
+				HandleSystemBackdrop(dialogWindow);
+				break;
+		}
+	}
+
+	void WindowedContentDialog::HandleSmokeLayer(WinUI3Package::ContentDialogWindow const& dialogWindow)
+	{
+
+		if (OwnerWindow() == nullptr || OwnerWindow().Content() == nullptr || OwnerWindow().Content().XamlRoot() == nullptr)
+			return;
+
+		//if (!UnderlaySmokeLayer() ||
+		//	UnderlaySmokeLayer().SmokeLayerKind() == WindowedContentDialogSmokeLayerKind::None)
+		//{
+		//	return;
+		//}
+
+		//DisableOwnerEvents(dialogWindow);
+
+		//Microsoft::UI::Xaml::Controls::Primitives::Popup popup = {};
+
+		m_Popup = Microsoft::UI::Xaml::Controls::Primitives::Popup();
+
+		m_Popup.XamlRoot(OwnerWindow().Content().XamlRoot());
+		m_Popup.RequestedTheme(RequestedTheme());
+
+
+		Microsoft::UI::Xaml::Shapes::Rectangle darkLayer = {};
+		darkLayer.Opacity(0.0);
+		//darkLayer.OpacityTransition(UnderlaySmokeLayer().OpacityTransition());
+
+		auto Transition = Microsoft::UI::Xaml::ScalarTransition();
+		Transition.Duration(std::chrono::milliseconds(250));
+		darkLayer.OpacityTransition(Transition);
+
+		Microsoft::UI::Xaml::Media::SolidColorBrush brush = {};
+		brush.Color(ContentDialogUtils::SmokeFillColor());
+		darkLayer.Fill(brush);
+
+
+		SizeToXamlRoot(darkLayer, OwnerWindow());
+
+		m_Popup.Child(darkLayer);
+		SmokeLayerCache(darkLayer);
+
+
+		dialogWindow.Opened(m_onPopupOpened);
+		m_onPopupOpened = dialogWindow.Opened({ this, &WindowedContentDialog::DialogWindow_Opened });
+
+		dialogWindow.Closed(m_onPopupClosed);
+		m_onPopupClosed = dialogWindow.Closed({ this, &WindowedContentDialog::DialogWindow_Closed });
+
+		//AttachPopupLifecycle(dialogWindow, m_Popup, true);
+	}
+
+	void WindowedContentDialog::HandleSystemBackdrop(WinUI3Package::ContentDialogWindow const& dialogWindow)
+	{
+		//if (UnderlaySystemBackdrop() == nullptr || UnderlaySystemBackdrop().Backdrop() == WinUI3Package::BackdropType::None)
+		//	return;
+
+
+		if (OwnerWindow() == nullptr || OwnerWindow().Content() == nullptr || OwnerWindow().Content().XamlRoot() == nullptr)
+			return;
+
+		//DisableOwnerEvents(dialogWindow);
+
+		// Create the popup with helper
+		m_Popup = ContentDialogUtils::CreatePopup(
+			OwnerWindow().Content().XamlRoot(),
+			UnderlaySystemBackdrop().CoverMode() == UnderlayCoverMode::Full,
+			GetTitleBarOffset());
+
+		// Store the backdrop layer
+		BackdropLayerCache(m_Popup.Child().try_as<Microsoft::UI::Xaml::Controls::Border>());
+		if (BackdropLayerCache())
+		{
+			BackdropLayerCache().OpacityTransition(UnderlaySystemBackdrop().OpacityTransition());
+		}
+
+
+
+		dialogWindow.Loaded(m_onPopupOpened);
+		m_onPopupOpened = dialogWindow.Loaded({ this, &WindowedContentDialog::DialogWindow_Opened });
+
+		dialogWindow.Closed(m_onPopupClosed);
+		m_onPopupClosed = dialogWindow.Closed({ this, &WindowedContentDialog::DialogWindow_Closed });
+
+		//AttachPopupLifecycle(dialogWindow, m_Popup, false);
+	}
+
+	void WindowedContentDialog::DisableOwnerEvents(WinUI3Package::ContentDialogWindow const& dialogWindow)
+	{
+		dialogWindow.Opened(m_DialogWindow_Opened);
+		dialogWindow.Closed(m_DialogWindow_Closed);
+
+		m_DialogWindow_Opened = dialogWindow.Opened({ this, &WindowedContentDialog::DialogWindow_Opened });
+		m_DialogWindow_Closed = dialogWindow.Closed({ this, &WindowedContentDialog::DialogWindow_Closed });
+
+	}
+
+	void WindowedContentDialog::AttachPopupLifecycle(WinUI3Package::ContentDialogWindow const& dialogWindow, Microsoft::UI::Xaml::Controls::Primitives::Popup const& popup, bool isSmokeLayer)
+	{
+
+		//auto OnDialogWindowOpened = [&](WinUI3Package::ContentDialogWindow const& Window, winrt::Windows::Foundation::IInspectable const& args) {
+
+		//	m_Popup.IsOpen(true);
+		//	m_Popup.Child().Opacity(1.0f);
+
+		//	OwnerWindow().SizeChanged(m_OnOwnerWindowSizeChanged);
+		//	m_OnOwnerWindowSizeChanged = OwnerWindow().SizeChanged({ this, &WindowedContentDialog::OnOwnerWindowSizeChanged });
+
+		//};
+
+		//auto DialogWindow_ClosedPopup = [&](Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::WindowEventArgs const& args) ->Windows::Foundation::IAsyncAction {
+
+
+		//	m_Popup.Child().Opacity(0.f);
+
+		//	m_Popup.IsOpen(false);
+
+		//	m_Popup.Child(nullptr);
+
+		//	OwnerWindow().SizeChanged(m_OnOwnerWindowSizeChanged);
+
+		//	co_return;
+		//};
+
+		//if (isSmokeLayer)
+		//{
+		//	dialogWindow.Opened(m_onPopupOpened);
+		//	m_onPopupOpened = dialogWindow.Opened(OnDialogWindowOpened);
+		//}
+		//else {
+
+		//	dialogWindow.Loaded(m_onPopupLoaded);
+		//	m_onPopupLoaded = dialogWindow.Loaded(OnDialogWindowOpened);
+		//}
+
+		//dialogWindow.Closed(m_onPopupClosed);
+		//m_onPopupClosed = dialogWindow.Closed(DialogWindow_ClosedPopup);
+
+
+
+	}
+
+	void WindowedContentDialog::SizeToXamlRoot(Microsoft::UI::Xaml::FrameworkElement element, Microsoft::UI::Xaml::Window window)
+	{
+
+		element.Width(window.Content().XamlRoot().Size().Width);
+
+		switch (Underlay())
+		{
+			case WinUI3Package::UnderlayMode::SmokeLayer:
+				element.Height(window.Content().XamlRoot().Size().Height);
+				break;
+
+			case WinUI3Package::UnderlayMode::SystemBackdrop:
+				element.Height(UnderlaySystemBackdrop().CoverMode() == WinUI3Package::UnderlayCoverMode::Full ? window.Content().XamlRoot().Size().Height : window.Content().XamlRoot().Size().Height - GetTitleBarOffset());
+				break;
+		}
+	}
+
+	int WindowedContentDialog::GetTitleBarOffset()
+	{
+
+		if (!OwnerWindow() || !OwnerWindow().AppWindow() || !OwnerWindow().AppWindow().TitleBar())
+		{
+			return 0;
+		}
+
+		auto heightOption = OwnerWindow().AppWindow().TitleBar().PreferredHeightOption();
+
+		switch (heightOption)
+		{
+			case Microsoft::UI::Windowing::TitleBarHeightOption::Standard:
+				return 32;
+			case Microsoft::UI::Windowing::TitleBarHeightOption::Tall:
+				return 48;
+			default:
+				return 0;
+		}
+	}
+
+	//void WindowedContentDialog::DialogWindow_Loaded(winrt::Windows::Foundation::IInspectable const& sender, winrt::Windows::Foundation::IInspectable const& e)
+	//{
+	//	if (auto popup = sender.try_as<Microsoft::UI::Xaml::Controls::Primitives::Popup>()) {
+
+	//		popup.IsOpen(true);
+	//		popup.Child().Opacity(1.0f);
+	//		m_OnOwnerWindowSizeChanged_Loaded = OwnerWindow().SizeChanged({this, &WindowedContentDialog::OnOwnerWindowSizeChanged});
+	//	
+	//	}
+
+	//}
+
+	void WindowedContentDialog::DialogWindow_Opened(WinUI3Package::ContentDialogWindow const& sender, winrt::Windows::Foundation::IInspectable const& e)
+	{
+
+		m_Popup.IsOpen(true);
+		m_Popup.Child().Opacity(1.0f);
+
+		if (OwnerWindow()) {
+
+			OwnerWindow().SizeChanged(m_OnOwnerWindowSizeChanged);
+			m_OnOwnerWindowSizeChanged = OwnerWindow().SizeChanged({ this, &WindowedContentDialog::OnOwnerWindowSizeChanged });
+		}
+
+
+		/*	if (auto control = OwnerWindow().Content().try_as<Microsoft::UI::Xaml::Controls::Control>())
+				control.IsEnabled(false);*/
+	}
+
+	void WindowedContentDialog::DialogWindow_Closed(winrt::Windows::Foundation::IInspectable const& sender, Microsoft::UI::Xaml::WindowEventArgs const& e)
+	{
+
+
+		m_Popup.Child().Opacity(0.f);
+
+		m_Popup.IsOpen(false);
+
+		m_Popup.Child(nullptr);
+
+		if (OwnerWindow()) OwnerWindow().SizeChanged(m_OnOwnerWindowSizeChanged);
+
+		//if (auto control = OwnerWindow().Content().try_as<Microsoft::UI::Xaml::Controls::Control>())
+		//	control.IsEnabled(true);
+	}
+
+	void WindowedContentDialog::DialogWindow_ClosedPopup(winrt::Windows::Foundation::IInspectable const& sender, Microsoft::UI::Xaml::WindowEventArgs const& e)
+	{
+
+		//if (auto popup = sender.try_as<Microsoft::UI::Xaml::Controls::Primitives::Popup>()) {
+
+		//	popup.Child.Opacity = 0.0;
+		//	await Task.Delay(popup.Child.OpacityTransition ? .Duration ? ? new TimeSpan(0));
+		//	popup.IsOpen = false;
+		//	popup.Child = null;
+		//	OwnerWindow.SizeChanged -= OnOwnerWindowSizeChanged;
+		//}
+	}
+
+	void WindowedContentDialog::OnOwnerWindowSizeChanged(winrt::Windows::Foundation::IInspectable const& sender, Microsoft::UI::Xaml::WindowSizeChangedEventArgs const& args)
+	{
+
+		switch (Underlay())
+		{
+			case WinUI3Package::UnderlayMode::SmokeLayer:
+				SizeToXamlRoot(SmokeLayerCache(), OwnerWindow());
+				break;
+
+			case WinUI3Package::UnderlayMode::SystemBackdrop:
+				SizeToXamlRoot(BackdropLayerCache(), OwnerWindow());
+				break;
+		}
+
+	}
+
+	winrt::event_token WindowedContentDialog::PrimaryButtonClick(Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler)
+	{
+		return m_PrimaryButtonClick.add(handler);
+	}
+
+	void WindowedContentDialog::PrimaryButtonClick(winrt::event_token const& token)
+	{
+		m_PrimaryButtonClick.remove(token);
+	}
+
+	winrt::event_token WindowedContentDialog::SecondaryButtonClick(Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler)
+	{
+		return m_SecondaryButtonClick.add(handler);
+	}
+
+	void WindowedContentDialog::SecondaryButtonClick(winrt::event_token const& token)
+	{
+		m_SecondaryButtonClick.remove(token);
+	}
+
+	winrt::event_token WindowedContentDialog::CloseButtonClick(Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler)
+	{
+		return m_CloseButtonClick.add(handler);
+	}
+
+	void WindowedContentDialog::CloseButtonClick(winrt::event_token const& token)
+	{
+		m_CloseButtonClick.remove(token);
+	}
+
+	winrt::Windows::Foundation::Collections::IVector<winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator> WindowedContentDialog::PrimaryButtonKeyboardAccelerators()
+	{
+		return m_ContentDialogWindow.PrimaryButtonKeyboardAccelerators();
+	}
+
+	winrt::Windows::Foundation::Collections::IVector<winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator> WindowedContentDialog::SecondaryButtonKeyboardAccelerators()
+	{
+		return m_ContentDialogWindow.SecondaryButtonKeyboardAccelerators();
+	}
+
+	winrt::Windows::Foundation::Collections::IVector<winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator> WindowedContentDialog::CloseButtonKeyboardAccelerators()
+	{
+		return m_ContentDialogWindow.CloseButtonKeyboardAccelerators();
+	}
+
+	winrt::event_token WindowedContentDialog::Opened(Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, Windows::Foundation::IInspectable> const& handler)
+	{
+		return m_Loaded.add(handler);
+	}
+
+	void WindowedContentDialog::Opened(winrt::event_token const& token)
+	{
+		m_Loaded.remove(token);
+	}
+
+	winrt::event_token WindowedContentDialog::Closed(Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, Microsoft::UI::Xaml::WindowEventArgs> const& handler)
+	{
+		return m_Closed.add(handler);
+	}
+
+	void WindowedContentDialog::Closed(winrt::event_token const& token)
+	{
+		m_Closed.remove(token);
+	}
+
+	winrt::event_token WindowedContentDialog::ContentRightTapped(Windows::Foundation::TypedEventHandler<Windows::Foundation::IInspectable, winrt::Microsoft::UI::Xaml::Input::RightTappedRoutedEventArgs> const& handler)
+	{
+		return m_ContentRightTapped.add(handler);
+	}
+
+	void WindowedContentDialog::ContentRightTapped(winrt::event_token const& token)
+	{
+		m_ContentRightTapped.remove(token);
+	}
+
+	void WindowedContentDialog::OnContentRightTapped(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::Input::RightTappedRoutedEventArgs const& e)
+	{
+
+	}
+
+
+}
diff --git a/WinUI3Package/WindowedContentDialog.h b/WinUI3Package/WindowedContentDialog.h
new file mode 100644
index 0000000..f95b9d5
--- /dev/null
+++ b/WinUI3Package/WindowedContentDialog.h
@@ -0,0 +1,240 @@
+#pragma once
+
+#include "WindowedContentDialog.g.h"
+
+#include "include/cppwinrt_utils.h"
+
+namespace winrt::WinUI3Package::implementation
+{
+	struct WindowedContentDialog : WindowedContentDialogT<WindowedContentDialog>
+	{
+		WindowedContentDialog();
+		~WindowedContentDialog();
+
+
+		double ContentMinWidth() {
+
+			return winrt::unbox_value<double>(GetValue(ContentMinWidthProperty()));
+
+		}
+
+		void ContentMinWidth(double value)
+		{
+			SetValue(ContentMinWidthProperty(), winrt::box_value(value));
+		}
+
+		static winrt::Microsoft::UI::Xaml::DependencyProperty ContentMinWidthProperty()
+		{
+			return _ContentMinWidthProperty;
+		}
+
+		winrt::Microsoft::UI::Xaml::FlowDirection ContentFlowDirection() {
+
+			return winrt::unbox_value<winrt::Microsoft::UI::Xaml::FlowDirection>(GetValue(ContentFlowDirectionProperty()));
+
+		}
+
+		void ContentFlowDirection(winrt::Microsoft::UI::Xaml::FlowDirection const& value)
+		{
+			SetValue(ContentFlowDirectionProperty(), winrt::box_value(value));
+		}
+
+		static winrt::Microsoft::UI::Xaml::DependencyProperty ContentFlowDirectionProperty()
+		{
+			return _ContentFlowDirectionProperty;
+		}
+
+		void Close();
+
+		void InitializeContentDialogWindow();
+
+		winrt::Windows::Foundation::IAsyncOperation<Microsoft::UI::Xaml::Controls::ContentDialogResult> ShowAsync();
+
+		winrt::Windows::Foundation::IAsyncOperation<Microsoft::UI::Xaml::Controls::ContentDialogResult> ShowAsync(bool isModal);
+
+		WinUI3Package::ContentDialogWindow GetDialogWindow() { return m_ContentDialogWindow; };
+
+		void UpdateWindowSize();
+
+		void SetUnderlay(WinUI3Package::ContentDialogWindow const& dialogWindow);
+
+		void HandleSmokeLayer(WinUI3Package::ContentDialogWindow const& dialogWindow);
+
+		void HandleSystemBackdrop(WinUI3Package::ContentDialogWindow const& dialogWindow);
+
+		void DisableOwnerEvents(WinUI3Package::ContentDialogWindow const& dialogWindow);
+
+		void AttachPopupLifecycle(WinUI3Package::ContentDialogWindow const& dialogWindow, Microsoft::UI::Xaml::Controls::Primitives::Popup const& popup, bool isSmokeLayer);
+
+		void SizeToXamlRoot(Microsoft::UI::Xaml::FrameworkElement element, Microsoft::UI::Xaml::Window window);
+
+		void DialogWindow_Loaded(winrt::Windows::Foundation::IInspectable const& sender, winrt::Windows::Foundation::IInspectable const& e);
+
+		void DialogWindow_Opened(WinUI3Package::ContentDialogWindow const& sender, winrt::Windows::Foundation::IInspectable const& e);
+
+		void DialogWindow_Closed(winrt::Windows::Foundation::IInspectable const& sender, Microsoft::UI::Xaml::WindowEventArgs const& e);
+
+		void DialogWindow_ClosedPopup(winrt::Windows::Foundation::IInspectable const& sender, Microsoft::UI::Xaml::WindowEventArgs const& e);
+
+		void OnOwnerWindowSizeChanged(winrt::Windows::Foundation::IInspectable const& sender, Microsoft::UI::Xaml::WindowSizeChangedEventArgs const& args);
+
+		void OnContentRightTapped(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::Input::RightTappedRoutedEventArgs const& e);
+
+		int GetTitleBarOffset();
+
+		winrt::event_token Opened(Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, Windows::Foundation::IInspectable> const& handler);
+		void Opened(winrt::event_token const& token);
+
+		winrt::event_token Closed(Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, Microsoft::UI::Xaml::WindowEventArgs> const& handler);
+		void Closed(winrt::event_token const& token);
+
+		winrt::event_token ContentRightTapped(Windows::Foundation::TypedEventHandler<Windows::Foundation::IInspectable,  winrt::Microsoft::UI::Xaml::Input::RightTappedRoutedEventArgs> const& handler);
+		void ContentRightTapped(winrt::event_token const& token);
+
+		winrt::event_token PrimaryButtonClick(Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler);
+		void PrimaryButtonClick(winrt::event_token const& token);
+
+		winrt::event_token SecondaryButtonClick(Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler);
+		void SecondaryButtonClick(winrt::event_token const& token);
+
+		winrt::event_token CloseButtonClick(Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler);
+		void CloseButtonClick(winrt::event_token const& token);
+
+		winrt::Windows::Foundation::Collections::IVector< winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator> PrimaryButtonKeyboardAccelerators();
+		winrt::Windows::Foundation::Collections::IVector< winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator> SecondaryButtonKeyboardAccelerators();
+		winrt::Windows::Foundation::Collections::IVector< winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator> CloseButtonKeyboardAccelerators();
+
+
+		static void OnIsPrimaryButtonEnabledChangedStatic(Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::DependencyPropertyChangedEventArgs e)
+		{
+			UNREFERENCED_PARAMETER(sender);
+			UNREFERENCED_PARAMETER(e);
+
+			//winrt::Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, IsEnabled() ? NormalState : DisabledState, true);
+
+			auto self = get_self<WindowedContentDialog>(sender.as<winrt::WinUI3Package::WindowedContentDialog>());
+
+			self->m_ContentDialogWindow.IsPrimaryButtonEnabled(e.NewValue().as<bool>());
+
+		}
+
+
+		static void OnIsSecondaryButtonEnabledChangedStatic(Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::DependencyPropertyChangedEventArgs e)
+		{
+			UNREFERENCED_PARAMETER(sender);
+			UNREFERENCED_PARAMETER(e);
+
+			//winrt::Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, IsEnabled() ? NormalState : DisabledState, true);
+
+			auto self = get_self<WindowedContentDialog>(sender.as<winrt::WinUI3Package::WindowedContentDialog>());
+
+			self->m_ContentDialogWindow.IsSecondaryButtonEnabled(e.NewValue().as<bool>());
+
+		}
+
+
+		DEFINE_PROPERTY2(Microsoft::UI::Xaml::Media::Imaging::BitmapImage, HeaderImage);
+		DEFINE_PROPERTY(winrt::hstring, HeaderImageUri);
+
+		DEFINE_PROPERTY2(Microsoft::UI::Xaml::Shapes::Rectangle, SmokeLayerCache);
+		DEFINE_PROPERTY2(Microsoft::UI::Xaml::Controls::Border, BackdropLayerCache);
+
+		DEFINE_PROPERTY(winrt::hstring, WindowTitle);
+		DEFINE_PROPERTY2(winrt::Windows::Foundation::IInspectable, Title);
+		DEFINE_PROPERTY2(winrt::Windows::Foundation::IInspectable, Content);
+
+		DEFINE_PROPERTY(Microsoft::UI::Xaml::ElementTheme, RequestedTheme);
+
+		DEFINE_PROPERTY2(Microsoft::UI::Xaml::Media::SystemBackdrop, SystemBackdrop);
+
+		// DEFINE_PROPERTY2(Microsoft::UI::Xaml::Media::Brush, Foreground);
+		// DEFINE_PROPERTY2(Microsoft::UI::Xaml::Media::Brush, Background);
+	   //  DEFINE_PROPERTY2(Microsoft::UI::Xaml::Media::Brush, BorderBrush);
+
+		// DEFINE_PROPERTY(Microsoft::UI::Xaml::Thickness, BorderThickness);
+		// DEFINE_PROPERTY(Microsoft::UI::Xaml::FlowDirection, FlowDirection);
+		DEFINE_PROPERTY2(Microsoft::UI::Xaml::DataTemplate, TitleTemplate);
+		DEFINE_PROPERTY2(Microsoft::UI::Xaml::DataTemplate, ContentTemplate);
+
+		DEFINE_PROPERTY(winrt::hstring, PrimaryButtonText);
+		DEFINE_PROPERTY(winrt::hstring, SecondaryButtonText);
+		DEFINE_PROPERTY(winrt::hstring, CloseButtonText);
+
+		//DEFINE_PROPERTY(bool, IsPrimaryButtonEnabled);
+		//DEFINE_PROPERTY(bool, IsSecondaryButtonEnabled);
+
+		DEPENDENCY_PROPERTY(bool, IsPrimaryButtonEnabled);
+		DEPENDENCY_PROPERTY(bool, IsSecondaryButtonEnabled);
+
+		DEFINE_PROPERTY(Microsoft::UI::Xaml::Controls::ContentDialogButton, DefaultButton);
+
+		DEFINE_PROPERTY(WinUI3Package::UnderlayMode, Underlay);
+
+		DEFINE_PROPERTY2(WinUI3Package::UnderlaySystemBackdropOptions, UnderlaySystemBackdrop);
+		//DEFINE_PROPERTY2(WinUI3Package::UnderlaySmokeLayerOptions, UnderlaySmokeLayer);
+
+		DEFINE_PROPERTY(bool, CenterInParent);
+
+
+		DEFINE_PROPERTY2(Microsoft::UI::Xaml::Style, PrimaryButtonStyle);
+		DEFINE_PROPERTY2(Microsoft::UI::Xaml::Style, SecondaryButtonStyle);
+		DEFINE_PROPERTY2(Microsoft::UI::Xaml::Style, CloseButtonStyle);
+
+
+		DEFINE_PROPERTY2(Microsoft::UI::Xaml::Window, OwnerWindow);
+
+		DEFINE_PROPERTY(bool, HasTitleBar);
+		DEFINE_PROPERTY(bool, IsResizable);
+
+
+		//DEFINE_PROPERTY2(winrt::Windows::Foundation::Collections::IVector< winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator>, PrimaryButtonKeyboardAccelerators);
+		//DEFINE_PROPERTY2(winrt::Windows::Foundation::Collections::IVector< winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator>, SecondaryButtonKeyboardAccelerators);
+	   // DEFINE_PROPERTY2(winrt::Windows::Foundation::Collections::IVector< winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator>, CloseButtonKeyboardAccelerators);
+
+
+	private:
+
+		static winrt::Microsoft::UI::Xaml::DependencyProperty _ContentFlowDirectionProperty;
+		static winrt::Microsoft::UI::Xaml::DependencyProperty _ContentMinWidthProperty;
+
+		WinUI3Package::ContentDialogWindow m_ContentDialogWindow{ nullptr };
+
+		Microsoft::UI::Xaml::Controls::Primitives::Popup m_Popup{ nullptr };
+
+
+		winrt::event<Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, Windows::Foundation::IInspectable>> m_Loaded;
+		winrt::event<Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, Microsoft::UI::Xaml::WindowEventArgs>> m_Closed;
+
+		winrt::event<Windows::Foundation::TypedEventHandler<Windows::Foundation::IInspectable,  winrt::Microsoft::UI::Xaml::Input::RightTappedRoutedEventArgs>> m_ContentRightTapped;
+
+
+		winrt::event<Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, WinUI3Package::ContentDialogWindowButtonClickEventArgs>> m_PrimaryButtonClick;
+		winrt::event<Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, WinUI3Package::ContentDialogWindowButtonClickEventArgs>> m_SecondaryButtonClick;
+		winrt::event<Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, WinUI3Package::ContentDialogWindowButtonClickEventArgs>> m_CloseButtonClick;
+
+
+		winrt::event_token m_DialogWindow_Opened;
+		winrt::event_token m_DialogWindow_Closed;
+
+		winrt::event_token m_onPopupLoaded;
+		winrt::event_token m_onPopupOpened;
+		winrt::event_token m_onPopupClosed;
+		// winrt::event_token m_DialogWindow_Loaded;
+		 //winrt::event_token m_DialogWindow_ClosedPopup;
+
+		winrt::event_token m_OnOwnerWindowSizeChanged;
+
+		winrt::event_token m_OnOwnerWindowSizeChanged_Loaded;
+
+
+		winrt::handle m_DialogEvent;
+
+	};
+}
+
+namespace winrt::WinUI3Package::factory_implementation
+{
+    struct WindowedContentDialog : WindowedContentDialogT<WindowedContentDialog, implementation::WindowedContentDialog>
+    {
+    };
+}
diff --git a/WinUI3Package/WindowedContentDialog.idl b/WinUI3Package/WindowedContentDialog.idl
new file mode 100644
index 0000000..a09711d
--- /dev/null
+++ b/WinUI3Package/WindowedContentDialog.idl
@@ -0,0 +1,77 @@
+import "Underlay.idl";
+import "UnderlaySmokeLayerOptions.idl";
+import "UnderlaySystemBackdropOptions.idl";
+import "ContentDialogWindowButtonClickEventArgs.idl";
+import "ContentDialogWindow.idl";
+
+namespace WinUI3Package
+{
+    [bindable]
+    [default_interface]
+    runtimeclass WindowedContentDialog : Microsoft.UI.Xaml.Controls.Control
+    {
+        WindowedContentDialog();
+
+        void Close();
+
+        WinUI3Package.ContentDialogWindow GetDialogWindow();
+
+        void UpdateWindowSize();
+
+        Microsoft.UI.Xaml.Shapes.Rectangle SmokeLayerCache;
+        Microsoft.UI.Xaml.Controls.Border BackdropLayerCache;
+
+        Microsoft.UI.Xaml.Media.Imaging.BitmapImage HeaderImage{ get; set; };
+        String HeaderImageUri{ get; set; };
+
+        String WindowTitle;
+        Object Title;
+        Object Content;
+
+
+        Microsoft.UI.Xaml.Media.SystemBackdrop SystemBackdrop;
+
+        Microsoft.UI.Xaml.DataTemplate TitleTemplate;
+        Microsoft.UI.Xaml.DataTemplate ContentTemplate;
+        String PrimaryButtonText;
+        String SecondaryButtonText;
+        String CloseButtonText;
+        Boolean IsPrimaryButtonEnabled;
+        Boolean IsSecondaryButtonEnabled;
+        Microsoft.UI.Xaml.Controls.ContentDialogButton DefaultButton;
+
+        WinUI3Package.UnderlayMode Underlay;
+        WinUI3Package.UnderlaySystemBackdropOptions UnderlaySystemBackdrop;
+
+        Boolean CenterInParent;
+        Microsoft.UI.Xaml.Style PrimaryButtonStyle;
+        Microsoft.UI.Xaml.Style SecondaryButtonStyle;
+        Microsoft.UI.Xaml.Style CloseButtonStyle;
+        Microsoft.UI.Xaml.Window OwnerWindow;
+        Boolean HasTitleBar;
+        Boolean IsResizable;
+
+        Microsoft.UI.Xaml.FlowDirection ContentFlowDirection;
+
+        Double ContentMinWidth;
+
+
+        Windows.Foundation.Collections.IVector<Microsoft.UI.Xaml.Input.KeyboardAccelerator> PrimaryButtonKeyboardAccelerators{ get; };
+        Windows.Foundation.Collections.IVector<Microsoft.UI.Xaml.Input.KeyboardAccelerator> SecondaryButtonKeyboardAccelerators{ get; };
+        Windows.Foundation.Collections.IVector<Microsoft.UI.Xaml.Input.KeyboardAccelerator> CloseButtonKeyboardAccelerators{ get; };
+
+
+        event Windows.Foundation.TypedEventHandler<WinUI3Package.WindowedContentDialog, Object> Opened;
+        event Windows.Foundation.TypedEventHandler<WinUI3Package.WindowedContentDialog, Microsoft.UI.Xaml.WindowEventArgs> Closed;
+
+        event Windows.Foundation.TypedEventHandler<Object, Microsoft.UI.Xaml.Input.RightTappedRoutedEventArgs> ContentRightTapped;
+
+        event Windows.Foundation.TypedEventHandler<WinUI3Package.WindowedContentDialog, WinUI3Package.ContentDialogWindowButtonClickEventArgs> PrimaryButtonClick;
+        event Windows.Foundation.TypedEventHandler<WinUI3Package.WindowedContentDialog, WinUI3Package.ContentDialogWindowButtonClickEventArgs> SecondaryButtonClick;
+        event Windows.Foundation.TypedEventHandler<WinUI3Package.WindowedContentDialog, WinUI3Package.ContentDialogWindowButtonClickEventArgs> CloseButtonClick;
+
+        Windows.Foundation.IAsyncOperation<Microsoft.UI.Xaml.Controls.ContentDialogResult> ShowAsync();
+        Windows.Foundation.IAsyncOperation<Microsoft.UI.Xaml.Controls.ContentDialogResult> ShowAsync(Boolean isModal);
+
+    }
+}
diff --git a/WinUI3Package/include/cppwinrt_utils.h b/WinUI3Package/include/cppwinrt_utils.h
new file mode 100644
index 0000000..9013908
--- /dev/null
+++ b/WinUI3Package/include/cppwinrt_utils.h
@@ -0,0 +1,58 @@
+#pragma once
+
+
+#define DEFINE_PROPERTY(type, name)                                      \
+public:                                                                  \
+                                                                         \
+    type name() const                                                    \
+    {                                                                    \
+        return _##name;                                                  \
+    }                                                                    \
+    void name(const type& value)                                         \
+    {                                                                    \
+       if (_##name != value){                                            \
+          _##name = value;                                               \
+       }                                                                 \
+    }                                                                    \
+                                                                         \
+private:                                                                 \
+    type _##name;
+
+
+#define DEFINE_PROPERTY2(type, name)                                      \
+public:                                                                  \
+                                                                         \
+    type name() const                                                    \
+    {                                                                    \
+        return _##name;                                                  \
+    }                                                                    \
+    void name(const type& value)                                         \
+    {                                                                    \
+       if (_##name != value){                                            \
+          _##name = value;                                               \
+       }                                                                 \
+    }                                                                    \
+                                                                         \
+private:                                                                 \
+    type _##name{nullptr};
+
+#define DEPENDENCY_PROPERTY(type, name)                                  \
+public:                                                                  \
+                                                                         \
+    static winrt::Microsoft::UI::Xaml::DependencyProperty name##Property() \
+    {                                                                    \
+        return _##name##Property;                                        \
+    }                                                                    \
+                                                                         \
+    type name() const                                                    \
+    {                                                                    \
+        return winrt::unbox_value<type>(GetValue(_##name##Property));    \
+    }                                                                    \
+                                                                         \
+    void name(const type& value)                                         \
+    {                                                                    \
+         SetValue(_##name##Property, winrt::box_value(value));           \
+    }                                                                   \
+                                                                         \
+private:                                                                 \
+    static winrt::Microsoft::UI::Xaml::DependencyProperty _##name##Property;
\ No newline at end of file

From d528be460896fb06e5487a5ed2ed738f908e25f5 Mon Sep 17 00:00:00 2001
From: FF69B4 <78807100@qq.com>
Date: Sun, 4 Jan 2026 20:57:15 +0800
Subject: [PATCH 2/3] Remove Macro

---
 WinUI3Package/ContentDialogContent.h          | 224 +++++++--
 WinUI3Package/ContentDialogWindow.xaml.h      |   8 -
 WinUI3Package/UnderlaySmokeLayerOptions.h     |  65 ++-
 WinUI3Package/UnderlaySystemBackdropOptions.h |  50 +-
 WinUI3Package/WinUI3Package.vcxproj           |   1 -
 WinUI3Package/WinUI3Package.vcxproj.filters   |   6 +-
 WinUI3Package/WindowedContentDialog.h         | 456 ++++++++++++++----
 WinUI3Package/include/cppwinrt_utils.h        |  58 ---
 8 files changed, 632 insertions(+), 236 deletions(-)
 delete mode 100644 WinUI3Package/include/cppwinrt_utils.h

diff --git a/WinUI3Package/ContentDialogContent.h b/WinUI3Package/ContentDialogContent.h
index 29d14fa..bb95577 100644
--- a/WinUI3Package/ContentDialogContent.h
+++ b/WinUI3Package/ContentDialogContent.h
@@ -2,15 +2,12 @@
 
 #include "ContentDialogContent.g.h"
 
-#include "include/cppwinrt_utils.h"
-
 namespace winrt::WinUI3Package::implementation
 {
-    struct ContentDialogContent : ContentDialogContentT<ContentDialogContent>
-    {
+	struct ContentDialogContent : ContentDialogContentT<ContentDialogContent>
+	{
 		using Super = ContentDialogContentT<ContentDialogContent>;
 
-
 		ContentDialogContent();
 		~ContentDialogContent();
 
@@ -24,8 +21,6 @@ namespace winrt::WinUI3Package::implementation
 
 		void AfterLostFocus();
 
-		//void DetermineButtonsVisibilityState();
-		//void DetermineDefaultButtonStates();
 		winrt::hstring DetermineButtonsVisibilityState();
 		winrt::hstring DetermineDefaultButtonState();
 
@@ -58,8 +53,6 @@ namespace winrt::WinUI3Package::implementation
 			UNREFERENCED_PARAMETER(sender);
 			UNREFERENCED_PARAMETER(e);
 
-			//winrt::Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, IsEnabled() ? NormalState : DisabledState, true);
-
 			auto self = get_self<ContentDialogContent>(sender.as<winrt::WinUI3Package::ContentDialogContent>());
 
 			if (self->IsLoaded())
@@ -67,7 +60,6 @@ namespace winrt::WinUI3Package::implementation
 				self->buttonsVisibilityState = self->DetermineButtonsVisibilityState();
 				self->isCustomMeasureFinishedAfterLoaded = false;
 			}
-
 		}
 
 		static void OnDefaultButtonChangedStatic(Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::DependencyPropertyChangedEventArgs e)
@@ -75,18 +67,14 @@ namespace winrt::WinUI3Package::implementation
 			UNREFERENCED_PARAMETER(sender);
 			UNREFERENCED_PARAMETER(e);
 
-			//winrt::Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, IsEnabled() ? NormalState : DisabledState, true);
-
 			auto self = get_self<ContentDialogContent>(sender.as<winrt::WinUI3Package::ContentDialogContent>());
 
 			if (self->IsLoaded())
 			{
 				self->defaultButtonState = self->DetermineDefaultButtonState();
 			}
-
 		}
 
-
 		static winrt::Windows::UI::Xaml::Style DefaultButtonStyle()
 		{
 			static auto style = Microsoft::UI::Xaml::Application::Current().Resources().TryLookup(
@@ -95,38 +83,179 @@ namespace winrt::WinUI3Package::implementation
 
 			return style;
 		}
-		//static void OnIsClickEnabledPropertyChangedStatic(Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::DependencyPropertyChangedEventArgs args)
-		//{
-		//	UNREFERENCED_PARAMETER(sender);
-		//	UNREFERENCED_PARAMETER(args);
-		//	get_self<ContentDialogContent>(sender.as<winrt::WinUI3Package::ContentDialogContent>())->OnIsClickEnabledPropertyChanged(args.OldValue().as<bool>(), args.NewValue().as<bool>());
-
-		//}
 
 		winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> PrimaryButtonKeyboardAccelerators();
 		winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> SecondaryButtonKeyboardAccelerators();
 		winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> CloseButtonKeyboardAccelerators();
 
+		// IsHeaderImage property
+		bool IsHeaderImage() const
+		{
+			return _IsHeaderImage;
+		}
+		void IsHeaderImage(const bool& value)
+		{
+			if (_IsHeaderImage != value)
+			{
+				_IsHeaderImage = value;
+			}
+		}
 
-		DEFINE_PROPERTY(bool, IsHeaderImage);
+		// Title dependency property
+		static winrt::Microsoft::UI::Xaml::DependencyProperty TitleProperty()
+		{
+			return _TitleProperty;
+		}
+		winrt::Windows::Foundation::IInspectable Title() const
+		{
+			return winrt::unbox_value<winrt::Windows::Foundation::IInspectable>(GetValue(_TitleProperty));
+		}
+		void Title(const winrt::Windows::Foundation::IInspectable& value)
+		{
+			SetValue(_TitleProperty, winrt::box_value(value));
+		}
 
-		DEPENDENCY_PROPERTY(winrt::Windows::Foundation::IInspectable, Title);
-		DEPENDENCY_PROPERTY(Microsoft::UI::Xaml::DataTemplate, TitleTemplate);
-		DEPENDENCY_PROPERTY(winrt::hstring, PrimaryButtonText);
-		DEPENDENCY_PROPERTY(winrt::hstring, SecondaryButtonText);
-		DEPENDENCY_PROPERTY(winrt::hstring, CloseButtonText);
+		// TitleTemplate dependency property
+		static winrt::Microsoft::UI::Xaml::DependencyProperty TitleTemplateProperty()
+		{
+			return _TitleTemplateProperty;
+		}
+		Microsoft::UI::Xaml::DataTemplate TitleTemplate() const
+		{
+			return winrt::unbox_value<Microsoft::UI::Xaml::DataTemplate>(GetValue(_TitleTemplateProperty));
+		}
+		void TitleTemplate(const Microsoft::UI::Xaml::DataTemplate& value)
+		{
+			SetValue(_TitleTemplateProperty, winrt::box_value(value));
+		}
 
-		DEPENDENCY_PROPERTY(bool, IsPrimaryButtonEnabled);
-		DEPENDENCY_PROPERTY(bool, IsSecondaryButtonEnabled);
+		// PrimaryButtonText dependency property
+		static winrt::Microsoft::UI::Xaml::DependencyProperty PrimaryButtonTextProperty()
+		{
+			return _PrimaryButtonTextProperty;
+		}
+		winrt::hstring PrimaryButtonText() const
+		{
+			return winrt::unbox_value<winrt::hstring>(GetValue(_PrimaryButtonTextProperty));
+		}
+		void PrimaryButtonText(const winrt::hstring& value)
+		{
+			SetValue(_PrimaryButtonTextProperty, winrt::box_value(value));
+		}
 
-		DEPENDENCY_PROPERTY(Microsoft::UI::Xaml::Controls::ContentDialogButton, DefaultButton);
+		// SecondaryButtonText dependency property
+		static winrt::Microsoft::UI::Xaml::DependencyProperty SecondaryButtonTextProperty()
+		{
+			return _SecondaryButtonTextProperty;
+		}
+		winrt::hstring SecondaryButtonText() const
+		{
+			return winrt::unbox_value<winrt::hstring>(GetValue(_SecondaryButtonTextProperty));
+		}
+		void SecondaryButtonText(const winrt::hstring& value)
+		{
+			SetValue(_SecondaryButtonTextProperty, winrt::box_value(value));
+		}
 
-		DEPENDENCY_PROPERTY(Microsoft::UI::Xaml::Style, PrimaryButtonStyle);
-		DEPENDENCY_PROPERTY(Microsoft::UI::Xaml::Style, SecondaryButtonStyle);
-		DEPENDENCY_PROPERTY(Microsoft::UI::Xaml::Style, CloseButtonStyle);
+		// CloseButtonText dependency property
+		static winrt::Microsoft::UI::Xaml::DependencyProperty CloseButtonTextProperty()
+		{
+			return _CloseButtonTextProperty;
+		}
+		winrt::hstring CloseButtonText() const
+		{
+			return winrt::unbox_value<winrt::hstring>(GetValue(_CloseButtonTextProperty));
+		}
+		void CloseButtonText(const winrt::hstring& value)
+		{
+			SetValue(_CloseButtonTextProperty, winrt::box_value(value));
+		}
 
-	private:
+		// IsPrimaryButtonEnabled dependency property
+		static winrt::Microsoft::UI::Xaml::DependencyProperty IsPrimaryButtonEnabledProperty()
+		{
+			return _IsPrimaryButtonEnabledProperty;
+		}
+		bool IsPrimaryButtonEnabled() const
+		{
+			return winrt::unbox_value<bool>(GetValue(_IsPrimaryButtonEnabledProperty));
+		}
+		void IsPrimaryButtonEnabled(const bool& value)
+		{
+			SetValue(_IsPrimaryButtonEnabledProperty, winrt::box_value(value));
+		}
 
+		// IsSecondaryButtonEnabled dependency property
+		static winrt::Microsoft::UI::Xaml::DependencyProperty IsSecondaryButtonEnabledProperty()
+		{
+			return _IsSecondaryButtonEnabledProperty;
+		}
+		bool IsSecondaryButtonEnabled() const
+		{
+			return winrt::unbox_value<bool>(GetValue(_IsSecondaryButtonEnabledProperty));
+		}
+		void IsSecondaryButtonEnabled(const bool& value)
+		{
+			SetValue(_IsSecondaryButtonEnabledProperty, winrt::box_value(value));
+		}
+
+		// DefaultButton dependency property
+		static winrt::Microsoft::UI::Xaml::DependencyProperty DefaultButtonProperty()
+		{
+			return _DefaultButtonProperty;
+		}
+		Microsoft::UI::Xaml::Controls::ContentDialogButton DefaultButton() const
+		{
+			return winrt::unbox_value<Microsoft::UI::Xaml::Controls::ContentDialogButton>(GetValue(_DefaultButtonProperty));
+		}
+		void DefaultButton(const Microsoft::UI::Xaml::Controls::ContentDialogButton& value)
+		{
+			SetValue(_DefaultButtonProperty, winrt::box_value(value));
+		}
+
+		// PrimaryButtonStyle dependency property
+		static winrt::Microsoft::UI::Xaml::DependencyProperty PrimaryButtonStyleProperty()
+		{
+			return _PrimaryButtonStyleProperty;
+		}
+		Microsoft::UI::Xaml::Style PrimaryButtonStyle() const
+		{
+			return winrt::unbox_value<Microsoft::UI::Xaml::Style>(GetValue(_PrimaryButtonStyleProperty));
+		}
+		void PrimaryButtonStyle(const Microsoft::UI::Xaml::Style& value)
+		{
+			SetValue(_PrimaryButtonStyleProperty, winrt::box_value(value));
+		}
+
+		// SecondaryButtonStyle dependency property
+		static winrt::Microsoft::UI::Xaml::DependencyProperty SecondaryButtonStyleProperty()
+		{
+			return _SecondaryButtonStyleProperty;
+		}
+		Microsoft::UI::Xaml::Style SecondaryButtonStyle() const
+		{
+			return winrt::unbox_value<Microsoft::UI::Xaml::Style>(GetValue(_SecondaryButtonStyleProperty));
+		}
+		void SecondaryButtonStyle(const Microsoft::UI::Xaml::Style& value)
+		{
+			SetValue(_SecondaryButtonStyleProperty, winrt::box_value(value));
+		}
+
+		// CloseButtonStyle dependency property
+		static winrt::Microsoft::UI::Xaml::DependencyProperty CloseButtonStyleProperty()
+		{
+			return _CloseButtonStyleProperty;
+		}
+		Microsoft::UI::Xaml::Style CloseButtonStyle() const
+		{
+			return winrt::unbox_value<Microsoft::UI::Xaml::Style>(GetValue(_CloseButtonStyleProperty));
+		}
+		void CloseButtonStyle(const Microsoft::UI::Xaml::Style& value)
+		{
+			SetValue(_CloseButtonStyleProperty, winrt::box_value(value));
+		}
+
+	private:
 		bool isCustomMeasureFinishedAfterLoaded;
 
 		Microsoft::UI::Xaml::Controls::Button PrimaryButton{ nullptr };
@@ -139,7 +268,6 @@ namespace winrt::WinUI3Package::implementation
 
 		winrt::event<Windows::Foundation::TypedEventHandler<Windows::Foundation::IInspectable, Microsoft::UI::Xaml::Input::RightTappedRoutedEventArgs>> m_ContentRightTapped;
 
-
 		Microsoft::UI::Xaml::UIElement m_TitleArea{ nullptr };
 		Microsoft::UI::Xaml::Controls::Grid m_DialogSpace{ nullptr };
 		Microsoft::UI::Xaml::Controls::Grid m_CommandSpace{ nullptr };
@@ -153,17 +281,31 @@ namespace winrt::WinUI3Package::implementation
 		winrt::event_token m_OnSecondaryButtonClick;
 		winrt::event_token m_OnCloseButtonClick;
 
-
 		winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> m_PrimaryButtonKeyboardAccelerators{ nullptr };
 		winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> m_SecondaryButtonKeyboardAccelerators{ nullptr };
 		winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> m_CloseButtonKeyboardAccelerators{ nullptr };
 
-    };
+		// IsHeaderImage property field
+		bool _IsHeaderImage;
+
+		// Dependency property fields
+		static winrt::Microsoft::UI::Xaml::DependencyProperty _TitleProperty;
+		static winrt::Microsoft::UI::Xaml::DependencyProperty _TitleTemplateProperty;
+		static winrt::Microsoft::UI::Xaml::DependencyProperty _PrimaryButtonTextProperty;
+		static winrt::Microsoft::UI::Xaml::DependencyProperty _SecondaryButtonTextProperty;
+		static winrt::Microsoft::UI::Xaml::DependencyProperty _CloseButtonTextProperty;
+		static winrt::Microsoft::UI::Xaml::DependencyProperty _IsPrimaryButtonEnabledProperty;
+		static winrt::Microsoft::UI::Xaml::DependencyProperty _IsSecondaryButtonEnabledProperty;
+		static winrt::Microsoft::UI::Xaml::DependencyProperty _DefaultButtonProperty;
+		static winrt::Microsoft::UI::Xaml::DependencyProperty _PrimaryButtonStyleProperty;
+		static winrt::Microsoft::UI::Xaml::DependencyProperty _SecondaryButtonStyleProperty;
+		static winrt::Microsoft::UI::Xaml::DependencyProperty _CloseButtonStyleProperty;
+	};
 }
 
 namespace winrt::WinUI3Package::factory_implementation
 {
-    struct ContentDialogContent : ContentDialogContentT<ContentDialogContent, implementation::ContentDialogContent>
-    {
-    };
-}
+	struct ContentDialogContent : ContentDialogContentT<ContentDialogContent, implementation::ContentDialogContent>
+	{
+	};
+}
\ No newline at end of file
diff --git a/WinUI3Package/ContentDialogWindow.xaml.h b/WinUI3Package/ContentDialogWindow.xaml.h
index ece3a91..e6fe969 100644
--- a/WinUI3Package/ContentDialogWindow.xaml.h
+++ b/WinUI3Package/ContentDialogWindow.xaml.h
@@ -3,7 +3,6 @@
 #include "ContentDialogWindow.g.h"
 
 #include <winrt/Microsoft.UI.Windowing.h>
-#include "include/cppwinrt_utils.h"
 
 namespace winrt::WinUI3Package::implementation
 {
@@ -159,13 +158,6 @@ namespace winrt::WinUI3Package::implementation
 		winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator> CloseButtonKeyboardAccelerators();
 
 
-		//DEFINE_PROPERTY2(winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator>, PrimaryButtonKeyboardAccelerators);
-		//DEFINE_PROPERTY2(winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator>, SecondaryButtonKeyboardAccelerators);
-		//DEFINE_PROPERTY2(winrt::Windows::Foundation::Collections::IVector<Microsoft::UI::Xaml::Input::KeyboardAccelerator>, CloseButtonKeyboardAccelerators);
-
-	//	DEFINE_PROPERTY2(Microsoft::UI::Xaml::Media::Imaging::BitmapImage, HeaderImage);
-		//DEFINE_PROPERTY(winrt::hstring, HeaderImageUri);
-
 
 	private:
 		bool m_hasTitleBar = true;
diff --git a/WinUI3Package/UnderlaySmokeLayerOptions.h b/WinUI3Package/UnderlaySmokeLayerOptions.h
index a2d77e3..a284123 100644
--- a/WinUI3Package/UnderlaySmokeLayerOptions.h
+++ b/WinUI3Package/UnderlaySmokeLayerOptions.h
@@ -1,24 +1,65 @@
 #pragma once
 
 #include "UnderlaySmokeLayerOptions.g.h"
-#include "include/cppwinrt_utils.h"
 
 namespace winrt::WinUI3Package::implementation
 {
-    struct UnderlaySmokeLayerOptions : UnderlaySmokeLayerOptionsT<UnderlaySmokeLayerOptions>
-    {
-        UnderlaySmokeLayerOptions();
+	struct UnderlaySmokeLayerOptions : UnderlaySmokeLayerOptionsT<UnderlaySmokeLayerOptions>
+	{
+		UnderlaySmokeLayerOptions();
 
+		// SmokeLayerKind 属性
+		WinUI3Package::WindowedContentDialogSmokeLayerKind SmokeLayerKind() const
+		{
+			return _SmokeLayerKind;
+		}
 
-		DEFINE_PROPERTY(WinUI3Package::WindowedContentDialogSmokeLayerKind, SmokeLayerKind);
-		DEFINE_PROPERTY2(Microsoft::UI::Xaml::UIElement, CustomSmokeLayer);
-		DEFINE_PROPERTY(Microsoft::UI::Xaml::ScalarTransition, OpacityTransition);
-    };
+		void SmokeLayerKind(const WinUI3Package::WindowedContentDialogSmokeLayerKind& value)
+		{
+			if (_SmokeLayerKind != value)
+			{
+				_SmokeLayerKind = value;
+			}
+		}
+
+		// CustomSmokeLayer 属性
+		Microsoft::UI::Xaml::UIElement CustomSmokeLayer() const
+		{
+			return _CustomSmokeLayer;
+		}
+
+		void CustomSmokeLayer(const Microsoft::UI::Xaml::UIElement& value)
+		{
+			if (_CustomSmokeLayer != value)
+			{
+				_CustomSmokeLayer = value;
+			}
+		}
+
+		// OpacityTransition 属性
+		Microsoft::UI::Xaml::ScalarTransition OpacityTransition() const
+		{
+			return _OpacityTransition;
+		}
+
+		void OpacityTransition(const Microsoft::UI::Xaml::ScalarTransition& value)
+		{
+			if (_OpacityTransition != value)
+			{
+				_OpacityTransition = value;
+			}
+		}
+
+	private:
+		WinUI3Package::WindowedContentDialogSmokeLayerKind _SmokeLayerKind;
+		Microsoft::UI::Xaml::UIElement _CustomSmokeLayer{ nullptr };
+		Microsoft::UI::Xaml::ScalarTransition _OpacityTransition;
+	};
 }
 
 namespace winrt::WinUI3Package::factory_implementation
 {
-    struct UnderlaySmokeLayerOptions : UnderlaySmokeLayerOptionsT<UnderlaySmokeLayerOptions, implementation::UnderlaySmokeLayerOptions>
-    {
-    };
-}
+	struct UnderlaySmokeLayerOptions : UnderlaySmokeLayerOptionsT<UnderlaySmokeLayerOptions, implementation::UnderlaySmokeLayerOptions>
+	{
+	};
+}
\ No newline at end of file
diff --git a/WinUI3Package/UnderlaySystemBackdropOptions.h b/WinUI3Package/UnderlaySystemBackdropOptions.h
index 2f49717..4c4ac48 100644
--- a/WinUI3Package/UnderlaySystemBackdropOptions.h
+++ b/WinUI3Package/UnderlaySystemBackdropOptions.h
@@ -2,23 +2,49 @@
 
 #include "UnderlaySystemBackdropOptions.g.h"
 
-#include "include/cppwinrt_utils.h"
-
 namespace winrt::WinUI3Package::implementation
 {
-    struct UnderlaySystemBackdropOptions : UnderlaySystemBackdropOptionsT<UnderlaySystemBackdropOptions>
-    {
-        UnderlaySystemBackdropOptions();
+	struct UnderlaySystemBackdropOptions : UnderlaySystemBackdropOptionsT<UnderlaySystemBackdropOptions>
+	{
+		UnderlaySystemBackdropOptions();
+
+		// CoverMode 属性
+		WinUI3Package::UnderlayCoverMode CoverMode() const
+		{
+			return _CoverMode;
+		}
+
+		void CoverMode(const WinUI3Package::UnderlayCoverMode& value)
+		{
+			if (_CoverMode != value)
+			{
+				_CoverMode = value;
+			}
+		}
 
+		// OpacityTransition 属性
+		winrt::Microsoft::UI::Xaml::ScalarTransition OpacityTransition() const
+		{
+			return _OpacityTransition;
+		}
 
-		DEFINE_PROPERTY(WinUI3Package::UnderlayCoverMode, CoverMode);
-		DEFINE_PROPERTY(winrt::Microsoft::UI::Xaml::ScalarTransition, OpacityTransition);
-    };
+		void OpacityTransition(const winrt::Microsoft::UI::Xaml::ScalarTransition& value)
+		{
+			if (_OpacityTransition != value)
+			{
+				_OpacityTransition = value;
+			}
+		}
+
+	private:
+		WinUI3Package::UnderlayCoverMode _CoverMode;
+		winrt::Microsoft::UI::Xaml::ScalarTransition _OpacityTransition;
+	};
 }
 
 namespace winrt::WinUI3Package::factory_implementation
 {
-    struct UnderlaySystemBackdropOptions : UnderlaySystemBackdropOptionsT<UnderlaySystemBackdropOptions, implementation::UnderlaySystemBackdropOptions>
-    {
-    };
-}
+	struct UnderlaySystemBackdropOptions : UnderlaySystemBackdropOptionsT<UnderlaySystemBackdropOptions, implementation::UnderlaySystemBackdropOptions>
+	{
+	};
+}
\ No newline at end of file
diff --git a/WinUI3Package/WinUI3Package.vcxproj b/WinUI3Package/WinUI3Package.vcxproj
index 6fdc7b0..1bf7c64 100644
--- a/WinUI3Package/WinUI3Package.vcxproj
+++ b/WinUI3Package/WinUI3Package.vcxproj
@@ -367,7 +367,6 @@
     <ClInclude Include="IconUtils.h" />
     <ClInclude Include="include\BadgeGlyphs.hpp" />
     <ClInclude Include="include\BuiltInUris.hpp" />
-    <ClInclude Include="include\cppwinrt_utils.h" />
     <ClInclude Include="include\DependentValue.h">
       <DependentUpon>include\DependentValue.idl</DependentUpon>
       <SubType>Code</SubType>
diff --git a/WinUI3Package/WinUI3Package.vcxproj.filters b/WinUI3Package/WinUI3Package.vcxproj.filters
index b6c4944..73fb2e2 100644
--- a/WinUI3Package/WinUI3Package.vcxproj.filters
+++ b/WinUI3Package/WinUI3Package.vcxproj.filters
@@ -219,9 +219,6 @@
     <ClInclude Include="Shimmer.DefaultGradientColor.h">
       <Filter>Controls\Shimmer</Filter>
     </ClInclude>
-    <ClInclude Include="include\cppwinrt_utils.h">
-      <Filter>include</Filter>
-    </ClInclude>
     <ClInclude Include="ContentDialogUtils.h">
       <Filter>Controls\WindowedContentDialog</Filter>
     </ClInclude>
@@ -574,4 +571,7 @@
       <Filter>Controls\WindowedContentDialog</Filter>
     </Page>
   </ItemGroup>
+  <ItemGroup>
+    <Natvis Include="$(MSBuildThisFileDirectory)..\..\natvis\wil.natvis" />
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/WinUI3Package/WindowedContentDialog.h b/WinUI3Package/WindowedContentDialog.h
index f95b9d5..0f34bd4 100644
--- a/WinUI3Package/WindowedContentDialog.h
+++ b/WinUI3Package/WindowedContentDialog.h
@@ -2,7 +2,6 @@
 
 #include "WindowedContentDialog.g.h"
 
-#include "include/cppwinrt_utils.h"
 
 namespace winrt::WinUI3Package::implementation
 {
@@ -11,11 +10,9 @@ namespace winrt::WinUI3Package::implementation
 		WindowedContentDialog();
 		~WindowedContentDialog();
 
-
-		double ContentMinWidth() {
-
+		double ContentMinWidth()
+		{
 			return winrt::unbox_value<double>(GetValue(ContentMinWidthProperty()));
-
 		}
 
 		void ContentMinWidth(double value)
@@ -28,10 +25,9 @@ namespace winrt::WinUI3Package::implementation
 			return _ContentMinWidthProperty;
 		}
 
-		winrt::Microsoft::UI::Xaml::FlowDirection ContentFlowDirection() {
-
+		winrt::Microsoft::UI::Xaml::FlowDirection ContentFlowDirection()
+		{
 			return winrt::unbox_value<winrt::Microsoft::UI::Xaml::FlowDirection>(GetValue(ContentFlowDirectionProperty()));
-
 		}
 
 		void ContentFlowDirection(winrt::Microsoft::UI::Xaml::FlowDirection const& value)
@@ -45,196 +41,454 @@ namespace winrt::WinUI3Package::implementation
 		}
 
 		void Close();
-
 		void InitializeContentDialogWindow();
-
 		winrt::Windows::Foundation::IAsyncOperation<Microsoft::UI::Xaml::Controls::ContentDialogResult> ShowAsync();
-
 		winrt::Windows::Foundation::IAsyncOperation<Microsoft::UI::Xaml::Controls::ContentDialogResult> ShowAsync(bool isModal);
-
 		WinUI3Package::ContentDialogWindow GetDialogWindow() { return m_ContentDialogWindow; };
-
 		void UpdateWindowSize();
-
 		void SetUnderlay(WinUI3Package::ContentDialogWindow const& dialogWindow);
-
 		void HandleSmokeLayer(WinUI3Package::ContentDialogWindow const& dialogWindow);
-
 		void HandleSystemBackdrop(WinUI3Package::ContentDialogWindow const& dialogWindow);
-
 		void DisableOwnerEvents(WinUI3Package::ContentDialogWindow const& dialogWindow);
-
 		void AttachPopupLifecycle(WinUI3Package::ContentDialogWindow const& dialogWindow, Microsoft::UI::Xaml::Controls::Primitives::Popup const& popup, bool isSmokeLayer);
-
 		void SizeToXamlRoot(Microsoft::UI::Xaml::FrameworkElement element, Microsoft::UI::Xaml::Window window);
-
 		void DialogWindow_Loaded(winrt::Windows::Foundation::IInspectable const& sender, winrt::Windows::Foundation::IInspectable const& e);
-
 		void DialogWindow_Opened(WinUI3Package::ContentDialogWindow const& sender, winrt::Windows::Foundation::IInspectable const& e);
-
 		void DialogWindow_Closed(winrt::Windows::Foundation::IInspectable const& sender, Microsoft::UI::Xaml::WindowEventArgs const& e);
-
 		void DialogWindow_ClosedPopup(winrt::Windows::Foundation::IInspectable const& sender, Microsoft::UI::Xaml::WindowEventArgs const& e);
-
 		void OnOwnerWindowSizeChanged(winrt::Windows::Foundation::IInspectable const& sender, Microsoft::UI::Xaml::WindowSizeChangedEventArgs const& args);
-
 		void OnContentRightTapped(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::Input::RightTappedRoutedEventArgs const& e);
-
 		int GetTitleBarOffset();
 
 		winrt::event_token Opened(Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, Windows::Foundation::IInspectable> const& handler);
 		void Opened(winrt::event_token const& token);
-
 		winrt::event_token Closed(Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, Microsoft::UI::Xaml::WindowEventArgs> const& handler);
 		void Closed(winrt::event_token const& token);
-
-		winrt::event_token ContentRightTapped(Windows::Foundation::TypedEventHandler<Windows::Foundation::IInspectable,  winrt::Microsoft::UI::Xaml::Input::RightTappedRoutedEventArgs> const& handler);
+		winrt::event_token ContentRightTapped(Windows::Foundation::TypedEventHandler<Windows::Foundation::IInspectable, winrt::Microsoft::UI::Xaml::Input::RightTappedRoutedEventArgs> const& handler);
 		void ContentRightTapped(winrt::event_token const& token);
-
 		winrt::event_token PrimaryButtonClick(Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler);
 		void PrimaryButtonClick(winrt::event_token const& token);
-
 		winrt::event_token SecondaryButtonClick(Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler);
 		void SecondaryButtonClick(winrt::event_token const& token);
-
 		winrt::event_token CloseButtonClick(Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, WinUI3Package::ContentDialogWindowButtonClickEventArgs> const& handler);
 		void CloseButtonClick(winrt::event_token const& token);
 
-		winrt::Windows::Foundation::Collections::IVector< winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator> PrimaryButtonKeyboardAccelerators();
-		winrt::Windows::Foundation::Collections::IVector< winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator> SecondaryButtonKeyboardAccelerators();
-		winrt::Windows::Foundation::Collections::IVector< winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator> CloseButtonKeyboardAccelerators();
-
+		winrt::Windows::Foundation::Collections::IVector<winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator> PrimaryButtonKeyboardAccelerators();
+		winrt::Windows::Foundation::Collections::IVector<winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator> SecondaryButtonKeyboardAccelerators();
+		winrt::Windows::Foundation::Collections::IVector<winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator> CloseButtonKeyboardAccelerators();
 
 		static void OnIsPrimaryButtonEnabledChangedStatic(Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::DependencyPropertyChangedEventArgs e)
 		{
 			UNREFERENCED_PARAMETER(sender);
 			UNREFERENCED_PARAMETER(e);
-
-			//winrt::Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, IsEnabled() ? NormalState : DisabledState, true);
-
 			auto self = get_self<WindowedContentDialog>(sender.as<winrt::WinUI3Package::WindowedContentDialog>());
-
 			self->m_ContentDialogWindow.IsPrimaryButtonEnabled(e.NewValue().as<bool>());
-
 		}
 
-
 		static void OnIsSecondaryButtonEnabledChangedStatic(Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::DependencyPropertyChangedEventArgs e)
 		{
 			UNREFERENCED_PARAMETER(sender);
 			UNREFERENCED_PARAMETER(e);
-
-			//winrt::Microsoft::UI::Xaml::VisualStateManager::GoToState(*this, IsEnabled() ? NormalState : DisabledState, true);
-
 			auto self = get_self<WindowedContentDialog>(sender.as<winrt::WinUI3Package::WindowedContentDialog>());
-
 			self->m_ContentDialogWindow.IsSecondaryButtonEnabled(e.NewValue().as<bool>());
+		}
 
+		// HeaderImage
+		Microsoft::UI::Xaml::Media::Imaging::BitmapImage HeaderImage() const
+		{
+			return _HeaderImage;
+		}
+		void HeaderImage(const Microsoft::UI::Xaml::Media::Imaging::BitmapImage& value)
+		{
+			if (_HeaderImage != value)
+			{
+				_HeaderImage = value;
+			}
 		}
 
+		// HeaderImageUri
+		winrt::hstring HeaderImageUri() const
+		{
+			return _HeaderImageUri;
+		}
+		void HeaderImageUri(const winrt::hstring& value)
+		{
+			if (_HeaderImageUri != value)
+			{
+				_HeaderImageUri = value;
+			}
+		}
 
-		DEFINE_PROPERTY2(Microsoft::UI::Xaml::Media::Imaging::BitmapImage, HeaderImage);
-		DEFINE_PROPERTY(winrt::hstring, HeaderImageUri);
+		// SmokeLayerCache
+		Microsoft::UI::Xaml::Shapes::Rectangle SmokeLayerCache() const
+		{
+			return _SmokeLayerCache;
+		}
+		void SmokeLayerCache(const Microsoft::UI::Xaml::Shapes::Rectangle& value)
+		{
+			if (_SmokeLayerCache != value)
+			{
+				_SmokeLayerCache = value;
+			}
+		}
 
-		DEFINE_PROPERTY2(Microsoft::UI::Xaml::Shapes::Rectangle, SmokeLayerCache);
-		DEFINE_PROPERTY2(Microsoft::UI::Xaml::Controls::Border, BackdropLayerCache);
+		// BackdropLayerCache
+		Microsoft::UI::Xaml::Controls::Border BackdropLayerCache() const
+		{
+			return _BackdropLayerCache;
+		}
+		void BackdropLayerCache(const Microsoft::UI::Xaml::Controls::Border& value)
+		{
+			if (_BackdropLayerCache != value)
+			{
+				_BackdropLayerCache = value;
+			}
+		}
 
-		DEFINE_PROPERTY(winrt::hstring, WindowTitle);
-		DEFINE_PROPERTY2(winrt::Windows::Foundation::IInspectable, Title);
-		DEFINE_PROPERTY2(winrt::Windows::Foundation::IInspectable, Content);
+		// WindowTitle
+		winrt::hstring WindowTitle() const
+		{
+			return _WindowTitle;
+		}
+		void WindowTitle(const winrt::hstring& value)
+		{
+			if (_WindowTitle != value)
+			{
+				_WindowTitle = value;
+			}
+		}
 
-		DEFINE_PROPERTY(Microsoft::UI::Xaml::ElementTheme, RequestedTheme);
+		// Title
+		winrt::Windows::Foundation::IInspectable Title() const
+		{
+			return _Title;
+		}
+		void Title(const winrt::Windows::Foundation::IInspectable& value)
+		{
+			if (_Title != value)
+			{
+				_Title = value;
+			}
+		}
 
-		DEFINE_PROPERTY2(Microsoft::UI::Xaml::Media::SystemBackdrop, SystemBackdrop);
+		// Content
+		winrt::Windows::Foundation::IInspectable Content() const
+		{
+			return _Content;
+		}
+		void Content(const winrt::Windows::Foundation::IInspectable& value)
+		{
+			if (_Content != value)
+			{
+				_Content = value;
+			}
+		}
 
-		// DEFINE_PROPERTY2(Microsoft::UI::Xaml::Media::Brush, Foreground);
-		// DEFINE_PROPERTY2(Microsoft::UI::Xaml::Media::Brush, Background);
-	   //  DEFINE_PROPERTY2(Microsoft::UI::Xaml::Media::Brush, BorderBrush);
+		// RequestedTheme
+		Microsoft::UI::Xaml::ElementTheme RequestedTheme() const
+		{
+			return _RequestedTheme;
+		}
+		void RequestedTheme(const Microsoft::UI::Xaml::ElementTheme& value)
+		{
+			if (_RequestedTheme != value)
+			{
+				_RequestedTheme = value;
+			}
+		}
 
-		// DEFINE_PROPERTY(Microsoft::UI::Xaml::Thickness, BorderThickness);
-		// DEFINE_PROPERTY(Microsoft::UI::Xaml::FlowDirection, FlowDirection);
-		DEFINE_PROPERTY2(Microsoft::UI::Xaml::DataTemplate, TitleTemplate);
-		DEFINE_PROPERTY2(Microsoft::UI::Xaml::DataTemplate, ContentTemplate);
+		// SystemBackdrop
+		Microsoft::UI::Xaml::Media::SystemBackdrop SystemBackdrop() const
+		{
+			return _SystemBackdrop;
+		}
+		void SystemBackdrop(const Microsoft::UI::Xaml::Media::SystemBackdrop& value)
+		{
+			if (_SystemBackdrop != value)
+			{
+				_SystemBackdrop = value;
+			}
+		}
 
-		DEFINE_PROPERTY(winrt::hstring, PrimaryButtonText);
-		DEFINE_PROPERTY(winrt::hstring, SecondaryButtonText);
-		DEFINE_PROPERTY(winrt::hstring, CloseButtonText);
+		// TitleTemplate
+		Microsoft::UI::Xaml::DataTemplate TitleTemplate() const
+		{
+			return _TitleTemplate;
+		}
+		void TitleTemplate(const Microsoft::UI::Xaml::DataTemplate& value)
+		{
+			if (_TitleTemplate != value)
+			{
+				_TitleTemplate = value;
+			}
+		}
 
-		//DEFINE_PROPERTY(bool, IsPrimaryButtonEnabled);
-		//DEFINE_PROPERTY(bool, IsSecondaryButtonEnabled);
+		// ContentTemplate
+		Microsoft::UI::Xaml::DataTemplate ContentTemplate() const
+		{
+			return _ContentTemplate;
+		}
+		void ContentTemplate(const Microsoft::UI::Xaml::DataTemplate& value)
+		{
+			if (_ContentTemplate != value)
+			{
+				_ContentTemplate = value;
+			}
+		}
 
-		DEPENDENCY_PROPERTY(bool, IsPrimaryButtonEnabled);
-		DEPENDENCY_PROPERTY(bool, IsSecondaryButtonEnabled);
+		// PrimaryButtonText
+		winrt::hstring PrimaryButtonText() const
+		{
+			return _PrimaryButtonText;
+		}
+		void PrimaryButtonText(const winrt::hstring& value)
+		{
+			if (_PrimaryButtonText != value)
+			{
+				_PrimaryButtonText = value;
+			}
+		}
 
-		DEFINE_PROPERTY(Microsoft::UI::Xaml::Controls::ContentDialogButton, DefaultButton);
+		// SecondaryButtonText
+		winrt::hstring SecondaryButtonText() const
+		{
+			return _SecondaryButtonText;
+		}
+		void SecondaryButtonText(const winrt::hstring& value)
+		{
+			if (_SecondaryButtonText != value)
+			{
+				_SecondaryButtonText = value;
+			}
+		}
 
-		DEFINE_PROPERTY(WinUI3Package::UnderlayMode, Underlay);
+		// CloseButtonText
+		winrt::hstring CloseButtonText() const
+		{
+			return _CloseButtonText;
+		}
+		void CloseButtonText(const winrt::hstring& value)
+		{
+			if (_CloseButtonText != value)
+			{
+				_CloseButtonText = value;
+			}
+		}
 
-		DEFINE_PROPERTY2(WinUI3Package::UnderlaySystemBackdropOptions, UnderlaySystemBackdrop);
-		//DEFINE_PROPERTY2(WinUI3Package::UnderlaySmokeLayerOptions, UnderlaySmokeLayer);
+		// IsPrimaryButtonEnabled
+		static winrt::Microsoft::UI::Xaml::DependencyProperty IsPrimaryButtonEnabledProperty()
+		{
+			return _IsPrimaryButtonEnabledProperty;
+		}
+		bool IsPrimaryButtonEnabled() const
+		{
+			return winrt::unbox_value<bool>(GetValue(_IsPrimaryButtonEnabledProperty));
+		}
+		void IsPrimaryButtonEnabled(const bool& value)
+		{
+			SetValue(_IsPrimaryButtonEnabledProperty, winrt::box_value(value));
+		}
 
-		DEFINE_PROPERTY(bool, CenterInParent);
+		// IsSecondaryButtonEnabled
+		static winrt::Microsoft::UI::Xaml::DependencyProperty IsSecondaryButtonEnabledProperty()
+		{
+			return _IsSecondaryButtonEnabledProperty;
+		}
+		bool IsSecondaryButtonEnabled() const
+		{
+			return winrt::unbox_value<bool>(GetValue(_IsSecondaryButtonEnabledProperty));
+		}
+		void IsSecondaryButtonEnabled(const bool& value)
+		{
+			SetValue(_IsSecondaryButtonEnabledProperty, winrt::box_value(value));
+		}
 
+		// DefaultButton
+		Microsoft::UI::Xaml::Controls::ContentDialogButton DefaultButton() const
+		{
+			return _DefaultButton;
+		}
+		void DefaultButton(const Microsoft::UI::Xaml::Controls::ContentDialogButton& value)
+		{
+			if (_DefaultButton != value)
+			{
+				_DefaultButton = value;
+			}
+		}
 
-		DEFINE_PROPERTY2(Microsoft::UI::Xaml::Style, PrimaryButtonStyle);
-		DEFINE_PROPERTY2(Microsoft::UI::Xaml::Style, SecondaryButtonStyle);
-		DEFINE_PROPERTY2(Microsoft::UI::Xaml::Style, CloseButtonStyle);
+		// Underlay
+		WinUI3Package::UnderlayMode Underlay() const
+		{
+			return _Underlay;
+		}
+		void Underlay(const WinUI3Package::UnderlayMode& value)
+		{
+			if (_Underlay != value)
+			{
+				_Underlay = value;
+			}
+		}
 
+		// UnderlaySystemBackdrop
+		WinUI3Package::UnderlaySystemBackdropOptions UnderlaySystemBackdrop() const
+		{
+			return _UnderlaySystemBackdrop;
+		}
+		void UnderlaySystemBackdrop(const WinUI3Package::UnderlaySystemBackdropOptions& value)
+		{
+			if (_UnderlaySystemBackdrop != value)
+			{
+				_UnderlaySystemBackdrop = value;
+			}
+		}
 
-		DEFINE_PROPERTY2(Microsoft::UI::Xaml::Window, OwnerWindow);
+		// CenterInParent
+		bool CenterInParent() const
+		{
+			return _CenterInParent;
+		}
+		void CenterInParent(const bool& value)
+		{
+			if (_CenterInParent != value)
+			{
+				_CenterInParent = value;
+			}
+		}
 
-		DEFINE_PROPERTY(bool, HasTitleBar);
-		DEFINE_PROPERTY(bool, IsResizable);
+		// PrimaryButtonStyle
+		Microsoft::UI::Xaml::Style PrimaryButtonStyle() const
+		{
+			return _PrimaryButtonStyle;
+		}
+		void PrimaryButtonStyle(const Microsoft::UI::Xaml::Style& value)
+		{
+			if (_PrimaryButtonStyle != value)
+			{
+				_PrimaryButtonStyle = value;
+			}
+		}
 
+		// SecondaryButtonStyle
+		Microsoft::UI::Xaml::Style SecondaryButtonStyle() const
+		{
+			return _SecondaryButtonStyle;
+		}
+		void SecondaryButtonStyle(const Microsoft::UI::Xaml::Style& value)
+		{
+			if (_SecondaryButtonStyle != value)
+			{
+				_SecondaryButtonStyle = value;
+			}
+		}
 
-		//DEFINE_PROPERTY2(winrt::Windows::Foundation::Collections::IVector< winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator>, PrimaryButtonKeyboardAccelerators);
-		//DEFINE_PROPERTY2(winrt::Windows::Foundation::Collections::IVector< winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator>, SecondaryButtonKeyboardAccelerators);
-	   // DEFINE_PROPERTY2(winrt::Windows::Foundation::Collections::IVector< winrt::Microsoft::UI::Xaml::Input::KeyboardAccelerator>, CloseButtonKeyboardAccelerators);
+		// CloseButtonStyle
+		Microsoft::UI::Xaml::Style CloseButtonStyle() const
+		{
+			return _CloseButtonStyle;
+		}
+		void CloseButtonStyle(const Microsoft::UI::Xaml::Style& value)
+		{
+			if (_CloseButtonStyle != value)
+			{
+				_CloseButtonStyle = value;
+			}
+		}
 
+		// OwnerWindow
+		Microsoft::UI::Xaml::Window OwnerWindow() const
+		{
+			return _OwnerWindow;
+		}
+		void OwnerWindow(const Microsoft::UI::Xaml::Window& value)
+		{
+			if (_OwnerWindow != value)
+			{
+				_OwnerWindow = value;
+			}
+		}
 
-	private:
+		// HasTitleBar
+		bool HasTitleBar() const
+		{
+			return _HasTitleBar;
+		}
+		void HasTitleBar(const bool& value)
+		{
+			if (_HasTitleBar != value)
+			{
+				_HasTitleBar = value;
+			}
+		}
+
+		// IsResizable
+		bool IsResizable() const
+		{
+			return _IsResizable;
+		}
+		void IsResizable(const bool& value)
+		{
+			if (_IsResizable != value)
+			{
+				_IsResizable = value;
+			}
+		}
 
+	private:
 		static winrt::Microsoft::UI::Xaml::DependencyProperty _ContentFlowDirectionProperty;
 		static winrt::Microsoft::UI::Xaml::DependencyProperty _ContentMinWidthProperty;
+		static winrt::Microsoft::UI::Xaml::DependencyProperty _IsPrimaryButtonEnabledProperty;
+		static winrt::Microsoft::UI::Xaml::DependencyProperty _IsSecondaryButtonEnabledProperty;
 
 		WinUI3Package::ContentDialogWindow m_ContentDialogWindow{ nullptr };
-
 		Microsoft::UI::Xaml::Controls::Primitives::Popup m_Popup{ nullptr };
 
-
 		winrt::event<Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, Windows::Foundation::IInspectable>> m_Loaded;
 		winrt::event<Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, Microsoft::UI::Xaml::WindowEventArgs>> m_Closed;
-
-		winrt::event<Windows::Foundation::TypedEventHandler<Windows::Foundation::IInspectable,  winrt::Microsoft::UI::Xaml::Input::RightTappedRoutedEventArgs>> m_ContentRightTapped;
-
-
+		winrt::event<Windows::Foundation::TypedEventHandler<Windows::Foundation::IInspectable, winrt::Microsoft::UI::Xaml::Input::RightTappedRoutedEventArgs>> m_ContentRightTapped;
 		winrt::event<Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, WinUI3Package::ContentDialogWindowButtonClickEventArgs>> m_PrimaryButtonClick;
 		winrt::event<Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, WinUI3Package::ContentDialogWindowButtonClickEventArgs>> m_SecondaryButtonClick;
 		winrt::event<Windows::Foundation::TypedEventHandler<WinUI3Package::WindowedContentDialog, WinUI3Package::ContentDialogWindowButtonClickEventArgs>> m_CloseButtonClick;
 
-
 		winrt::event_token m_DialogWindow_Opened;
 		winrt::event_token m_DialogWindow_Closed;
-
 		winrt::event_token m_onPopupLoaded;
 		winrt::event_token m_onPopupOpened;
 		winrt::event_token m_onPopupClosed;
-		// winrt::event_token m_DialogWindow_Loaded;
-		 //winrt::event_token m_DialogWindow_ClosedPopup;
-
 		winrt::event_token m_OnOwnerWindowSizeChanged;
-
 		winrt::event_token m_OnOwnerWindowSizeChanged_Loaded;
 
-
 		winrt::handle m_DialogEvent;
 
+		Microsoft::UI::Xaml::Media::Imaging::BitmapImage _HeaderImage{ nullptr };
+		winrt::hstring _HeaderImageUri;
+		Microsoft::UI::Xaml::Shapes::Rectangle _SmokeLayerCache{ nullptr };
+		Microsoft::UI::Xaml::Controls::Border _BackdropLayerCache{ nullptr };
+		winrt::hstring _WindowTitle;
+		winrt::Windows::Foundation::IInspectable _Title{ nullptr };
+		winrt::Windows::Foundation::IInspectable _Content{ nullptr };
+		Microsoft::UI::Xaml::ElementTheme _RequestedTheme;
+		Microsoft::UI::Xaml::Media::SystemBackdrop _SystemBackdrop{ nullptr };
+		Microsoft::UI::Xaml::DataTemplate _TitleTemplate{ nullptr };
+		Microsoft::UI::Xaml::DataTemplate _ContentTemplate{ nullptr };
+		winrt::hstring _PrimaryButtonText;
+		winrt::hstring _SecondaryButtonText;
+		winrt::hstring _CloseButtonText;
+		Microsoft::UI::Xaml::Controls::ContentDialogButton _DefaultButton;
+		WinUI3Package::UnderlayMode _Underlay;
+		WinUI3Package::UnderlaySystemBackdropOptions _UnderlaySystemBackdrop{ nullptr };
+		bool _CenterInParent;
+		Microsoft::UI::Xaml::Style _PrimaryButtonStyle{ nullptr };
+		Microsoft::UI::Xaml::Style _SecondaryButtonStyle{ nullptr };
+		Microsoft::UI::Xaml::Style _CloseButtonStyle{ nullptr };
+		Microsoft::UI::Xaml::Window _OwnerWindow{ nullptr };
+		bool _HasTitleBar;
+		bool _IsResizable;
 	};
 }
 
 namespace winrt::WinUI3Package::factory_implementation
 {
-    struct WindowedContentDialog : WindowedContentDialogT<WindowedContentDialog, implementation::WindowedContentDialog>
-    {
-    };
-}
+	struct WindowedContentDialog : WindowedContentDialogT<WindowedContentDialog, implementation::WindowedContentDialog>
+	{
+	};
+}
\ No newline at end of file
diff --git a/WinUI3Package/include/cppwinrt_utils.h b/WinUI3Package/include/cppwinrt_utils.h
deleted file mode 100644
index 9013908..0000000
--- a/WinUI3Package/include/cppwinrt_utils.h
+++ /dev/null
@@ -1,58 +0,0 @@
-#pragma once
-
-
-#define DEFINE_PROPERTY(type, name)                                      \
-public:                                                                  \
-                                                                         \
-    type name() const                                                    \
-    {                                                                    \
-        return _##name;                                                  \
-    }                                                                    \
-    void name(const type& value)                                         \
-    {                                                                    \
-       if (_##name != value){                                            \
-          _##name = value;                                               \
-       }                                                                 \
-    }                                                                    \
-                                                                         \
-private:                                                                 \
-    type _##name;
-
-
-#define DEFINE_PROPERTY2(type, name)                                      \
-public:                                                                  \
-                                                                         \
-    type name() const                                                    \
-    {                                                                    \
-        return _##name;                                                  \
-    }                                                                    \
-    void name(const type& value)                                         \
-    {                                                                    \
-       if (_##name != value){                                            \
-          _##name = value;                                               \
-       }                                                                 \
-    }                                                                    \
-                                                                         \
-private:                                                                 \
-    type _##name{nullptr};
-
-#define DEPENDENCY_PROPERTY(type, name)                                  \
-public:                                                                  \
-                                                                         \
-    static winrt::Microsoft::UI::Xaml::DependencyProperty name##Property() \
-    {                                                                    \
-        return _##name##Property;                                        \
-    }                                                                    \
-                                                                         \
-    type name() const                                                    \
-    {                                                                    \
-        return winrt::unbox_value<type>(GetValue(_##name##Property));    \
-    }                                                                    \
-                                                                         \
-    void name(const type& value)                                         \
-    {                                                                    \
-         SetValue(_##name##Property, winrt::box_value(value));           \
-    }                                                                   \
-                                                                         \
-private:                                                                 \
-    static winrt::Microsoft::UI::Xaml::DependencyProperty _##name##Property;
\ No newline at end of file

From fef8cbac1b85aaad08c4be1d37f4ade39733b1ff Mon Sep 17 00:00:00 2001
From: HO-COOH <szpeter@yeah.net>
Date: Mon, 5 Jan 2026 22:11:43 +0800
Subject: [PATCH 3/3] Refactor: Modal window logic to a base class as it's used
 by ModalWindow and ContentDialogWindow

---
 WinUI3Package/ContentDialogWindow.xaml.cpp | 40 +++++++---------------
 WinUI3Package/ContentDialogWindow.xaml.h   |  5 ++-
 WinUI3Package/ModalWindow.cpp              | 19 ++--------
 WinUI3Package/ModalWindow.h                |  9 ++---
 WinUI3Package/ModalWindowBase.hpp          | 29 ++++++++++++++++
 WinUI3Package/WinUI3Package.vcxproj        |  1 +
 6 files changed, 49 insertions(+), 54 deletions(-)
 create mode 100644 WinUI3Package/ModalWindowBase.hpp

diff --git a/WinUI3Package/ContentDialogWindow.xaml.cpp b/WinUI3Package/ContentDialogWindow.xaml.cpp
index 7f570a4..b74a9df 100644
--- a/WinUI3Package/ContentDialogWindow.xaml.cpp
+++ b/WinUI3Package/ContentDialogWindow.xaml.cpp
@@ -122,7 +122,7 @@ namespace winrt::WinUI3Package::implementation
 
 			Closed(m_Closed);
 
-			if (_parent != nullptr) 	_parent.Closed(m_OnParentClosed);
+			if (m_parent != nullptr) 	m_parent.Closed(m_OnParentClosed);
 
 			WindowImage().ImageOpened(m_ImageOpened);
 
@@ -228,11 +228,11 @@ namespace winrt::WinUI3Package::implementation
 
 		if (_center)
 		{
-			if (_parent != nullptr)
+			if (m_parent != nullptr)
 			{
 				AppWindow().Move(Windows::Graphics::PointInt32(
-					_parent.AppWindow().Position().X + (_parent.AppWindow().Size().Width - AppWindow().Size().Width) / 2,
-					_parent.AppWindow().Position().Y + (_parent.AppWindow().Size().Height - AppWindow().Size().Height) / 2));
+					m_parent.AppWindow().Position().X + (m_parent.AppWindow().Size().Width - AppWindow().Size().Width) / 2,
+					m_parent.AppWindow().Position().Y + (m_parent.AppWindow().Size().Height - AppWindow().Size().Height) / 2));
 			}
 			else
 			{
@@ -347,8 +347,8 @@ namespace winrt::WinUI3Package::implementation
 
 	void ContentDialogWindow::OnClosingRequestedBySystem()
 	{
-		if (_parent) {
-			_parent.Activate();
+		if (m_parent) {
+			m_parent.Activate();
 			//_parent.Closed(m_OnParentClosed);
 		}
 		if (AppWindow()) AppWindow().Hide();
@@ -358,8 +358,8 @@ namespace winrt::WinUI3Package::implementation
 
 	void ContentDialogWindow::OnClosingRequstedByCode()
 	{
-		if (_parent) {
-			_parent.Activate();
+		if (m_parent) {
+			m_parent.Activate();
 			//_parent.Closed(m_OnParentClosed);
 		}
 
@@ -372,7 +372,7 @@ namespace winrt::WinUI3Package::implementation
 	{
 		//if (_parent != nullptr) _parent.Closed(m_OnParentClosed);
 
-		_parent = nullptr;
+		m_parent = nullptr;
 
 		//DispatcherQueue().TryEnqueue([&] {
 
@@ -489,25 +489,11 @@ namespace winrt::WinUI3Package::implementation
 	{
 		_center = center;
 
-		if (_parent == parent) return;
+		if (m_parent == parent) return;
 
-		if (_parent != nullptr) _parent.Closed(m_OnParentClosed);
-
-		_parent = parent;
-
-		if (_parent != nullptr) m_OnParentClosed = _parent.Closed({ this, &ContentDialogWindow::OnParentClosed });;
-
-		HWND ownerHwnd = parent ?
-			winrt::Microsoft::UI::GetWindowFromWindowId(parent.AppWindow().Id()) :
-			nullptr;
-		HWND ownedHwnd = GetWindowFromWindowId(AppWindow().Id());
-
-		if (ownedHwnd)
-		{
-			SetWindowLongPtr(ownedHwnd, -8, reinterpret_cast<LONG_PTR>(ownerHwnd));
-		}
-
-		_presenter.IsModal(parent && modal);
+		SetModal(parent);
+		m_parent.Closed(m_OnParentClosed);
+		m_OnParentClosed = m_parent.Closed({ this, &ContentDialogWindow::OnParentClosed });;
 	}
 
 	void ContentDialogWindow::Foreground(Microsoft::UI::Xaml::Media::Brush const& brush) {
diff --git a/WinUI3Package/ContentDialogWindow.xaml.h b/WinUI3Package/ContentDialogWindow.xaml.h
index e6fe969..8115c41 100644
--- a/WinUI3Package/ContentDialogWindow.xaml.h
+++ b/WinUI3Package/ContentDialogWindow.xaml.h
@@ -3,10 +3,11 @@
 #include "ContentDialogWindow.g.h"
 
 #include <winrt/Microsoft.UI.Windowing.h>
+#include "ModalWindowBase.hpp"
 
 namespace winrt::WinUI3Package::implementation
 {
-	struct ContentDialogWindow : ContentDialogWindowT<ContentDialogWindow>
+	struct ContentDialogWindow : ContentDialogWindowT<ContentDialogWindow>, ModalWindowBase<ContentDialogWindow>
 	{
 		ContentDialogWindow();
 		~ContentDialogWindow();
@@ -173,8 +174,6 @@ namespace winrt::WinUI3Package::implementation
 
 		Microsoft::UI::Windowing::OverlappedPresenter _presenter{ nullptr };
 
-		Microsoft::UI::Xaml::Window _parent{ nullptr };
-
 		bool _center;
 
 
diff --git a/WinUI3Package/ModalWindow.cpp b/WinUI3Package/ModalWindow.cpp
index f4178c0..81224a9 100644
--- a/WinUI3Package/ModalWindow.cpp
+++ b/WinUI3Package/ModalWindow.cpp
@@ -3,26 +3,11 @@
 #if __has_include("ModalWindow.g.cpp")
 #include "ModalWindow.g.cpp"
 #endif
-#include "include/HwndHelper.hpp"
-#include <winrt/Microsoft.UI.Windowing.h>
 
 namespace winrt::WinUI3Package::implementation
 {
-	ModalWindow::ModalWindow(winrt::Microsoft::UI::Xaml::Window const& parent) : m_owner(parent)
+	ModalWindow::ModalWindow(winrt::Microsoft::UI::Xaml::Window const& parent)
 	{
-		m_closedRevoker = Closed(winrt::auto_revoke, { this, &ModalWindow::OnClosed });
-
-		SetWindowLongPtr(GetHwnd(*this), GWLP_HWNDPARENT, reinterpret_cast<LONG_PTR>(GetHwnd(parent)));
-		auto appWindow = AppWindow();
-		appWindow.Presenter().as<winrt::Microsoft::UI::Windowing::OverlappedPresenter>().IsModal(true);
-		appWindow.Show();
-	}
-
-	void ModalWindow::OnClosed(winrt::Windows::Foundation::IInspectable const&, winrt::Microsoft::UI::Xaml::WindowEventArgs const&)
-	{
-		if (m_owner)
-		{
-			m_owner.Activate();
-		}
+		SetModal(parent);
 	}
 }
diff --git a/WinUI3Package/ModalWindow.h b/WinUI3Package/ModalWindow.h
index 45380a5..8f85d7c 100644
--- a/WinUI3Package/ModalWindow.h
+++ b/WinUI3Package/ModalWindow.h
@@ -1,19 +1,14 @@
 #pragma once
 
 #include "ModalWindow.g.h"
+#include "ModalWindowBase.hpp"
 
 namespace winrt::WinUI3Package::implementation
 {
-	struct ModalWindow : ModalWindowT<ModalWindow>
+	struct ModalWindow : ModalWindowT<ModalWindow>, ModalWindowBase<ModalWindow>
 	{
 		ModalWindow() = default;
 		ModalWindow(winrt::Microsoft::UI::Xaml::Window const& parent);
-
-	private:
-		void OnClosed(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::WindowEventArgs const& args);
-
-		winrt::Microsoft::UI::Xaml::Window m_owner{ nullptr };
-		winrt::Microsoft::UI::Xaml::Window::Closed_revoker m_closedRevoker{};
 	};
 }
 
diff --git a/WinUI3Package/ModalWindowBase.hpp b/WinUI3Package/ModalWindowBase.hpp
new file mode 100644
index 0000000..a9ccf81
--- /dev/null
+++ b/WinUI3Package/ModalWindowBase.hpp
@@ -0,0 +1,29 @@
+#pragma once
+#include "HwndHelper.hpp"
+
+template<typename WindowImplementation>
+class ModalWindowBase
+{
+	winrt::Microsoft::UI::Xaml::Window::Closed_revoker m_closedRevoker;
+	constexpr auto& getSelf()
+	{
+		return *static_cast<WindowImplementation*>(this);
+	}
+
+protected:
+	winrt::Microsoft::UI::Xaml::Window m_parent{ nullptr };
+
+public:
+	void SetModal(winrt::Microsoft::UI::Xaml::Window const& parent)
+	{
+		m_parent = parent;
+		m_closedRevoker = getSelf().Closed(winrt::auto_revoke, [this](auto&&...) {
+			m_parent.Activate();
+		});
+
+		SetWindowLongPtr(GetHwnd(getSelf()), GWLP_HWNDPARENT, reinterpret_cast<LONG_PTR>(GetHwnd(parent)));
+		auto appWindow = getSelf().AppWindow();
+		appWindow.Presenter().as<winrt::Microsoft::UI::Windowing::OverlappedPresenter>().IsModal(true);
+		appWindow.Show();
+	}
+};
\ No newline at end of file
diff --git a/WinUI3Package/WinUI3Package.vcxproj b/WinUI3Package/WinUI3Package.vcxproj
index 1bf7c64..2f07d89 100644
--- a/WinUI3Package/WinUI3Package.vcxproj
+++ b/WinUI3Package/WinUI3Package.vcxproj
@@ -420,6 +420,7 @@
       <DependentUpon>ModalWindow.idl</DependentUpon>
       <SubType>Code</SubType>
     </ClInclude>
+    <ClInclude Include="ModalWindowBase.hpp" />
     <ClInclude Include="ModernStandardWindowContextMenu.xaml.h">
       <DependentUpon>ModernStandardWindowContextMenu.xaml</DependentUpon>
       <SubType>Code</SubType>