10. 应用开发：C++/C# 和 WinUI3

  <?xml version="1.0" encoding="utf-8"?>
<Window
    x:Class="WinUI3Cpp.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3Cpp"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Title="WinUI3Cpp">

    <StackPanel Orientation="Horizontal" HorizontalAlignment="Center" VerticalAlignment="Center" >
    <Button x:Name="myButton" Click="myButton_Click">Click Me</Button>
    </StackPanel>

</Window>
  

  #pragma once

#include "MainWindow.g.h"

namespace winrt::WinUI3Cpp::implementation
{
    struct MainWindow : MainWindowT<MainWindow>
    {
        MainWindow()
        {
            // Xaml objects should not call InitializeComponent during construction.
            // See https://github.com/microsoft/cppwinrt/tree/master/nuget#initializecomponent
        }

        int32_t MyProperty();
        void MyProperty(int32_t value);

        void myButton_Click(IInspectable const& sender, Microsoft::UI::Xaml::RoutedEventArgs const& args);
    };
}

namespace winrt::WinUI3Cpp::factory_implementation
{
    struct MainWindow : MainWindowT<MainWindow, implementation::MainWindow>
    {
    };
}
  

  #include "pch.h"
#include "MainWindow.xaml.h"
#if __has_include("MainWindow.g.cpp")
#include "MainWindow.g.cpp"
#endif

using namespace winrt;
using namespace Microsoft::UI::Xaml;

// To learn more about WinUI, the WinUI project structure,
// and more about our project templates, see: http://aka.ms/winui-project-info.

namespace winrt::WinUI3Cpp::implementation
{
    int32_t MainWindow::MyProperty()
    {
        throw hresult_not_implemented();
    }

    void MainWindow::MyProperty(int32_t /* value */)
    {
        throw hresult_not_implemented();
    }

    void MainWindow::myButton_Click(IInspectable const&, RoutedEventArgs const&)
    {
        myButton().Content(box_value(L"Clicked"));
    }
}
  

  namespace WinUI3Cpp
{
    [default_interface]
    runtimeclass MainWindow : Microsoft.UI.Xaml.Window
    {
        MainWindow();
        Int32 MyProperty;
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Window
    x:Class="WinUI3X.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3X"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Title="x:Bind">

    <StackPanel Orientation="Vertical" HorizontalAlignment="Center" VerticalAlignment="Center">
        <TextBlock Text="{x:Bind MyProperty}" HorizontalAlignment="Center" FontSize="64"/>
        <Button x:Name="myButton" Click="myButton_Click">Click Me</Button>
    </StackPanel>
</Window>
  

  #pragma once

#include "MainWindow.g.h"

namespace winrt::WinUI3X::implementation
{
    struct MainWindow : MainWindowT<MainWindow>
    {
    private:
        int32_t propertyValue = 0;

    public:
        MainWindow(){}

        int32_t MyProperty();
        void MyProperty(int32_t value);

        void myButton_Click(IInspectable const& sender, Microsoft::UI::Xaml::RoutedEventArgs const& args);
    };
}

namespace winrt::WinUI3X::factory_implementation
{
    struct MainWindow : MainWindowT<MainWindow, implementation::MainWindow>
    {
    };
}
  

  #include "pch.h"
#include "MainWindow.xaml.h"
#if __has_include("MainWindow.g.cpp")
#include "MainWindow.g.cpp"
#endif

using namespace winrt;
using namespace Microsoft::UI::Xaml;

namespace winrt::WinUI3X::implementation
{
    int32_t MainWindow::MyProperty()
    {
        return propertyValue;
    }

    void MainWindow::MyProperty(int32_t value)
    {
       propertyValue = value;
       this->Bindings->Update();
       OutputDebugString(L"Property value updated to: ");
       OutputDebugString(winrt::to_hstring(propertyValue).c_str());
       OutputDebugString(L"\r\n");
    }

    void MainWindow::myButton_Click(IInspectable const&, RoutedEventArgs const&)
    {
        MyProperty(propertyValue + 1);
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Window
    x:Class="WinUI3X.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3X"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Title="x:Control">

    <StackPanel Orientation="Horizontal" HorizontalAlignment="Center" VerticalAlignment="Center">
        <Border x:Name="colorPanel" Width="64" Height="64" CornerRadius="32" Background="Black" HorizontalAlignment="Left" VerticalAlignment="Top" Margin="0,0,10,0"/>
        <StackPanel Orientation="Vertical">            
            <RadioButton x:Name="yellowButton" Content="Yellow" Checked="yellowButton_Checked"/>
            <RadioButton x:Name="blueButton" Content="Blue" Checked="blueButton_Checked"/>
            <RadioButton x:Name="redButton" Content="Red" Checked="redButton_Checked"/>
        </StackPanel>
        <StackPanel Orientation="Vertical" Margin="20,0,0,0">
            <TextBox x:Name="nameBox" Header="Enter your name:" Width="200"/>
            <Button x:Name="sayHiButton" Content="Say Hi!" Click="sayHiButton_Click" Margin="0,10,0,0"/>
        </StackPanel>
    </StackPanel>
</Window>
  

  #pragma once

#include "MainWindow.g.h"

namespace winrt::WinUI3X::implementation
{
    struct MainWindow : MainWindowT<MainWindow>
    {
    private:
        winrt::fire_and_forget showMessage(hstring message);
    public:
        MainWindow(){}

        void yellowButton_Checked(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
        void blueButton_Checked(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
        void redButton_Checked(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
        void sayHiButton_Click(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
    };
}

namespace winrt::WinUI3X::factory_implementation
{
    struct MainWindow : MainWindowT<MainWindow, implementation::MainWindow>
    {
    };
}
  

  #include "pch.h"
#include "MainWindow.xaml.h"
#if __has_include("MainWindow.g.cpp")
#include "MainWindow.g.cpp"
#endif

using namespace winrt;
using namespace Microsoft::UI::Xaml;
using namespace Microsoft::UI::Xaml::Media;

namespace winrt::WinUI3X::implementation
{
	winrt::fire_and_forget MainWindow::showMessage(hstring message)
	{
		Microsoft::UI::Xaml::Controls::ContentDialog dialog{};
		dialog.XamlRoot(this->Content().XamlRoot());
		dialog.Title(box_value(L"Greetings"));
		dialog.Content(box_value(message));
		dialog.CloseButtonText(L"Close");
		co_await dialog.ShowAsync();
	}
	void MainWindow::yellowButton_Checked(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e)
	{
		colorPanel().Background(SolidColorBrush{ Microsoft::UI::Colors::Yellow() });
	}

	void MainWindow::blueButton_Checked(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e)
	{
		colorPanel().Background(SolidColorBrush{ Microsoft::UI::Colors::Blue() });
	}

	void MainWindow::redButton_Checked(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e)
	{
		colorPanel().Background(SolidColorBrush{ Microsoft::UI::Colors::Red() });
	}

	void MainWindow::sayHiButton_Click(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e)
	{
		if (nameBox().Text().empty()) {
			showMessage(L"Enter your name!");
			return;
		}
		showMessage(hstring{ L"Hi, " + nameBox().Text() });
	}

}
  

  namespace WinUI3X
{
    [default_interface]
    runtimeclass MainWindow : Microsoft.UI.Xaml.Window
    {
        MainWindow();
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Window
    x:Class="WinUI3X.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3X"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Title="x:Control">

    <StackPanel Orientation="Horizontal" HorizontalAlignment="Center" VerticalAlignment="Center">
        <StackPanel Orientation="Vertical" Padding="12" BorderBrush="Gray" BorderThickness="0,0,1,0">
            <ComboBox x:Name="manualList" Header="Manual List" Width="200"/>
            <Button x:Name="addManualItemButton" Content="Add Item" Click="addManualItemButton_Click" Margin="0,10,0,0"/>
        </StackPanel>
        <StackPanel Orientation="Vertical" Padding="12" BorderBrush="Gray" BorderThickness="0,0,1,0">
            <ComboBox x:Name="sourceList" Header="ItemsSource List" Width="200"/>
            <Button x:Name="addSourceItemButton" Content="Add Item" Click="addSourceItemButton_Click" Margin="0,10,0,0"/>
        </StackPanel>
        <StackPanel Orientation="Vertical" Padding="12" BorderBrush="Gray" BorderThickness="0,0,1,0">
            <ComboBox x:Name="boundList" Header="Bound List" Width="200" ItemsSource="{x:Bind collection}"/>
            <Button x:Name="addBoundItemButton" Content="Add Item" Click="addBoundItemButton_Click" Margin="0,10,0,0"/>
        </StackPanel>
    </StackPanel>
</Window>
  

  #pragma once

#include "MainWindow.g.h"

namespace winrt::WinUI3X::implementation
{
    struct MainWindow : MainWindowT<MainWindow>
    {
    private:
        int32_t manualIndex = 0;
        int32_t sourceIndex = 0;
        int32_t boundIndex = 0;
        winrt::Windows::Foundation::Collections::IObservableVector<hstring> sourceArray{ winrt::single_threaded_observable_vector<hstring>() };
        winrt::Windows::Foundation::Collections::IObservableVector<hstring> boundArray{ winrt::single_threaded_observable_vector<hstring>() };
    public:
        MainWindow();

        winrt::Windows::Foundation::Collections::IObservableVector<hstring> collection();

        void addManualItemButton_Click(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
        void addSourceItemButton_Click(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
        void addBoundItemButton_Click(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
    };
}

namespace winrt::WinUI3X::factory_implementation
{
    struct MainWindow : MainWindowT<MainWindow, implementation::MainWindow>
    {
    };
}
  

  #include "pch.h"
#include "MainWindow.xaml.h"
#if __has_include("MainWindow.g.cpp")
#include "MainWindow.g.cpp"
#endif

using namespace winrt;
using namespace Microsoft::UI::Xaml;

namespace winrt::WinUI3X::implementation
{
	MainWindow::MainWindow() {
		InitializeComponent();
		sourceList().ItemsSource(sourceArray);
	}

	void MainWindow::addManualItemButton_Click(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e)
	{
		manualIndex++;
		manualList().Items().Append(box_value(hstring{ L"Item " + to_hstring(manualIndex) }));
		if (manualList().SelectedItem() == nullptr) manualList().SelectedIndex(0);
	}

	void MainWindow::addSourceItemButton_Click(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e)
	{
		sourceIndex++;
		sourceArray.Append(hstring{ L"Item " + to_hstring(sourceIndex) });
		if (sourceList().SelectedItem() == nullptr) sourceList().SelectedIndex(0);
	}

	winrt::Windows::Foundation::Collections::IObservableVector<hstring> MainWindow::collection() {
		return boundArray;
	}

	void MainWindow::addBoundItemButton_Click(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e)
	{
		boundIndex++;
		boundArray.Append(hstring{ L"Item " + to_hstring(boundIndex) });
		if (boundList().SelectedItem() == nullptr) boundList().SelectedIndex(0);
	}
}
  

  namespace WinUI3X
{
    [default_interface]
    runtimeclass MainWindow : Microsoft.UI.Xaml.Window
    {
        MainWindow();
        Windows.Foundation.Collections.IObservableVector<String> collection{ get; };
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Window
    x:Class="WinUI3X.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3X"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d" 
    Title="Pages and Navigation">

    <local:MainPage/>

</Window>
  

  #pragma once

#include "MainWindow.g.h"

namespace winrt::WinUI3X::implementation
{
    struct MainWindow : MainWindowT<MainWindow>
    {
        MainWindow(){}
    };
}

namespace winrt::WinUI3X::factory_implementation
{
    struct MainWindow : MainWindowT<MainWindow, implementation::MainWindow>
    {
    };
}
  

  #include "pch.h"
#include "MainWindow.xaml.h"
#if __has_include("MainWindow.g.cpp")
#include "MainWindow.g.cpp"
#endif

using namespace winrt;
using namespace Microsoft::UI::Xaml;

namespace winrt::WinUI3X::implementation
{
}
  

  namespace WinUI3X
{
    [default_interface]
    runtimeclass MainWindow : Microsoft.UI.Xaml.Window
    {
        MainWindow();
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Page
    x:Class="WinUI3X.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3X"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d" 
    Loaded="Page_Loaded">
    
    <NavigationView x:Name="nav" IsSettingsVisible="True" ItemInvoked="NavigationView_ItemInvoked" BackRequested="nav_BackRequested">
        <NavigationView.MenuItems>
            <NavigationViewItem Content="Home" Icon="Home" Tag="home"/>
            <NavigationViewItem Content="Other Page" Icon="Page" Tag="other"/>
        </NavigationView.MenuItems>
        <NavigationView.Content>            
            <Frame x:Name="mainFrame" Navigated="mainFrame_Navigated"/>
        </NavigationView.Content>
    </NavigationView>

</Page>
  

  #pragma once

#include "MainPage.g.h"

namespace winrt::WinUI3X::implementation
{
    struct MainPage : MainPageT<MainPage>
    {
    private:
        void openHomePage();
        void openOtherPage();
        void openSettingPage();

    public:
        MainPage(){}

        void Page_Loaded(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
        void NavigationView_ItemInvoked(winrt::Microsoft::UI::Xaml::Controls::NavigationView const& sender, winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemInvokedEventArgs const& args);

        void mainFrame_Navigated(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::Navigation::NavigationEventArgs const& e);
        void nav_BackRequested(winrt::Microsoft::UI::Xaml::Controls::NavigationView const& sender, winrt::Microsoft::UI::Xaml::Controls::NavigationViewBackRequestedEventArgs const& args);
    };
}

namespace winrt::WinUI3X::factory_implementation
{
    struct MainPage : MainPageT<MainPage, implementation::MainPage>
    {
    };
}
  

  #include "pch.h"
#include "MainPage.xaml.h"
#if __has_include("MainPage.g.cpp")
#include "MainPage.g.cpp"
#endif
#include "winrt/Windows.UI.Xaml.Interop.h"

using namespace winrt;
using namespace Microsoft::UI::Xaml;

// To learn more about WinUI, the WinUI project structure,
// and more about our project templates, see: http://aka.ms/winui-project-info.

namespace winrt::WinUI3X::implementation
{
    void MainPage::Page_Loaded(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e)
    {
        // Initialize your stuff here!
    }

    void MainPage::NavigationView_ItemInvoked(winrt::Microsoft::UI::Xaml::Controls::NavigationView const& sender, winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemInvokedEventArgs const& args)
    {
        if (args.IsSettingsInvoked()) {
            openSettingPage();
        }
        else {
            hstring tag = unbox_value<hstring>(args.InvokedItemContainer().Tag());
            if (tag == L"home")
                openHomePage();
            else if (tag == L"other") 
                openOtherPage();
        }
    }

    void MainPage::openHomePage()
    {
        mainFrame().Navigate(xaml_typename<HomePage>());
    }

    void MainPage::openOtherPage()
    {
        mainFrame().Navigate(xaml_typename<OtherPage>());
    }

    void MainPage::openSettingPage()
    {
        mainFrame().Navigate(xaml_typename<SettingsPage>());
    }

    void MainPage::mainFrame_Navigated(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::Navigation::NavigationEventArgs const& e)
    {
        nav().IsBackEnabled(mainFrame().CanGoBack());
    }


    void MainPage::nav_BackRequested(winrt::Microsoft::UI::Xaml::Controls::NavigationView const& sender, winrt::Microsoft::UI::Xaml::Controls::NavigationViewBackRequestedEventArgs const& args)
    {
        mainFrame().GoBack();
    }
}
  

  namespace WinUI3X
{
    [default_interface]
    runtimeclass MainPage : Microsoft.UI.Xaml.Controls.Page
    {
        MainPage();
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Page
    x:Class="WinUI3X.HomePage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3X"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">

    <StackPanel Orientation="Horizontal" HorizontalAlignment="Center" VerticalAlignment="Center">
        <TextBlock Text="This is the HOME page." FontFamily="Arial" FontSize="24"/>
    </StackPanel>
</Page>
  

  #pragma once

#include "HomePage.g.h"

namespace winrt::WinUI3X::implementation
{
    struct HomePage : HomePageT<HomePage>
    {
        HomePage(){}
    };
}

namespace winrt::WinUI3X::factory_implementation
{
    struct HomePage : HomePageT<HomePage, implementation::HomePage>
    {
    };
}
  

  #include "pch.h"
#include "HomePage.xaml.h"
#if __has_include("HomePage.g.cpp")
#include "HomePage.g.cpp"
#endif

using namespace winrt;
using namespace Microsoft::UI::Xaml;

namespace winrt::WinUI3X::implementation
{

}
  

  namespace WinUI3X
{
    [default_interface]
    runtimeclass HomePage : Microsoft.UI.Xaml.Controls.Page
    {
        HomePage();
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Page
    x:Class="WinUI3X.OtherPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3X"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">

    <StackPanel Orientation="Horizontal" HorizontalAlignment="Center" VerticalAlignment="Center">
        <TextBlock Text="This is the OTHER page." FontFamily="Arial" FontSize="24"/>
    </StackPanel>
</Page>
  

  #pragma once

#include "OtherPage.g.h"

namespace winrt::WinUI3X::implementation
{
    struct OtherPage : OtherPageT<OtherPage>
    {
        OtherPage(){}
    };
}

namespace winrt::WinUI3X::factory_implementation
{
    struct OtherPage : OtherPageT<OtherPage, implementation::OtherPage>
    {
    };
}
  

  #include "pch.h"
#include "OtherPage.xaml.h"
#if __has_include("OtherPage.g.cpp")
#include "OtherPage.g.cpp"
#endif

using namespace winrt;
using namespace Microsoft::UI::Xaml;

namespace winrt::WinUI3X::implementation
{

}
  

  namespace WinUI3X
{
    [default_interface]
    runtimeclass OtherPage : Microsoft.UI.Xaml.Controls.Page
    {
        OtherPage();
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Page
    x:Class="WinUI3X.SettingsPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3X"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">

    <StackPanel Orientation="Horizontal" HorizontalAlignment="Center" VerticalAlignment="Center">
        <TextBlock Text="This is the SETTING page." FontFamily="Arial" FontSize="24"/>
    </StackPanel>
</Page>
  

  #pragma once

#include "SettingsPage.g.h"

namespace winrt::WinUI3X::implementation
{
    struct SettingsPage : SettingsPageT<SettingsPage>
    {
        SettingsPage(){}
    };
}

namespace winrt::WinUI3X::factory_implementation
{
    struct SettingsPage : SettingsPageT<SettingsPage, implementation::SettingsPage>
    {
    };
}
  

  #include "pch.h"
#include "SettingsPage.xaml.h"
#if __has_include("SettingsPage.g.cpp")
#include "SettingsPage.g.cpp"
#endif

using namespace winrt;
using namespace Microsoft::UI::Xaml;

namespace winrt::WinUI3X::implementation
{

}
  

  namespace WinUI3X
{
    [default_interface]
    runtimeclass SettingsPage : Microsoft.UI.Xaml.Controls.Page
    {
        SettingsPage();
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Application
    x:Class="WinUI3APP.App"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3APP"
    RequestedTheme="Light">
    <Application.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls" />
                <!-- Other merged dictionaries here -->
            </ResourceDictionary.MergedDictionaries>
            <!-- Other app resources here -->
        </ResourceDictionary>
    </Application.Resources>
</Application>
  

  #pragma once

#include "App.xaml.g.h"

namespace winrt::WinUI3APP::implementation
{
    struct App : AppT<App>
    {
        App();

        void OnLaunched(Microsoft::UI::Xaml::LaunchActivatedEventArgs const&);
        static HWND getMainWindow();

    private:
        static winrt::Microsoft::UI::Xaml::Window window;
    };
}
  

  #include "pch.h"
#include "App.xaml.h"
#include "MainWindow.xaml.h"
#include <microsoft.ui.xaml.window.h>

using namespace winrt;
using namespace Microsoft::UI::Xaml;

// To learn more about WinUI, the WinUI project structure,
// and more about our project templates, see: http://aka.ms/winui-project-info.

namespace winrt::WinUI3APP::implementation
{
    winrt::Microsoft::UI::Xaml::Window App::window{ nullptr };
    /// <summary>
    /// Initializes the singleton application object.  This is the first line of authored code
    /// executed, and as such is the logical equivalent of main() or WinMain().
    /// </summary>
    App::App()
    {
        // Xaml objects should not call InitializeComponent during construction.
        // See https://github.com/microsoft/cppwinrt/tree/master/nuget#initializecomponent

#if defined _DEBUG && !defined DISABLE_XAML_GENERATED_BREAK_ON_UNHANDLED_EXCEPTION
        UnhandledException([](IInspectable const&, UnhandledExceptionEventArgs const& e)
        {
            if (IsDebuggerPresent())
            {
                auto errorMessage = e.Message();
                __debugbreak();
            }
        });
#endif
    }

    /// <summary>
    /// Invoked when the application is launched.
    /// </summary>
    /// <param name="e">Details about the launch request and process.</param>
    void App::OnLaunched([[maybe_unused]] LaunchActivatedEventArgs const& e)
    {
        window = make<MainWindow>();
        window.Activate();
    }
    HWND App::getMainWindow()
    {
        auto windowNative{ App::window.try_as<::IWindowNative>() };
        HWND hwnd{ 0 };
        windowNative->get_WindowHandle(&hwnd);
        return hwnd;
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Page
    x:Class="WinUI3APP.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3APP"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">

    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="Auto"/>
            <ColumnDefinition Width="*"/>
        </Grid.ColumnDefinitions>
        <Button x:Name="selectImageFileButton" Content="Open file" Click="selectImageFileButton_Click"/>
        <Image x:Name="image" Grid.Column="1" Margin="20">
            <Image.Source>
                <BitmapImage x:Name="bmp"/>
            </Image.Source>
        </Image>
    </Grid>
    
</Page>
  

  #pragma once

#include "MainPage.g.h"

namespace winrt::WinUI3APP::implementation
{
    struct MainPage : MainPageT<MainPage>
    {
    private:
        winrt::fire_and_forget openImageFile();
    public:
        MainPage(){}
        void selectImageFileButton_Click(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
    };
}

namespace winrt::WinUI3APP::factory_implementation
{
    struct MainPage : MainPageT<MainPage, implementation::MainPage>
    {
    };
}
  

  #include "pch.h"
#include "MainPage.xaml.h"
#if __has_include("MainPage.g.cpp")
#include "MainPage.g.cpp"
#endif
#include "winrt/Windows.Storage.Pickers.h"
#include "App.xaml.h"
#include <shobjidl.h>

using namespace winrt;
using namespace Microsoft::UI::Xaml;

// To learn more about WinUI, the WinUI project structure,
// and more about our project templates, see: http://aka.ms/winui-project-info.

namespace winrt::WinUI3APP::implementation
{
	void MainPage::selectImageFileButton_Click(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e)
	{
		openImageFile();
	}

	winrt::fire_and_forget MainPage::openImageFile()
	{
		Windows::Storage::Pickers::FileOpenPicker picker{};
		HWND hwnd = App::getMainWindow();
		picker.as<IInitializeWithWindow>()->Initialize(hwnd);
		picker.SuggestedStartLocation(Windows::Storage::Pickers::PickerLocationId::PicturesLibrary);
		picker.FileTypeFilter().Append(L".png");
		Windows::Storage::StorageFile file = co_await picker.PickSingleFileAsync();
		if (file != nullptr) {
			bmp().SetSource(co_await file.OpenAsync(Windows::Storage::FileAccessMode::Read));
		}
	}
}
  

  namespace WinUI3APP
{
    [default_interface]
    runtimeclass MainPage : Microsoft.UI.Xaml.Controls.Page
    {
        MainPage();
    }
}
  

  namespace WinUI3App
{
    [bindable]
    [default_interface]
    runtimeclass UserViewModel 
    {
        UserViewModel();
        void SetUserData(Int32 id, String firstName, String lastName, String email);
        String FirstName{ get; };
        String LastName{ get; };
        String Email{ get; };
        Int32 Id{ get; };
    }
}
  

  #pragma once

#include "UserViewModel.g.h"

namespace winrt::WinUI3App::implementation
{
    struct UserViewModel : UserViewModelT<UserViewModel>
    {
    private:
        int32_t id;
        hstring firstName;
        hstring lastName;
        hstring email;
    public:
        UserViewModel() = default;
        void SetUserData(int32_t _id, hstring _firstName, hstring _lastName, hstring _email);
        hstring FirstName();
        hstring LastName();
        hstring Email();
        int32_t Id();
    };
}

namespace winrt::WinUI3App::factory_implementation
{
    struct UserViewModel : UserViewModelT<UserViewModel, implementation::UserViewModel>
    {
    };
}
  

  #include "pch.h"
#include "UserViewModel.h"
#if __has_include("UserViewModel.g.cpp")
#include "UserViewModel.g.cpp"
#endif

namespace winrt::WinUI3App::implementation
{
    void UserViewModel::SetUserData(int32_t _id, hstring _firstName, hstring _lastName, hstring _email)
    {
        id = _id;
        firstName = _firstName;
        lastName = _lastName;
        email = _email;
    }
    hstring UserViewModel::FirstName()
    {
        return firstName;
    }
    hstring UserViewModel::LastName()
    {
        return lastName;
    }
    hstring UserViewModel::Email()
    {
        return email;
    }
    int32_t UserViewModel::Id() {
        return id;
    }
}
  

  #pragma once
#include "db/sqlite3.h"
#include "UserViewModel.h"

namespace winrt::WinUI3App::implementation {
	class DbHelper
	{
	private:
		sqlite3* db;
		bool doesTableExist(std::string tableName);
		bool doesRecordExist(const char* sql);
		bool executeStatement(const char* sql);
		int getNextId();
		hstring convertToHString(const unsigned char*);

	public:
		void openDataBase(const char* path);
		void closeDatabase();

		void getAllUsers(Windows::Foundation::Collections::IObservableVector<WinUI3App::UserViewModel>& array);
		bool updateUser(int id, hstring firstName, hstring lastName, hstring email);
		bool deleteUser(int id);
	};
}
  

  #include "pch.h"
#include "DbHelper.h"

namespace winrt::WinUI3App::implementation {
	void DbHelper::openDataBase(const char* path)
	{
		int result = sqlite3_open(path, &db);
		if (result == SQLITE_OK) {
			OutputDebugString(L"Amazing!. It actually worked!\r\n");
			if (!doesTableExist("users")) {
				executeStatement(std::string{ "create table users (id int primary key, first_name text, last_name text, email text);" }.c_str());
				OutputDebugString(L"Tabel 'users' created!\r\n");
			}
		}
		else {
			OutputDebugString(L"ERROR: Cannot open db~");
		}
	}

	bool DbHelper::doesTableExist(std::string tableName)
	{
		return doesRecordExist(std::string{ "select 1 from sqlite_master where type='table' and name='" + tableName + "'" }.c_str());
	}

	bool DbHelper::doesRecordExist(const char* sql)
	{
		bool exists = false;
		sqlite3_stmt* st;
		if (sqlite3_prepare_v2(db, sql, -1, &st, NULL) == SQLITE_OK) {
			exists = sqlite3_step(st) == SQLITE_ROW;
		}
		sqlite3_finalize(st);

		return exists;
	}

	bool DbHelper::executeStatement(const char* sql)
	{
		return sqlite3_exec(db, sql, NULL, NULL, NULL) == SQLITE_OK;
	}

	void DbHelper::closeDatabase()
	{
		sqlite3_close(db);
	}

	int DbHelper::getNextId()
	{
		int nextId = 0;
		sqlite3_stmt* st;
		if (sqlite3_prepare_v2(db, "select max(id) from users", -1, &st, NULL) == SQLITE_OK) {
			if (sqlite3_step(st) == SQLITE_ROW)
				nextId = sqlite3_column_int(st, 0);
		}
		sqlite3_finalize(st);
		return ++nextId;
	}

	void DbHelper::getAllUsers(Windows::Foundation::Collections::IObservableVector<WinUI3App::UserViewModel>& array)
	{
		sqlite3_stmt* st;
		if (sqlite3_prepare_v2(db, "select id, first_name, last_name, email from users order by first_name", -1, &st, NULL) == SQLITE_OK) {
			while (sqlite3_step(st) == SQLITE_ROW) {
				WinUI3App::UserViewModel u = winrt::make<WinUI3App::implementation::UserViewModel>();
				u.SetUserData(sqlite3_column_int(st, 0), convertToHString(sqlite3_column_text(st, 1)), convertToHString(sqlite3_column_text(st, 2)), convertToHString(sqlite3_column_text(st, 3)));
				array.Append(u);
			}

		}
		sqlite3_finalize(st);
	}

	bool DbHelper::updateUser(int id, hstring firstName, hstring lastName, hstring email)
	{
		bool updated = false;
		int finalId = id == 0 ? getNextId() : id;
		const char* sql;
		/* Notice we left the field "id" at the end, so both INSERT and UPDATE have the same "bind" field order*/
		if (id == 0) {
			sql = "insert into users (first_name, last_name, email, id) values (?, ?, ?, ?);";
		}
		else {
			sql = "update users set first_name=?, last_name=?, email=? where id=?;";
		}
		sqlite3_stmt* st;
		if (sqlite3_prepare_v2(db, sql, -1, &st, NULL) == SQLITE_OK) {
			sqlite3_bind_text(st, 1, winrt::to_string(firstName).c_str(), -1, SQLITE_TRANSIENT);
			sqlite3_bind_text(st, 2, winrt::to_string(lastName).c_str(), -1, SQLITE_TRANSIENT);
			sqlite3_bind_text(st, 3, winrt::to_string(email).c_str(), -1, SQLITE_TRANSIENT);
			sqlite3_bind_int(st, 4, finalId);
			updated = sqlite3_step(st) == SQLITE_DONE;
		}
		sqlite3_finalize(st);

		return updated;
	}

	bool DbHelper::deleteUser(int id)
	{
		bool deleted = false;
		sqlite3_stmt* st;
		if (sqlite3_prepare_v2(db, "delete from users where id=?", -1, &st, NULL) == SQLITE_OK) {
			sqlite3_bind_int(st, 1, id);
			deleted = sqlite3_step(st) == SQLITE_DONE;
		}
		sqlite3_finalize(st);
		return deleted;
	}

	hstring DbHelper::convertToHString(const unsigned char* value)
	{
		return winrt::to_hstring(std::string{ reinterpret_cast<char const*>(value) });
	}
}
  

  int DbHelper::getNextId()
{
    int nextId = 0;
    sqlite3_stmt* st;
    if (sqlite3_prepare_v2(db, "select max(id) from users", -1, &st, NULL) != SQLITE_OK) {
        OutputDebugString(L"Failed to prepare SQL statement.\n");
        return -1; // 返回错误值
    }

    if (sqlite3_step(st) == SQLITE_ROW) {
        nextId = sqlite3_column_int(st, 0);
    } else {
        OutputDebugString(L"Failed to retrieve the maximum ID.\n");
    }

    sqlite3_finalize(st);
    return ++nextId;
}
  

  create table users (
    id integer primary key autoincrement,
    first_name text,
    last_name text,
    email text
);
  

  int lastId = getNextId(); // 初始化时获取最大 ID
// 插入新记录时：
int newId = ++lastId;
  

  <?xml version="1.0" encoding="utf-8"?>
<Application
    x:Class="WinUI3App.App"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3App"
    RequestedTheme="Light">
    <Application.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls" />
                <!-- Other merged dictionaries here -->
            </ResourceDictionary.MergedDictionaries>
            <!-- Other app resources here -->
        </ResourceDictionary>
    </Application.Resources>
</Application>
  

  #pragma once

#include "App.xaml.g.h"
#include "DbHelper.h"

namespace winrt::WinUI3App::implementation
{
    struct App : AppT<App>
    {
        App();

        void OnLaunched(Microsoft::UI::Xaml::LaunchActivatedEventArgs const&);
        static DbHelper db;

    private:
        winrt::Microsoft::UI::Xaml::Window window{ nullptr };
    };
}
  

  #include "pch.h"
#include "App.xaml.h"
#include "MainWindow.xaml.h"

using namespace winrt;
using namespace Microsoft::UI::Xaml;

namespace winrt::WinUI3App::implementation
{
    DbHelper App::db{};
    App::App()
    {
#if defined _DEBUG && !defined DISABLE_XAML_GENERATED_BREAK_ON_UNHANDLED_EXCEPTION
        UnhandledException([](IInspectable const&, UnhandledExceptionEventArgs const& e)
        {
            if (IsDebuggerPresent())
            {
                auto errorMessage = e.Message();
                __debugbreak();
            }
        });
#endif
    }

    void App::OnLaunched([[maybe_unused]] LaunchActivatedEventArgs const& e)
    {
        window = make<MainWindow>();
        window.Activate();
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Window
    x:Class="WinUI3App.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3App"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Title="WinUI3App">

    <local:MainPage/>
</Window>
  

  #pragma once

#include "MainWindow.g.h"

namespace winrt::WinUI3App::implementation
{
    struct MainWindow : MainWindowT<MainWindow>
    {
        MainWindow(){}
    };
}

namespace winrt::WinUI3App::factory_implementation
{
    struct MainWindow : MainWindowT<MainWindow, implementation::MainWindow>
    {
    };
}
  

  #include "pch.h"
#include "MainWindow.xaml.h"
#if __has_include("MainWindow.g.cpp")
#include "MainWindow.g.cpp"
#endif

using namespace winrt;
using namespace Microsoft::UI::Xaml;

namespace winrt::WinUI3App::implementation
{
}
  

  namespace WinUI3App
{
    [default_interface]
    runtimeclass MainWindow : Microsoft.UI.Xaml.Window
    {
        MainWindow();
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<UserControl
    x:Class="WinUI3App.UpdateUserControl"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3App"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">

    <StackPanel Orientation="Vertical">
        <TextBox x:Name="firstNameBox" InputScope="NameOrPhoneNumber" Margin="0,0,0,12" Header="First name"/>
        <TextBox x:Name="lastNameBox" InputScope="NameOrPhoneNumber" Margin="0,0,0,12" Header="Last name"/>
        <TextBox x:Name="emailBox" InputScope="EmailNameOrAddress" Margin="0,0,0,12" Header="Email address"/>
        <Button x:Name="saveButton" Content="Save" Style="{StaticResource AccentButtonStyle}" HorizontalAlignment="Stretch" Click="saveButton_Click"/>
    </StackPanel>
</UserControl>
  

  #pragma once

#include "UpdateUserControl.g.h"

namespace winrt::WinUI3App::implementation
{
    struct UpdateUserControl : UpdateUserControlT<UpdateUserControl>
    {
    private:
        int32_t id;
        winrt::event < Windows::Foundation::EventHandler<int32_t>> userUpdatedEvent; // The actual event object used internally
    public:
        UpdateUserControl(){}

        void LoadUserData(int32_t _id, hstring firstName, hstring lastName, hstring email);
        winrt::event_token UserUpdated(const Windows::Foundation::EventHandler<int32_t>& handler); // Add an event handler and returns token
        void UserUpdated(const winrt::event_token& token); // Use the token to remove event handler        
        void saveButton_Click(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
    };
}

namespace winrt::WinUI3App::factory_implementation
{
    struct UpdateUserControl : UpdateUserControlT<UpdateUserControl, implementation::UpdateUserControl>
    {
    };
}
  

  #include "pch.h"
#include "UpdateUserControl.xaml.h"
#if __has_include("UpdateUserControl.g.cpp")
#include "UpdateUserControl.g.cpp"
#endif
#include "App.xaml.h"

using namespace winrt;
using namespace Microsoft::UI::Xaml;

namespace winrt::WinUI3App::implementation
{
	void UpdateUserControl::LoadUserData(int32_t _id, hstring firstName, hstring lastName, hstring email)
	{
		id = _id;
		firstNameBox().Text(firstName);
		lastNameBox().Text(lastName);
		emailBox().Text(email);
	}

	winrt::event_token UpdateUserControl::UserUpdated(const Windows::Foundation::EventHandler<int32_t>& handler)
	{
		// Add a new event handler (or listner)
		return userUpdatedEvent.add(handler);
	}

	void UpdateUserControl::UserUpdated(const winrt::event_token& token)
	{
		// Remove the event handler (or listner)
		userUpdatedEvent.remove(token);
	}

	void UpdateUserControl::saveButton_Click(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e)
	{
		if (firstNameBox().Text().empty()) {
			firstNameBox().Focus(Microsoft::UI::Xaml::FocusState::Keyboard);
			return;
		}
		if (lastNameBox().Text().empty()) {
			lastNameBox().Focus(Microsoft::UI::Xaml::FocusState::Keyboard);
			return;
		}
		if (emailBox().Text().empty()) {
			emailBox().Focus(Microsoft::UI::Xaml::FocusState::Keyboard);
			return;
		}
		bool saved = App::db.updateUser(id, firstNameBox().Text(), lastNameBox().Text(), emailBox().Text());
		if (saved) {
			OutputDebugString(L"Saved!");
			firstNameBox().Text(L"");
			lastNameBox().Text(L"");
			emailBox().Text(L"");
			firstNameBox().Focus(Microsoft::UI::Xaml::FocusState::Keyboard);
		}
		userUpdatedEvent(*this, 0);
	}
}
  

  namespace WinUI3App
{
    [default_interface]
    runtimeclass UpdateUserControl : Microsoft.UI.Xaml.Controls.UserControl
    {
        UpdateUserControl();
        void LoadUserData(Int32 id, String firstName, String lastName, String email);
        event Windows.Foundation.EventHandler<Int32> UserUpdated;
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Page
    x:Class="WinUI3App.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3App"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Loaded="Page_Loaded"
    Unloaded="Page_Unloaded">

    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="*"/>
            <ColumnDefinition Width="320"/>
        </Grid.ColumnDefinitions>

        <TextBlock x:Name="itemCountBlock" Margin="12"/>
        <Button x:Name="newUserButton" Content="New Users" HorizontalAlignment="Right" Click="newUserButton_Click"/>
        <ListView x:Name="userList" Grid.Row="1" ItemsSource="{x:Bind userArray}">
            <ListView.Resources>
                <MenuFlyout x:Key="contextMenu">
                    <MenuFlyoutItem x:Name="editButton" Icon="Edit" Text="Edit" Click="editButton_Click"/>
                    <MenuFlyoutItem x:Name="deleteButton" Icon="Delete" Text="Delete" Click="deleteButton_Click"/>
                </MenuFlyout>
            </ListView.Resources>
            <ListView.ItemTemplate>
                <DataTemplate x:DataType="local:UserViewModel">
                    <StackPanel Orientation="Vertical" Background="Transparent" ContextFlyout="{StaticResource contextMenu}">
                        <TextBlock>
                            <Run Text="{x:Bind FirstName}"/>
                            <Run Text="{x:Bind LastName}"/>
                        </TextBlock>
                        <TextBlock Style="{StaticResource CaptionTextBlockStyle}" Text="{x:Bind Email}"/>
                    </StackPanel>
                </DataTemplate>
            </ListView.ItemTemplate>
        </ListView>

        <Border BorderBrush="LightGray" BorderThickness="1,0,0,0" Padding="8" Grid.Column="1" Grid.Row="1">
            <ContentControl x:Name="rightPanel" HorizontalContentAlignment="Stretch"/>
        </Border>
    </Grid>

</Page>
  

  #pragma once

#include "MainPage.g.h"
#include "UserViewModel.h"

namespace winrt::WinUI3App::implementation
{
    struct MainPage : MainPageT<MainPage>
    {
    private:       
        void closeDatabase();
        Windows::Foundation::Collections::IObservableVector<WinUI3App::UserViewModel> _userArray{ winrt::single_threaded_observable_vector<WinUI3App::UserViewModel>() };
        void loadAllUsers();   
        void closeRightPanel();

    public:
        MainPage(){}

        void Page_Loaded(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
        void Page_Unloaded(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);

        Windows::Foundation::Collections::IObservableVector<WinUI3App::UserViewModel> userArray();
        void newUserButton_Click(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
        void editButton_Click(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
        void deleteButton_Click(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
    };
}

namespace winrt::WinUI3App::factory_implementation
{
    struct MainPage : MainPageT<MainPage, implementation::MainPage>
    {
    };
}
  

  #include "pch.h"
#include "MainPage.xaml.h"
#if __has_include("MainPage.g.cpp")
#include "MainPage.g.cpp"
#endif
#include <winrt/Windows.Storage.h>
#include "App.xaml.h"
#include "UpdateUserControl.xaml.h"

using namespace winrt;
using namespace Microsoft::UI::Xaml;

namespace winrt::WinUI3App::implementation
{
	void MainPage::Page_Loaded(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e)
	{
		std::string path = winrt::to_string(Windows::Storage::ApplicationData::Current().LocalFolder().Path() + L"\\database.db");
		const char* dbFilename = path.c_str();
		App::db.openDataBase(dbFilename);
		loadAllUsers();
	}

	void MainPage::Page_Unloaded(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e)
	{
		closeDatabase();
	}

	void MainPage::closeDatabase()
	{
		App::db.closeDatabase();
	}

	Windows::Foundation::Collections::IObservableVector<WinUI3App::UserViewModel> MainPage::userArray()
	{
		return _userArray;
	}

	void MainPage::loadAllUsers()
	{
		_userArray.Clear();
		App::db.getAllUsers(_userArray);
		itemCountBlock().Text(winrt::to_hstring(_userArray.Size()) + L" Users");
	}

	void MainPage::closeRightPanel()
	{
		rightPanel().Content(nullptr);
	}

	void MainPage::newUserButton_Click(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e)
	{
		WinUI3App::UpdateUserControl update = winrt::make<WinUI3App::implementation::UpdateUserControl>();
		update.UserUpdated([this](const IInspectable&, int32_t) {
			closeRightPanel();
			loadAllUsers();
			});
		rightPanel().Content(update);
	}

	void MainPage::editButton_Click(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e)
	{
		WinUI3App::UserViewModel user = sender.try_as<Microsoft::UI::Xaml::FrameworkElement>().DataContext().try_as<WinUI3App::UserViewModel>();
		WinUI3App::UpdateUserControl update = winrt::make<WinUI3App::implementation::UpdateUserControl>();
		update.LoadUserData(user.Id(), user.FirstName(), user.LastName(), user.Email());
		update.UserUpdated([this](const IInspectable&, int32_t) {
			closeRightPanel();
			loadAllUsers();
			});
		rightPanel().Content(update);
	}

	void MainPage::deleteButton_Click(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e)
	{
		WinUI3App::UserViewModel user = sender.try_as<Microsoft::UI::Xaml::FrameworkElement>().DataContext().try_as<WinUI3App::UserViewModel>();
		if (App::db.deleteUser(user.Id())) {
			closeRightPanel();
			loadAllUsers();
		}
	}

}
  

  import "UserViewModel.idl";
namespace WinUI3App
{
    [default_interface]
    runtimeclass MainPage : Microsoft.UI.Xaml.Controls.Page
    {
        MainPage();
        Windows.Foundation.Collections.IObservableVector<UserViewModel>userArray{ get; };
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Application
    x:Class="WinUI3Experiment.App"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3Experiment"
    RequestedTheme="Light">
    <Application.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls" />
                <!-- Other merged dictionaries here -->
            </ResourceDictionary.MergedDictionaries>
            <!-- Other app resources here -->
        </ResourceDictionary>
    </Application.Resources>
</Application>
  

  #pragma once

#include "App.xaml.g.h"

namespace winrt::WinUI3Experiment::implementation
{
    struct App : AppT<App>
    {
        App();

        void OnLaunched(Microsoft::UI::Xaml::LaunchActivatedEventArgs const&);
           
        static winrt::Microsoft::UI::Xaml::Window window;
    };
}
  

  #include "pch.h"
#include "App.xaml.h"
#include "MainWindow.xaml.h"

using namespace winrt;
using namespace Microsoft::UI::Xaml;

namespace winrt::WinUI3Experiment::implementation
{
    winrt::Microsoft::UI::Xaml::Window App::window{ nullptr };
    App::App()
    {
#if defined _DEBUG && !defined DISABLE_XAML_GENERATED_BREAK_ON_UNHANDLED_EXCEPTION
        UnhandledException([](IInspectable const&, UnhandledExceptionEventArgs const& e)
        {
            if (IsDebuggerPresent())
            {
                auto errorMessage = e.Message();
                __debugbreak();
            }
        });
#endif
    }
    void App::OnLaunched([[maybe_unused]] LaunchActivatedEventArgs const& e)
    {
        window = make<MainWindow>();
        window.Activate();
    }
}
  

  namespace WinUI3Experiment
{
    [bindable]
    [default_interface]
    runtimeclass ContactViewModel 
    {
        ContactViewModel();
        String Name{ get; };
        String Country{ get; };
        void SetContactData(String _name, String _country);
    }
}
  

  #pragma once

#include "ContactViewModel.g.h"

namespace winrt::WinUI3Experiment::implementation
{
    struct ContactViewModel : ContactViewModelT<ContactViewModel>
    {
    private:
        winrt::hstring name;
        winrt::hstring country;
    public:
        ContactViewModel() = default;

        winrt::hstring Name();
        winrt::hstring Country();
        void SetContactData(winrt::hstring, winrt::hstring);

    };
}

namespace winrt::WinUI3Experiment::factory_implementation
{
    struct ContactViewModel : ContactViewModelT<ContactViewModel, implementation::ContactViewModel>
    {
    };
}
  

  #include "pch.h"
#include "ContactViewModel.h"
#if __has_include("ContactViewModel.g.cpp")
#include "ContactViewModel.g.cpp"
#endif

namespace winrt::WinUI3Experiment::implementation
{
	winrt::hstring ContactViewModel::Name() {
		return name;
	}

	winrt::hstring ContactViewModel::Country() {
		return country;
	}

	void ContactViewModel::SetContactData(winrt::hstring _name, winrt::hstring _country) {
		name = _name;
		country = _country;
	}
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Page
    x:Class="WinUI3Experiment.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3Experiment"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Loaded="Page_Loaded">

    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="400"/>
            <ColumnDefinition Width="*"/>
        </Grid.ColumnDefinitions>
        <Border BorderBrush="{ThemeResource SystemListLowColor}" BorderThickness="0,0,1,0" Padding="20">
            <ListView x:Name="list">
                <ListView.ItemTemplate>
                    <DataTemplate x:DataType="local:ContactViewModel">
                        <Grid Padding="8" Background="Transparent" PointerEntered="Grid_PointerEntered" PointerExited="Grid_PointerExited">
                            <Grid.ColumnDefinitions>
                                <ColumnDefinition Width="Auto"/>
                                <ColumnDefinition Width="*"/>
                                <ColumnDefinition Width="Auto"/>
                            </Grid.ColumnDefinitions>
                            <FontIcon Glyph="&#xE13D;"/>
                            <TextBlock Text="{x:Bind Name}" Grid.Column="1" Margin="12,0,0,0"/>
                            <TextBlock Text="{x:Bind Country}" Grid.Column="2"/>
                        </Grid>
                    </DataTemplate>
                </ListView.ItemTemplate>
            </ListView>
        </Border>      
    </Grid>    
</Page>
  

  #pragma once

#include "MainPage.g.h"
#include "ContactViewModel.h"

namespace winrt::WinUI3Experiment::implementation
{
    struct MainPage : MainPageT<MainPage>
    {
    private:
        Windows::Foundation::Collections::IObservableVector< WinUI3Experiment::ContactViewModel> contactArray{ winrt::single_threaded_observable_vector<WinUI3Experiment::ContactViewModel>()};
        void prepareContactData();
        Microsoft::UI::Composition::SpringVector3NaturalMotionAnimation animation{ nullptr };
        void initSpringAnimation();
        void startAnimation(Microsoft::UI::Xaml::Controls::Grid grid, float scale);

    public:
        MainPage(){}

        void Page_Loaded(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
        void Grid_PointerEntered(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::Input::PointerRoutedEventArgs const& e);
        void Grid_PointerExited(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::Input::PointerRoutedEventArgs const& e);
    };
}

namespace winrt::WinUI3Experiment::factory_implementation
{
    struct MainPage : MainPageT<MainPage, implementation::MainPage>
    {
    };
}
  

  #include "pch.h"
#include "MainPage.xaml.h"
#if __has_include("MainPage.g.cpp")
#include "MainPage.g.cpp"
#endif
#include "App.xaml.h"

using namespace winrt;
using namespace Microsoft::UI::Xaml;

namespace winrt::WinUI3Experiment::implementation
{
	void MainPage::Page_Loaded(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e)
	{
		list().ItemsSource(contactArray);
		prepareContactData();
		initSpringAnimation();
	}

	void MainPage::prepareContactData() {
		WinUI3Experiment::ContactViewModel contact = winrt::make<WinUI3Experiment::implementation::ContactViewModel>();
		contact.SetContactData(L"Liam O'Connor", L"Ireland");
		contactArray.Append(contact);

		contact = winrt::make<WinUI3Experiment::implementation::ContactViewModel>();
		contact.SetContactData(L"Maria Garcia", L"Spain");
		contactArray.Append(contact);

		contact = winrt::make<WinUI3Experiment::implementation::ContactViewModel>();
		contact.SetContactData(L"Yuki Takahashi", L"Japan");
		contactArray.Append(contact);

		contact = winrt::make<WinUI3Experiment::implementation::ContactViewModel>();
		contact.SetContactData(L"Sofia Petrova", L"Russia");
		contactArray.Append(contact);

		contact = winrt::make<WinUI3Experiment::implementation::ContactViewModel>();
		contact.SetContactData(L"David Johnson", L"United States");
		contactArray.Append(contact);

		contact = winrt::make<WinUI3Experiment::implementation::ContactViewModel>();
		contact.SetContactData(L"Marco Rossi", L"Italy");
		contactArray.Append(contact);

		contact = winrt::make<WinUI3Experiment::implementation::ContactViewModel>();
		contact.SetContactData(L"Juan Rodríguez", L"Mexico");
		contactArray.Append(contact);
	}

	void MainPage::initSpringAnimation()
	{
		animation = App::window.Compositor().CreateSpringVector3Animation();
		animation.Target(L"Scale");

	}

	void MainPage::startAnimation(Microsoft::UI::Xaml::Controls::Grid grid, float scale)
	{
		animation.FinalValue(Windows::Foundation::Numerics::float3{ scale });
		grid.CenterPoint(Windows::Foundation::Numerics::float3{ (grid.ActualSize().x / 2.f),(grid.ActualSize().y / 2.f), 1.f });
		grid.StartAnimation(animation);
	}

	void MainPage::Grid_PointerEntered(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::Input::PointerRoutedEventArgs const& e)
	{
		startAnimation(sender.try_as<Microsoft::UI::Xaml::Controls::Grid>(), 1.1f);
	}


	void MainPage::Grid_PointerExited(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::Input::PointerRoutedEventArgs const& e)
	{
		startAnimation(sender.try_as<Microsoft::UI::Xaml::Controls::Grid>(), 1.0f);
	}
}
  

  namespace WinUI3Experiment
{
    [default_interface]
    runtimeclass MainPage : Microsoft.UI.Xaml.Controls.Page
    {
        MainPage();
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Page
    x:Class="WinUI3Experiment.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3Experiment"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">

    <StackPanel Orientation="Horizontal" Margin="40">
        <Button x:Name="requestButton" Content="Request" VerticalAlignment="Top" Click="requestButton_Click"/>
        <ProgressRing x:Name="pRing" Width="20" Height="20" IsActive="False" VerticalAlignment="Top" Margin="4"/>
        <Border BorderBrush="Gray" Padding="8" BorderThickness="1" Margin="20,0,0,0" VerticalAlignment="Top" Width="480" CornerRadius="4">
            <TextBlock x:Name="responseBlock" Style="{StaticResource SubtitleTextBlockStyle}" TextWrapping="Wrap"/>
        </Border>
    </StackPanel>  
</Page>
  

  #pragma once

#include "MainPage.g.h"

namespace winrt::WinUI3Experiment::implementation
{
    struct MainPage : MainPageT<MainPage>
    {
    private:
        Windows::Foundation::IAsyncAction callEndpoint();
        void parseJoke(winrt::hstring json);

    public:
        MainPage(){}

        void requestButton_Click(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e);
    };
}

namespace winrt::WinUI3Experiment::factory_implementation
{
    struct MainPage : MainPageT<MainPage, implementation::MainPage>
    {
    };
}
  

  #include "pch.h"
#include "MainPage.xaml.h"
#if __has_include("MainPage.g.cpp")
#include "MainPage.g.cpp"
#endif
#include <sstream>

using namespace winrt;
using namespace Microsoft::UI::Xaml;

namespace winrt::WinUI3Experiment::implementation
{
	void MainPage::requestButton_Click(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e)
	{
		callEndpoint();
	}

	Windows::Foundation::IAsyncAction MainPage::callEndpoint()
	{
		pRing().IsActive(true);
		Windows::Foundation::Uri url{ L"https://official-joke-api.appspot.com/random_joke" };
		Windows::Web::Http::Filters::HttpBaseProtocolFilter filter{};
		filter.CacheControl().ReadBehavior(Windows::Web::Http::Filters::HttpCacheReadBehavior::MostRecent);
		Windows::Web::Http::HttpClient client{ filter };

		try {
			auto response{ co_await client.GetAsync(url) };
			if (response.IsSuccessStatusCode()) {
				winrt::hstring content = co_await response.Content().ReadAsStringAsync();
				parseJoke(content);
			}
		}
		catch (winrt::hresult_error& ex) {
			responseBlock().Text(ex.message().c_str());
		}
		client.Close();
		pRing().IsActive(false);
		co_return;
	}

	void MainPage::parseJoke(winrt::hstring json)
	{
		//OutputDebugString(json.c_str());
		//OutputDebugString(L"\r\n");
		Windows::Data::Json::JsonObject obj{ Windows::Data::Json::JsonObject::Parse(json) };
		std::wostringstream joke;
		joke << obj.GetNamedString(L"setup");
		joke << "\r\n\r\n";
		joke << obj.GetNamedString(L"punchline");
		responseBlock().Text(joke.str().c_str());
	}
}
  

  namespace WinUI3Experiment
{
    [default_interface]
    runtimeclass MainPage : Microsoft.UI.Xaml.Controls.Page
    {
        MainPage();
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Application
    x:Class="WinUI3CSharp.App"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3CSharp">
    <Application.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls" />
                <!-- Other merged dictionaries here -->
            </ResourceDictionary.MergedDictionaries>
            <!-- Other app resources here -->
        </ResourceDictionary>
    </Application.Resources>
</Application>
  

  using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Controls.Primitives;
using Microsoft.UI.Xaml.Data;
using Microsoft.UI.Xaml.Input;
using Microsoft.UI.Xaml.Media;
using Microsoft.UI.Xaml.Navigation;
using Microsoft.UI.Xaml.Shapes;
using Windows.ApplicationModel;
using Windows.ApplicationModel.Activation;
using Windows.Foundation;
using Windows.Foundation.Collections;

// To learn more about WinUI, the WinUI project structure,
// and more about our project templates, see: http://aka.ms/winui-project-info.

namespace WinUI3CSharp
{
    /// <summary>
    /// Provides application-specific behavior to supplement the default Application class.
    /// </summary>
    public partial class App : Application
    {
        /// <summary>
        /// Initializes the singleton application object.  This is the first line of authored code
        /// executed, and as such is the logical equivalent of main() or WinMain().
        /// </summary>
        public App()
        {
            this.InitializeComponent();
        }

        /// <summary>
        /// Invoked when the application is launched.
        /// </summary>
        /// <param name="args">Details about the launch request and process.</param>
        protected override void OnLaunched(Microsoft.UI.Xaml.LaunchActivatedEventArgs args)
        {
            m_window = new MainWindow();
            m_window.Activate();
        }

        private Window? m_window;
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Window
    x:Class="WinUI3CSharp.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3CSharp"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Title="WinUI3CSharp">

    <StackPanel Orientation="Horizontal" HorizontalAlignment="Center" VerticalAlignment="Center">
        <Button x:Name="myButton" Click="myButton_Click">Click Me</Button>
    </StackPanel>
</Window>
  

  using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Controls.Primitives;
using Microsoft.UI.Xaml.Data;
using Microsoft.UI.Xaml.Input;
using Microsoft.UI.Xaml.Media;
using Microsoft.UI.Xaml.Navigation;
using Windows.Foundation;
using Windows.Foundation.Collections;

// To learn more about WinUI, the WinUI project structure,
// and more about our project templates, see: http://aka.ms/winui-project-info.

namespace WinUI3CSharp
{
    /// <summary>
    /// An empty window that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainWindow : Window
    {
        public MainWindow()
        {
            this.InitializeComponent();
        }

        private void myButton_Click(object sender, RoutedEventArgs e)
        {
            myButton.Content = "Clicked";
        }
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Window
    x:Class="WinUI3CSharp.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3CSharp"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Title="WinUI3CSharp">

    <StackPanel Orientation="Vertical" HorizontalAlignment="Center" VerticalAlignment="Center">
        <Button x:Name="myButton" Click="myButton_Click" Content="Click Me" Style="{StaticResource AccentButtonStyle}" HorizontalAlignment="Center"/>
        <TextBlock x:Name="TB_SayHi" FontFamily="Arial" FontSize="24" FontStyle="Italic" TextWrapping="WrapWholeWords" CharacterSpacing="200" Foreground="CornflowerBlue" Text="Hi, there." Margin="0,10,0,0" />
    </StackPanel>
</Window>
  

  using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Controls.Primitives;
using Microsoft.UI.Xaml.Data;
using Microsoft.UI.Xaml.Input;
using Microsoft.UI.Xaml.Media;
using Microsoft.UI.Xaml.Navigation;
using Windows.Foundation;
using Windows.Foundation.Collections;

// To learn more about WinUI, the WinUI project structure,
// and more about our project templates, see: http://aka.ms/winui-project-info.

namespace WinUI3CSharp
{
    /// <summary>
    /// An empty window that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainWindow : Window
    {
        public MainWindow()
        {
            this.InitializeComponent();
        }

        private void myButton_Click(object sender, RoutedEventArgs e)
        {
            myButton.Content = "Clicked";
            TB_SayHi.Text = "Hello World!";
        }
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Page
    x:Class="WinUI3CSharp.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3CSharp"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>

        <TextBlock TextWrapping="WrapWholeWords"
                           Margin="10,25,0,12"
                           Text="If you have five or more equally important navigation categories that should prominently appear on larger window widths, consider using a left navigation pane." />

        <NavigationView x:Name="nvSample5" 
                                            Grid.Row="1" 
                                            Height="Auto"
                                            Header="This is Header Text" 
                                            PaneDisplayMode="Auto" 
                                            IsTabStop="False" 
                                            SelectionChanged="NavigationView_SelectionChanged5" >
            <NavigationView.MenuItems>
                <NavigationViewItem Content="Menu Bar" Tag="MenuBar" Icon="Bullets" />
                <NavigationViewItem Content="Selector Bar" Tag="SelectorBar" Icon="Forward" />
                <NavigationViewItem Content="Command Bar" Tag="CommandBar" Icon="SwitchApps" />
                <NavigationViewItem Content="Scratch Pad" Tag="ScratchPad" Icon="Go" />
            </NavigationView.MenuItems>
            <Frame Margin="0,0,0,0" x:Name="contentFrame5" />
        </NavigationView>
    </Grid>

</Page>
  

  using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using System.Text.RegularExpressions;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Controls.Primitives;
using Microsoft.UI.Xaml.Data;
using Microsoft.UI.Xaml.Input;
using Microsoft.UI.Xaml.Media;
using Microsoft.UI.Xaml.Navigation;
using Windows.Foundation;
using Windows.Foundation.Collections;

using WinUI3CSharp.SamplePages;

// To learn more about WinUI, the WinUI project structure,
// and more about our project templates, see: http://aka.ms/winui-project-info.

namespace WinUI3CSharp
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainPage : Page
    {
        public MainPage()
        {
            this.InitializeComponent();
        }

        private void NavigationView_SelectionChanged5(NavigationView sender, NavigationViewSelectionChangedEventArgs args)
        {
            if (args.IsSettingsSelected)
            {
                contentFrame5.Navigate(typeof(WebViewToPage));
            }
            else
            {
                var selectedItem = (Microsoft.UI.Xaml.Controls.NavigationViewItem)args.SelectedItem;
                string selectedItemTag = ((string)selectedItem.Tag);
                sender.Header = SplitPascalCaseToSentence(selectedItemTag);
                string pageName = "WinUI3CSharp.SamplePages." + selectedItemTag;
                Type pageType = Type.GetType(pageName);
                contentFrame5.Navigate(pageType);
            }
        }

        static string SplitPascalCaseToSentence(string input)
        {
            // Add space before each uppercase letter, except the first one
            string result = Regex.Replace(input, @"([a-z])([A-Z])", "$1 $2");

            // Capitalize the first letter of the result string
            result = char.ToUpper(result[0]) + result.Substring(1);

            return result;
        }
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Page
    x:Class="WinUI3CSharp.SamplePages.MenuBar"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3CSharp.SamplePages"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

    <StackPanel>
        <TextBlock x:Name="SelectedOptionText2" Text="" Margin="12,10,0,0"/>
        <MenuBar x:Name="Example3">
            <MenuBarItem Title="File">
                <MenuFlyoutSubItem Text="New">
                    <MenuFlyoutItem x:Name="z1" Text="Plain Text Document" Click="OnElementClicked"/>
                    <MenuFlyoutItem x:Name="z2" Text="Rich Text Document" Click="OnElementClicked"/>
                    <MenuFlyoutItem x:Name="z3" Text="Other Formats" Click="OnElementClicked"/>
                </MenuFlyoutSubItem>
                <MenuFlyoutItem x:Name="z4" Text="Open" Click="OnElementClicked"/>
                <MenuFlyoutItem x:Name="z5" Text="Save" Click="OnElementClicked"/>
                <MenuFlyoutSeparator />
                <MenuFlyoutItem x:Name="z6" Text="Exit" Click="OnElementClicked"/>
            </MenuBarItem>

            <MenuBarItem Title="Edit">
                <MenuFlyoutItem x:Name="z7" Text="Undo" Click="OnElementClicked"/>
                <MenuFlyoutItem x:Name="z8" Text="Cut" Click="OnElementClicked"/>
                <MenuFlyoutItem x:Name="z9" Text="Copy" Click="OnElementClicked"/>
                <MenuFlyoutItem x:Name="z11" Text="Paste" Click="OnElementClicked"/>
            </MenuBarItem>

            <MenuBarItem Title="View">
                <MenuFlyoutItem x:Name="z12" Text="Output" Click="OnElementClicked"/>
                <MenuFlyoutSeparator/>
                <RadioMenuFlyoutItem x:Name="z13" Text="Landscape" GroupName="OrientationGroup" Click="OnElementClicked"/>
                <RadioMenuFlyoutItem x:Name="z14" Text="Portrait" GroupName="OrientationGroup" IsChecked="True" Click="OnElementClicked"/>
                <MenuFlyoutSeparator/>
                <RadioMenuFlyoutItem x:Name="z15" Text="Small icons" GroupName="SizeGroup" Click="OnElementClicked"/>
                <RadioMenuFlyoutItem x:Name="z16" Text="Medium icons" IsChecked="True" GroupName="SizeGroup" Click="OnElementClicked"/>
                <RadioMenuFlyoutItem x:Name="z17" Text="Large icons" GroupName="SizeGroup" Click="OnElementClicked"/>
            </MenuBarItem>

            <MenuBarItem Title="Help">
                <MenuFlyoutItem x:Name="z18" Text="About" Click="OnElementClicked"/>
            </MenuBarItem>
        </MenuBar>
    </StackPanel>
</Page>
  

  using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Controls.Primitives;
using Microsoft.UI.Xaml.Data;
using Microsoft.UI.Xaml.Input;
using Microsoft.UI.Xaml.Media;
using Microsoft.UI.Xaml.Navigation;
using Windows.Foundation;
using Windows.Foundation.Collections;

// To learn more about WinUI, the WinUI project structure,
// and more about our project templates, see: http://aka.ms/winui-project-info.

namespace WinUI3CSharp.SamplePages
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MenuBar : Page
    {
        public MenuBar()
        {
            this.InitializeComponent();
        }

        private void OnElementClicked(object sender, RoutedEventArgs e)
        {
            //var selectedFlyoutItem = sender as MenuFlyoutItem;
            //string exampleNumber = selectedFlyoutItem.Name.Substring(0, 1);

            SelectedOptionText2.Text = "You clicked: " + (sender as MenuFlyoutItem).Text;

        }
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Page
    x:Class="WinUI3CSharp.SamplePages.CommandBar"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3CSharp.SamplePages"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="*"/>
            <ColumnDefinition Width="Auto"/>
        </Grid.ColumnDefinitions>

        <StackPanel Grid.Column="0" HorizontalAlignment="Left">
            <CommandBar x:Name="PrimaryCommandBar" IsOpen="False" DefaultLabelPosition="Right">
                <AppBarButton x:Name="addButton" Icon="Add" Label="Add" Click="OnElementClicked"/>
                <AppBarButton x:Name="editButton" Icon="Edit" Label="Edit" Click="OnElementClicked"/>
                <AppBarButton x:Name="shareButton" Icon="Share" Label="Share" Click="OnElementClicked"/>
                <CommandBar.SecondaryCommands>
                    <AppBarButton x:Name="settingsButton" Icon="Setting" Label="Settings" Click="OnElementClicked">
                        <AppBarButton.KeyboardAccelerators>
                            <KeyboardAccelerator Modifiers="Control" Key="I" />
                        </AppBarButton.KeyboardAccelerators>
                    </AppBarButton>
                </CommandBar.SecondaryCommands>
            </CommandBar>
            <TextBlock x:Name="SelectedOptionText" Padding="0,8,0,0"></TextBlock>
        </StackPanel>

        <StackPanel Grid.Column="1" HorizontalAlignment="Right">
            <TextBlock Text="Show or hide" />
            <Button Margin="0,12,0,0" Content="Open command bar" Click="OpenButton_Click" />
            <Button Margin="0,12,0,0" Content="Close command bar" Click="CloseButton_Click" />
            <TextBlock Margin="0,16,0,0" Text="Modify content" />
            <Button Margin="0,12,0,0" Content="Add secondary commands" Click="AddSecondaryCommands_Click" />
            <Button Margin="0,12,0,0" Content="Remove secondary commands" Click="RemoveSecondaryCommands_Click" />
        </StackPanel>
    </Grid>
</Page>
  

  using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Controls.Primitives;
using Microsoft.UI.Xaml.Data;
using Microsoft.UI.Xaml.Input;
using Microsoft.UI.Xaml.Media;
using Microsoft.UI.Xaml.Navigation;
using Windows.Foundation;
using Windows.Foundation.Collections;

// To learn more about WinUI, the WinUI project structure,
// and more about our project templates, see: http://aka.ms/winui-project-info.

namespace WinUI3CSharp.SamplePages
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class CommandBar : Page, INotifyPropertyChanged
    {
        private bool multipleButtons = false;

        public bool MultipleButtons
        {
            get
            {
                return multipleButtons;
            }
            set
            {
                multipleButtons = value;
                OnPropertyChanged("MultipleButtons");
            }
        }

        public event PropertyChangedEventHandler PropertyChanged;

        public void OnPropertyChanged(string PropertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(PropertyName));
        }
        public CommandBar()
        {
            this.InitializeComponent();
            AddKeyboardAccelerators();
        }

        private void OpenButton_Click(object sender, RoutedEventArgs e)
        {
            PrimaryCommandBar.IsOpen = true;
            PrimaryCommandBar.IsSticky = true;
        }

        private void CloseButton_Click(object sender, RoutedEventArgs e)
        {
            PrimaryCommandBar.IsOpen = false;
            PrimaryCommandBar.IsSticky = false;
        }

        private void OnElementClicked(object sender, Microsoft.UI.Xaml.RoutedEventArgs e)
        {
            SelectedOptionText.Text = "You clicked: " + (sender as AppBarButton).Label;
        }

        private void AddSecondaryCommands_Click(object sender, RoutedEventArgs e)
        {
            // Add compact button to the command bar. It provides functionality specific
            // to this page, and is removed when leaving the page.

            if (PrimaryCommandBar.SecondaryCommands.Count == 1)
            {
                var newButton = new AppBarButton();
                newButton.Icon = new SymbolIcon(Symbol.Add);
                newButton.Label = "Button 1";
                newButton.KeyboardAccelerators.Add(new Microsoft.UI.Xaml.Input.KeyboardAccelerator()
                {
                    Key = Windows.System.VirtualKey.N,
                    Modifiers = Windows.System.VirtualKeyModifiers.Control
                });
                PrimaryCommandBar.SecondaryCommands.Add(newButton);

                newButton = new AppBarButton
                {
                    Icon = new SymbolIcon(Symbol.Delete),
                    Label = "Button 2"
                };
                PrimaryCommandBar.SecondaryCommands.Add(newButton);
                newButton.KeyboardAccelerators.Add(new Microsoft.UI.Xaml.Input.KeyboardAccelerator()
                {
                    Key = Windows.System.VirtualKey.Delete
                });
                PrimaryCommandBar.SecondaryCommands.Add(new AppBarSeparator());

                newButton = new AppBarButton();
                newButton.Icon = new SymbolIcon(Symbol.FontDecrease);
                newButton.Label = "Button 3";
                newButton.KeyboardAccelerators.Add(new Microsoft.UI.Xaml.Input.KeyboardAccelerator()
                {
                    Key = Windows.System.VirtualKey.Subtract,
                    Modifiers = Windows.System.VirtualKeyModifiers.Control
                });
                PrimaryCommandBar.SecondaryCommands.Add(newButton);

                newButton = new AppBarButton();
                newButton.Icon = new SymbolIcon(Symbol.FontIncrease);
                newButton.Label = "Button 4";
                newButton.KeyboardAccelerators.Add(new Microsoft.UI.Xaml.Input.KeyboardAccelerator()
                {
                    Key = Windows.System.VirtualKey.Add,
                    Modifiers = Windows.System.VirtualKeyModifiers.Control
                });
                PrimaryCommandBar.SecondaryCommands.Add(newButton);

            }
            MultipleButtons = true;
        }

        private void RemoveSecondaryCommands_Click(object sender, RoutedEventArgs e)
        {
            RemoveSecondaryCommands();
        }

        protected override void OnNavigatingFrom(NavigatingCancelEventArgs e)
        {
            RemoveSecondaryCommands();
            base.OnNavigatingFrom(e);
        }

        private void RemoveSecondaryCommands()
        {
            while (PrimaryCommandBar.SecondaryCommands.Count > 1)
            {
                PrimaryCommandBar.SecondaryCommands.RemoveAt(PrimaryCommandBar.SecondaryCommands.Count - 1);
            }
            MultipleButtons = false;
        }


        private void AddKeyboardAccelerators()
        {
            editButton.KeyboardAccelerators.Add(new Microsoft.UI.Xaml.Input.KeyboardAccelerator()
            {
                Key = Windows.System.VirtualKey.E,
                Modifiers = Windows.System.VirtualKeyModifiers.Control
            });

            shareButton.KeyboardAccelerators.Add(new Microsoft.UI.Xaml.Input.KeyboardAccelerator()
            {
                Key = Windows.System.VirtualKey.F4
            });

            addButton.KeyboardAccelerators.Add(new Microsoft.UI.Xaml.Input.KeyboardAccelerator()
            {
                Key = Windows.System.VirtualKey.A,
                Modifiers = Windows.System.VirtualKeyModifiers.Control
            });

        }
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Page
    x:Class="WinUI3CSharp.SamplePages.WebViewToPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3CSharp.SamplePages"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="*" />
        </Grid.RowDefinitions>
        <TextBlock TextWrapping="Wrap" Margin="0,0,0,12">
                WebView2 is powered by the Chromium engine.
        </TextBlock>
        <WebView2 x:Name="MyWebView2" Source="https://coding-x.tech" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Grid.Row="1" MinHeight="560" MinWidth="200"/>
    </Grid>
</Page>
  

  using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Controls.Primitives;
using Microsoft.UI.Xaml.Data;
using Microsoft.UI.Xaml.Input;
using Microsoft.UI.Xaml.Media;
using Microsoft.UI.Xaml.Navigation;
using Windows.Foundation;
using Windows.Foundation.Collections;


namespace WinUI3CSharp.SamplePages
{
    public sealed partial class WebViewToPage : Page
    {
        public WebViewToPage()
        {
            this.InitializeComponent();
        }
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Page
    x:Class="WinUI3CSharp.SamplePages.GridView"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3CSharp.SamplePages"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

    <Page.Resources>
        <DataTemplate x:Key="ImageTemplate" x:DataType="local:CustomDataObject">
            <Image Stretch="UniformToFill" Source="{x:Bind ImageLocation}" AutomationProperties.Name="{x:Bind Title}" Width="190" Height="190" AutomationProperties.AccessibilityView="Raw" />
        </DataTemplate>
    </Page.Resources>

    <StackPanel>
        <TextBlock Margin="0,0,0,15">
                    This is a basic GridView that has the full source code below. <LineBreak/>Other samples on this page display only the additional markup needed to customize the specific GridView.
        </TextBlock>
        <GridView
                    x:Name="BasicGridView"
                    ItemTemplate="{StaticResource ImageTemplate}"
                    IsItemClickEnabled="True"
                    ItemClick="BasicGridView_ItemClick"
                    SelectionMode="Single"/>
        <TextBlock x:Name="ClickOutput" Style="{StaticResource OutputTextBlockStyle}" />
    </StackPanel> 
</Page>
  

  using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Controls.Primitives;
using Microsoft.UI.Xaml.Data;
using Microsoft.UI.Xaml.Input;
using Microsoft.UI.Xaml.Media;
using Microsoft.UI.Xaml.Navigation;
using Windows.Foundation;
using Windows.Foundation.Collections;

using System.Collections.ObjectModel;
using Microsoft.UI;

namespace WinUI3CSharp.SamplePages
{
    public sealed partial class GridView : Page
    {
        public GridView()
        {
            this.InitializeComponent();
            this.DataContext = this;
        }

        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);
            // Get data objects and place them into an ObservableCollection
            List<CustomDataObject> tempList = CustomDataObject.GetDataObjects();
            ObservableCollection<CustomDataObject> Items = new ObservableCollection<CustomDataObject>(tempList);
            BasicGridView.ItemsSource = Items;
        }

        private void BasicGridView_ItemClick(object sender, ItemClickEventArgs e)
        {
            ClickOutput.Text = "You clicked " + (e.ClickedItem as CustomDataObject).Title + ".";
        }
    }
}
  

  <?xml version="1.0" encoding="utf-8"?>
<Page
    x:Class="WinUI3CSharp.SamplePages.ViewModel"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WinUI3CSharp.SamplePages"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

</Page>
  

  using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Controls.Primitives;
using Microsoft.UI.Xaml.Data;
using Microsoft.UI.Xaml.Input;
using Microsoft.UI.Xaml.Media;
using Microsoft.UI.Xaml.Navigation;
using Windows.Foundation;
using Windows.Foundation.Collections;

namespace WinUI3CSharp.SamplePages
{
    public sealed partial class ViewModel : Page
    {
        public ViewModel()
        {
            this.InitializeComponent();
        }
    }

    public class CustomDataObject
    {
        public string Title { get; set; }
        public string ImageLocation { get; set; }
        public string Views { get; set; }
        public string Likes { get; set; }
        public string Description { get; set; }

        public CustomDataObject()
        {
        }

        public static List<CustomDataObject> GetDataObjects(bool includeAllItems = false)
        {
            string[] dummyTexts = new[] {
                @"Lorem ipsum dolor sit amet, consectetur adipiscing elit. ...",
                @"Nullam eget mattis metus. Donec pharetra, ...",
                @"Quisque accumsan pretium ligula in faucibus. ...",
                @"Aenean in nisl at elit venenatis blandit ut vitae lectus. ...",
                @"Ut consequat magna luctus justo egestas vehicula. ...",
                @"Proin malesuada, libero vitae aliquam venenatis, ...",
                @"Aenean vulputate, turpis non tincidunt ornare, ...",
                @"Duis facilisis, quam ut laoreet commodo, elit ex aliquet massa, ...",
            };

            Random rand = new Random();
            int numberOfLocations = includeAllItems ? 13 : 8;
            List<CustomDataObject> objects = new List<CustomDataObject>();
            for (int i = 0; i < numberOfLocations; i++)
            {
                objects.Add(new CustomDataObject()
                {
                    Title = $"Item {i + 1}",
                    ImageLocation = $"/Assets/SampleMedia/codingx-{i + 1}.jpg",
                    Views = rand.Next(100, 999).ToString(),
                    Likes = rand.Next(10, 99).ToString(),
                    Description = dummyTexts[i % dummyTexts.Length],
                });
            }
            return objects;
        }
    }
}