AppCenter to AppInsights migration. (#562)

* Remove AppCenter usage and libraries.

* Remove redundant pacakges and add the app insights sink.

* Diagnostic id support and manipulating telemetries.

* Handling of appdomain unhandled exceptions.

* Remove unused package identity package from mail project.

* Fixing printing.

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: [bkaankose]

.github/ISSUE_TEMPLATE/bug-report.md

@@ -0,0 +1,20 @@
+---
+name: Bug Report
+about: Something is not working as intended
+title: "[Bug]"
+labels: bug
+assignees: bkaankose
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature-proposal.md

@@ -0,0 +1,17 @@
+---
+name: Feature Proposal
+about: Suggest an idea for this project
+title: "[Proposal]"
+labels: enhancement
+assignees: ''
+
+---
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Is your proposal implemented in Windows Mail?**
+Wino's priority is to catch up with the feature set of Windows Mail first. 
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.gitignore

@@ -206,9 +206,6 @@ PublishScripts/
 *.nuget.props
 *.nuget.targets
 
-# Nuget personal access tokens and Credentials
-nuget.config
-
 # Microsoft Azure Build Output
 csx/
 *.build.csdef

CONTRIBUTING.md

@@ -15,7 +15,12 @@ Wino Mail is [Universal Windows Platform](https://learn.microsoft.com/en-us/wind
 **Min Version:** Windows 10 1809 
 **Target Version:** Windows 11 22H2
 
-It's pretty straightforward after cloning the repo. There are no prerequisites needed. Just open **Wino.sln** solution in your IDE and launch.
+## Prerequisites
+
+* ".NET desktop development" workload in Visual Studio 2022+
+* .NET SDK 8.0+
+
+With those installed, it's pretty straightforward after cloning the repo.  Just open **Wino.sln** solution in your IDE and launch.
 
 ## Project Architecture
 

Directory.Build.Props

@@ -0,0 +1,7 @@
+<Project>
+	<PropertyGroup>
+		<LangVersion>preview</LangVersion>
+		<IsAotCompatible>true</IsAotCompatible>
+		<Configurations>Debug;Release</Configurations>
+	</PropertyGroup>
+</Project>

Directory.Packages.props

@@ -0,0 +1,64 @@
+<Project>
+	<PropertyGroup>
+		<ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+	</PropertyGroup>
+	<ItemGroup>
+		<PackageVersion Include="ColorHashSharp" Version="1.0.0" />
+		<PackageVersion Include="CommunityToolkit.Common" Version="8.4.0" />
+		<PackageVersion Include="CommunityToolkit.Diagnostics" Version="8.4.0" />
+		<PackageVersion Include="CommunityToolkit.Labs.Uwp.Controls.MarkdownTextBlock" Version="0.1.250206-build.2040" />
+		<PackageVersion Include="CommunityToolkit.Mvvm" Version="8.4.0" />
+		<PackageVersion Include="CommunityToolkit.Uwp.Animations" Version="8.2.250129-preview2" />
+		<PackageVersion Include="CommunityToolkit.Uwp.Behaviors" Version="8.2.250129-preview2" />
+		<PackageVersion Include="CommunityToolkit.Uwp.Controls.Segmented" Version="8.2.250129-preview2" />
+		<PackageVersion Include="CommunityToolkit.Uwp.Controls.SettingsControls" Version="8.2.250129-preview2" />
+		<PackageVersion Include="CommunityToolkit.Uwp.Controls.Sizers" Version="8.2.250129-preview2" />
+		<PackageVersion Include="CommunityToolkit.Uwp.Controls.TabbedCommandBar" Version="8.2.250129-preview2" />
+		<PackageVersion Include="CommunityToolkit.Uwp.Controls.TokenizingTextBox" Version="8.2.250129-preview2" />
+		<PackageVersion Include="CommunityToolkit.Uwp.Extensions" Version="8.2.250129-preview2" />
+		<PackageVersion Include="EmailValidation" Version="1.2.0" />
+		<PackageVersion Include="HtmlAgilityPack" Version="1.11.72" />
+		<PackageVersion Include="Ical.Net" Version="4.3.1" />
+		<PackageVersion Include="IsExternalInit" Version="1.0.3" />
+		<PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.11.0" />
+		<PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.12.0" />
+		<PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="9.0.2" />
+		<PackageVersion Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="9.0.2" />
+		<PackageVersion Include="Microsoft.Graph" Version="5.69.0" />
+		<PackageVersion Include="Microsoft.Identity.Client" Version="4.68.0" />
+		<PackageVersion Include="Microsoft.Identity.Client.Broker" Version="4.68.0" />
+		<PackageVersion Include="Microsoft.Identity.Client.Extensions.Msal" Version="4.68.0" />
+		<PackageVersion Include="Microsoft.NETCore.UniversalWindowsPlatform" Version="6.2.14" />
+		<PackageVersion Include="Microsoft.UI.Xaml" Version="2.8.7" />
+		<PackageVersion Include="Microsoft.Xaml.Behaviors.Uwp.Managed" Version="3.0.0" />
+		<PackageVersion Include="MimeKit" Version="4.10.0" />
+		<PackageVersion Include="morelinq" Version="4.4.0" />
+		<PackageVersion Include="Nito.AsyncEx" Version="5.1.2" />
+		<PackageVersion Include="Nito.AsyncEx.Tasks" Version="5.1.2" />
+		<PackageVersion Include="NodaTime" Version="3.2.1" />
+		<PackageVersion Include="Serilog" Version="4.2.0" />
+		<PackageVersion Include="Serilog.Exceptions" Version="8.4.0" />
+		<PackageVersion Include="Serilog.Sinks.Debug" Version="3.0.0" />
+		<PackageVersion Include="Serilog.Sinks.File" Version="6.0.0" />
+		<PackageVersion Include="Serilog.Sinks.ApplicationInsights" Version="4.0.0" />
+		<PackageVersion Include="SkiaSharp" Version="3.116.1" />
+		<PackageVersion Include="sqlite-net-pcl" Version="1.9.172" />
+		<PackageVersion Include="SqlKata" Version="4.0.1" />
+		<PackageVersion Include="System.Private.Uri" Version="4.3.2" />
+		<PackageVersion Include="System.Text.Encoding.CodePages" Version="9.0.2" />
+		<PackageVersion Include="System.Text.Json" Version="9.0.2" />
+		<PackageVersion Include="Win2D.uwp" Version="1.28.2" />
+		<PackageVersion Include="H.NotifyIcon.Wpf" Version="2.2.0" />
+		<PackageVersion Include="CommunityToolkit.WinUI.Notifications" Version="7.1.2" />
+		<PackageVersion Include="Google.Apis.Auth" Version="1.69.0" />
+		<PackageVersion Include="Google.Apis.Calendar.v3" Version="1.69.0.3667" />
+		<PackageVersion Include="Google.Apis.Gmail.v1" Version="1.68.0.3427" />
+		<PackageVersion Include="Google.Apis.PeopleService.v1" Version="1.68.0.3359" />
+		<PackageVersion Include="HtmlKit" Version="1.2.0" />
+		<PackageVersion Include="MailKit" Version="4.10.0" />
+		<PackageVersion Include="TimePeriodLibrary.NET" Version="2.1.5" />
+		<PackageVersion Include="System.Reactive" Version="6.0.1" />
+		<PackageVersion Include="Microsoft.Bcl.AsyncInterfaces" Version="9.0.2" />
+		<PackageVersion Include="System.Text.Encodings.Web" Version="9.0.2" />
+	</ItemGroup>
+</Project>

Settings.XamlStyler

@@ -0,0 +1,42 @@
+{
+    "AttributesTolerance": 2,
+    "KeepFirstAttributeOnSameLine": false,
+    "MaxAttributeCharactersPerLine": 0,
+    "MaxAttributesPerLine": 1,
+    "NewlineExemptionElements": "RadialGradientBrush, GradientStop, LinearGradientBrush, ScaleTransform, SkewTransform, RotateTransform, TranslateTransform, Trigger, Condition, Setter",
+    "SeparateByGroups": false,
+    "AttributeIndentation": 0,
+    "AttributeIndentationStyle": 1,
+    "RemoveDesignTimeReferences":  false,
+    "IgnoreDesignTimeReferencePrefix": false,
+    "EnableAttributeReordering": true,
+    "AttributeOrderingRuleGroups": [
+        "x:Class",
+        "xmlns, xmlns:x",
+        "xmlns:*",
+        "x:Key, Key, x:Name, Name, x:Uid, Uid, Title",
+        "Grid.Row, Grid.RowSpan, Grid.Column, Grid.ColumnSpan, Canvas.Left, Canvas.Top, Canvas.Right, Canvas.Bottom",
+        "Width, Height, MinWidth, MinHeight, MaxWidth, MaxHeight",
+        "Margin, Padding, HorizontalAlignment, VerticalAlignment, HorizontalContentAlignment, VerticalContentAlignment, Panel.ZIndex",
+        "*:*, *",
+        "PageSource, PageIndex, Offset, Color, TargetName, Property, Value, StartPoint, EndPoint",
+        "mc:Ignorable, d:IsDataSource, d:LayoutOverrides, d:IsStaticText",
+        "Storyboard.*, From, To, Duration"
+    ],
+    "FirstLineAttributes": "",
+    "OrderAttributesByName": true,
+    "PutEndingBracketOnNewLine": false,
+    "RemoveEndingTagOfEmptyElement": true,
+    "SpaceBeforeClosingSlash": true,
+    "RootElementLineBreakRule": 0,
+    "ReorderVSM": 2,
+    "ReorderGridChildren": false,
+    "ReorderCanvasChildren": false,
+    "ReorderSetters": 0,
+    "FormatMarkupExtension": true,
+    "NoNewLineMarkupExtensions": "x:Bind, Binding",
+    "ThicknessSeparator": 2,
+    "ThicknessAttributes": "Margin, Padding, BorderThickness, ThumbnailClipMargin",
+    "FormatOnSave": true,
+    "CommentPadding": 2,
+}

Wino.Authentication/BaseAuthenticator.cs

@@ -0,0 +1,17 @@
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Interfaces;
+
+namespace Wino.Authentication
+{
+    public abstract class BaseAuthenticator
+    {
+        public abstract MailProviderType ProviderType { get; }
+        protected IAuthenticatorConfig AuthenticatorConfig { get; }
+
+        protected BaseAuthenticator(IAuthenticatorConfig authenticatorConfig)
+        {
+
+            AuthenticatorConfig = authenticatorConfig;
+        }
+    }
+}

Wino.Authentication/GmailAuthenticator.cs

@@ -0,0 +1,51 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Google.Apis.Auth.OAuth2;
+using Google.Apis.Util.Store;
+using Wino.Core.Domain.Entities.Shared;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Authentication;
+
+namespace Wino.Authentication
+{
+    public class GmailAuthenticator : BaseAuthenticator, IGmailAuthenticator
+    {
+        public GmailAuthenticator(IAuthenticatorConfig authConfig) : base(authConfig)
+        {
+        }
+
+        public string ClientId => AuthenticatorConfig.GmailAuthenticatorClientId;
+        public bool ProposeCopyAuthURL { get; set; }
+
+        public override MailProviderType ProviderType => MailProviderType.Gmail;
+
+        /// <summary>
+        /// Generates the token information for the given account.
+        /// For gmail, interactivity is automatically handled when you get the token.
+        /// </summary>
+        /// <param name="account">Account to get token for.</param>
+        public Task<TokenInformationEx> GenerateTokenInformationAsync(MailAccount account)
+            => GetTokenInformationAsync(account);
+
+        public async Task<TokenInformationEx> GetTokenInformationAsync(MailAccount account)
+        {
+            var userCredential = await GetGoogleUserCredentialAsync(account);
+
+            if (userCredential.Token.IsStale)
+            {
+                await userCredential.RefreshTokenAsync(CancellationToken.None);
+            }
+
+            return new TokenInformationEx(userCredential.Token.AccessToken, account.Address);
+        }
+
+        private Task<UserCredential> GetGoogleUserCredentialAsync(MailAccount account)
+        {
+            return GoogleWebAuthorizationBroker.AuthorizeAsync(new ClientSecrets()
+            {
+                ClientId = ClientId
+            }, AuthenticatorConfig.GmailScope, account.Id.ToString(), CancellationToken.None, new FileDataStore(AuthenticatorConfig.GmailTokenStoreIdentifier));
+        }
+    }
+}

Wino.Authentication/OutlookAuthenticator.cs

@@ -0,0 +1,126 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Identity.Client;
+using Microsoft.Identity.Client.Broker;
+using Microsoft.Identity.Client.Extensions.Msal;
+using Wino.Core.Domain;
+using Wino.Core.Domain.Entities.Shared;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Exceptions;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Authentication;
+
+namespace Wino.Authentication
+{
+    public class OutlookAuthenticator : BaseAuthenticator, IOutlookAuthenticator
+    {
+        private const string TokenCacheFileName = "OutlookCache.bin";
+        private bool isTokenCacheAttached = false;
+
+        // Outlook
+        private const string Authority = "https://login.microsoftonline.com/common";
+
+        public override MailProviderType ProviderType => MailProviderType.Outlook;
+
+        private readonly IPublicClientApplication _publicClientApplication;
+        private readonly IApplicationConfiguration _applicationConfiguration;
+
+        public OutlookAuthenticator(INativeAppService nativeAppService,
+                                    IApplicationConfiguration applicationConfiguration,
+                                    IAuthenticatorConfig authenticatorConfig) : base(authenticatorConfig)
+        {
+            _applicationConfiguration = applicationConfiguration;
+
+            var authenticationRedirectUri = nativeAppService.GetWebAuthenticationBrokerUri();
+
+            var options = new BrokerOptions(BrokerOptions.OperatingSystems.Windows)
+            {
+                Title = "Wino Mail",
+                ListOperatingSystemAccounts = true,
+            };
+
+            var outlookAppBuilder = PublicClientApplicationBuilder.Create(AuthenticatorConfig.OutlookAuthenticatorClientId)
+                .WithParentActivityOrWindow(nativeAppService.GetCoreWindowHwnd)
+                .WithBroker(options)
+                .WithDefaultRedirectUri()
+                .WithAuthority(Authority);
+
+            _publicClientApplication = outlookAppBuilder.Build();
+        }
+
+        public string[] Scope => AuthenticatorConfig.OutlookScope;
+
+        private async Task EnsureTokenCacheAttachedAsync()
+        {
+            if (!isTokenCacheAttached)
+            {
+                var storageProperties = new StorageCreationPropertiesBuilder(TokenCacheFileName, _applicationConfiguration.PublisherSharedFolderPath).Build();
+                var msalcachehelper = await MsalCacheHelper.CreateAsync(storageProperties);
+                msalcachehelper.RegisterCache(_publicClientApplication.UserTokenCache);
+
+                isTokenCacheAttached = true;
+            }
+        }
+
+        public async Task<TokenInformationEx> GetTokenInformationAsync(MailAccount account)
+        {
+            await EnsureTokenCacheAttachedAsync();
+
+            var storedAccount = (await _publicClientApplication.GetAccountsAsync()).FirstOrDefault(a => a.Username == account.Address);
+
+            if (storedAccount == null)
+                return await GenerateTokenInformationAsync(account);
+
+            try
+            {
+                var authResult = await _publicClientApplication.AcquireTokenSilent(Scope, storedAccount).ExecuteAsync();
+
+                return new TokenInformationEx(authResult.AccessToken, authResult.Account.Username);
+            }
+            catch (MsalUiRequiredException)
+            {
+                // Somehow MSAL is not able to refresh the token silently.
+                // Force interactive login.
+
+                return await GenerateTokenInformationAsync(account);
+            }
+            catch (Exception)
+            {
+                throw;
+            }
+        }
+
+        public async Task<TokenInformationEx> GenerateTokenInformationAsync(MailAccount account)
+        {
+            try
+            {
+                await EnsureTokenCacheAttachedAsync();
+
+                var authResult = await _publicClientApplication
+                    .AcquireTokenInteractive(Scope)
+                    .ExecuteAsync();
+
+                // If the account is null, it means it's the initial creation of it.
+                // If not, make sure the authenticated user address matches the username.
+                // When people refresh their token, accounts must match.
+
+                if (account?.Address != null && !account.Address.Equals(authResult.Account.Username, StringComparison.OrdinalIgnoreCase))
+                {
+                    throw new AuthenticationException("Authenticated address does not match with your account address.");
+                }
+
+                return new TokenInformationEx(authResult.AccessToken, authResult.Account.Username);
+            }
+            catch (MsalClientException msalClientException)
+            {
+                if (msalClientException.ErrorCode == "authentication_canceled" || msalClientException.ErrorCode == "access_denied")
+                    throw new AccountSetupCanceledException();
+
+                throw;
+            }
+
+            throw new AuthenticationException(Translator.Exception_UnknowErrorDuringAuthentication, new Exception(Translator.Exception_TokenGenerationFailed));
+        }
+    }
+}

Wino.Authentication/Wino.Authentication.csproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+	<PropertyGroup>
+		<TargetFramework>net9.0</TargetFramework>
+		<RuntimeIdentifiers>win-x86;win-x64;win-arm64</RuntimeIdentifiers>
+		<RootNamespace>Wino.Authentication</RootNamespace>
+		<Platforms>x86;x64;arm64</Platforms>
+		<AccelerateBuildsInVisualStudio>true</AccelerateBuildsInVisualStudio>
+		<ProduceReferenceAssembly>true</ProduceReferenceAssembly>
+	</PropertyGroup>
+	<ItemGroup>
+		<PackageReference Include="CommunityToolkit.Diagnostics" />
+		<PackageReference Include="CommunityToolkit.Mvvm"  />
+		<PackageReference Include="Google.Apis.Auth"  />
+		<PackageReference Include="Microsoft.Identity.Client" />
+		<PackageReference Include="Microsoft.Identity.Client.Broker"  />
+		<PackageReference Include="Microsoft.Identity.Client.Extensions.Msal"  />
+	</ItemGroup>
+	<ItemGroup>
+		<ProjectReference Include="..\Wino.Core.Domain\Wino.Core.Domain.csproj" />
+		<ProjectReference Include="..\Wino.Messages\Wino.Messaging.csproj" />
+	</ItemGroup>
+</Project>

Wino.BackgroundTasks/AppUpdatedTask.cs

@@ -0,0 +1,34 @@
+using Microsoft.Toolkit.Uwp.Notifications;
+using Windows.ApplicationModel;
+using Windows.ApplicationModel.Background;
+
+namespace Wino.BackgroundTasks
+{
+    /// <summary>
+    /// Creates a toast notification to notify user when the Store update happens.
+    /// </summary>
+    public sealed class AppUpdatedTask : IBackgroundTask
+    {
+        public void Run(IBackgroundTaskInstance taskInstance)
+        {
+            var def = taskInstance.GetDeferral();
+
+            var builder = new ToastContentBuilder();
+            builder.SetToastScenario(ToastScenario.Default);
+
+            Package package = Package.Current;
+            PackageId packageId = package.Id;
+            PackageVersion version = packageId.Version;
+
+            var versionText = string.Format("{0}.{1}.{2}.{3}", version.Major, version.Minor, version.Build, version.Revision);
+
+            // TODO: Handle with Translator, but it's not initialized here yet.
+            builder.AddText("Wino Mail is updated!");
+            builder.AddText(string.Format("New version {0} is ready.", versionText));
+
+            builder.Show();
+
+            def.Complete();
+        }
+    }
+}

Wino.BackgroundTasks/Properties/AssemblyInfo.cs

@@ -0,0 +1,29 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Wino.BackgroundTasks")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Wino.BackgroundTasks")]
+[assembly: AssemblyCopyright("Copyright ©  2023")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: ComVisible(false)]

Wino.BackgroundTasks/Wino.BackgroundTasks.csproj

@@ -0,0 +1,129 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{D9EF0F59-F5F2-4D6C-A5BA-84043D8F3E08}</ProjectGuid>
+    <OutputType>winmdobj</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Wino.BackgroundTasks</RootNamespace>
+    <AssemblyName>Wino.BackgroundTasks</AssemblyName>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <TargetPlatformIdentifier>UAP</TargetPlatformIdentifier>
+    <TargetPlatformVersion Condition=" '$(TargetPlatformVersion)' == '' ">10.0.22621.0</TargetPlatformVersion>
+    <TargetPlatformMinVersion>10.0.17763.0</TargetPlatformMinVersion>
+    <MinimumVisualStudioVersion>14</MinimumVisualStudioVersion>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{A5A43C5B-DE2A-4C0C-9213-0A381AF9435A};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <AllowCrossPlatformRetargeting>false</AllowCrossPlatformRetargeting>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <PlatformTarget>x86</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x86\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
+    <NoWarn>;2008</NoWarn>
+    <DebugType>full</DebugType>
+    <UseVSHostingProcess>false</UseVSHostingProcess>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
+    <PlatformTarget>x86</PlatformTarget>
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
+    <Optimize>true</Optimize>
+    <NoWarn>;2008</NoWarn>
+    <DebugType>pdbonly</DebugType>
+    <UseVSHostingProcess>false</UseVSHostingProcess>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|ARM64'">
+    <PlatformTarget>ARM64</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\ARM64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
+    <NoWarn>;2008</NoWarn>
+    <DebugType>full</DebugType>
+    <UseVSHostingProcess>false</UseVSHostingProcess>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|ARM64'">
+    <PlatformTarget>ARM64</PlatformTarget>
+    <OutputPath>bin\ARM64\Release\</OutputPath>
+    <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
+    <Optimize>true</Optimize>
+    <NoWarn>;2008</NoWarn>
+    <DebugType>pdbonly</DebugType>
+    <UseVSHostingProcess>false</UseVSHostingProcess>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <PlatformTarget>x64</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
+    <NoWarn>;2008</NoWarn>
+    <DebugType>full</DebugType>
+    <UseVSHostingProcess>false</UseVSHostingProcess>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <PlatformTarget>x64</PlatformTarget>
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
+    <Optimize>true</Optimize>
+    <NoWarn>;2008</NoWarn>
+    <DebugType>pdbonly</DebugType>
+    <UseVSHostingProcess>false</UseVSHostingProcess>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup>
+    <RestoreProjectStyle>PackageReference</RestoreProjectStyle>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="AppUpdatedTask.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Identity.Client">
+      <Version>4.66.2</Version>
+    </PackageReference>
+    <PackageReference Include="Microsoft.NETCore.UniversalWindowsPlatform">
+      <Version>6.2.14</Version>
+    </PackageReference>
+    <PackageReference Include="Microsoft.Toolkit.Uwp.Notifications">
+      <Version>7.1.3</Version>
+    </PackageReference>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Wino.Core.Domain\Wino.Core.Domain.csproj">
+      <Project>{CF3312E5-5DA0-4867-9945-49EA7598AF1F}</Project>
+      <Name>Wino.Core.Domain</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\Wino.Core.UWP\Wino.Core.UWP.csproj">
+      <Project>{395f19ba-1e42-495c-9db5-1a6f537fccb8}</Project>
+      <Name>Wino.Core.UWP</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\Wino.Core\Wino.Core.csproj">
+      <Project>{e6b1632a-8901-41e8-9ddf-6793c7698b0b}</Project>
+      <Name>Wino.Core</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <SDKReference Include="WindowsDesktop, Version=10.0.22621.0">
+      <Name>Windows Desktop Extensions for the UWP</Name>
+    </SDKReference>
+  </ItemGroup>
+  <PropertyGroup Condition=" '$(VisualStudioVersion)' == '' or '$(VisualStudioVersion)' &lt; '14.0' ">
+    <VisualStudioVersion>14.0</VisualStudioVersion>
+  </PropertyGroup>
+  <Import Project="$(MSBuildExtensionsPath)\Microsoft\WindowsXaml\v$(VisualStudioVersion)\Microsoft.Windows.UI.Xaml.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

Wino.Calendar.Packaging/Package.appxmanifest

@@ -0,0 +1,90 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<Package
+  xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
+  xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
+  xmlns:desktop="http://schemas.microsoft.com/appx/manifest/desktop/windows10"
+  xmlns:uap5="http://schemas.microsoft.com/appx/manifest/uap/windows10/5"
+  xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
+  IgnorableNamespaces="uap rescap">
+
+  <Identity
+    Name="58272BurakKSE.WinoCalendar"
+    Publisher="CN=51FBDAF3-E212-4149-89A2-A2636B3BC911"
+    Version="1.0.0.0" />
+
+  <Properties>
+    <DisplayName>Wino Calendar</DisplayName>
+    <PublisherDisplayName>Burak KÖSE</PublisherDisplayName>
+    <Logo>Images\StoreLogo.png</Logo>
+  </Properties>
+
+  <Dependencies>
+    <TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.0.0" MaxVersionTested="10.0.0.0" />
+    <TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.14393.0" MaxVersionTested="10.0.14393.0" />
+  </Dependencies>
+
+  <Resources>
+    <Resource Language="x-generate"/>
+  </Resources>
+
+  <Applications>
+    <Application Id="App"
+      Executable="$targetnametoken$.exe"
+      EntryPoint="$targetentrypoint$">
+      <uap:VisualElements
+        DisplayName="Wino Calendar"
+        Description="Wino.Calendar.Packaging"
+        BackgroundColor="transparent"
+        Square150x150Logo="Images\Square150x150Logo.png"
+        Square44x44Logo="Images\Square44x44Logo.png">
+        <uap:DefaultTile Wide310x150Logo="Images\Wide310x150Logo.png" />
+        <uap:SplashScreen Image="Images\SplashScreen.png" />
+      </uap:VisualElements>
+
+		<Extensions>
+			<!-- Registration of full trust backend application. -->
+			<uap:Extension Category="windows.appService">
+				<uap:AppService Name="WinoInteropService" />
+			</uap:Extension>
+			
+			<!-- Protocol activation: Google OAuth -->
+			<uap:Extension Category="windows.protocol">
+				<uap:Protocol Name="google.pw.oauth2">
+					<uap:DisplayName>Wino Google Authentication Protocol</uap:DisplayName>
+				</uap:Protocol>
+			</uap:Extension>
+			
+			<!-- Protocol activation: Launch UWP app from Full Trust Process  -->
+			<uap:Extension Category="windows.protocol">
+				<uap:Protocol Name="wino.calendar.launch">
+					<uap:DisplayName>Wino Calendara Launcher Protocol</uap:DisplayName>
+				</uap:Protocol>
+			</uap:Extension>
+
+			<!-- Startup Task -->
+			<uap5:Extension
+				Category="windows.startupTask"
+				Executable="Wino.Server\Wino.Server.exe"
+				EntryPoint="Windows.FullTrustApplication">
+				<uap5:StartupTask
+					  TaskId="WinoServer"
+					  Enabled="false"
+					  DisplayName="Wino Mail" />
+			</uap5:Extension>
+
+			<desktop:Extension Category="windows.fullTrustProcess" Executable="Wino.Server\Wino.Server.exe">
+				<desktop:FullTrustProcess>
+					<desktop:ParameterGroup GroupId="WinoServer" Parameters="Calendar" />
+				</desktop:FullTrustProcess>
+			</desktop:Extension>
+		</Extensions>
+    </Application>
+  </Applications>
+
+  <Capabilities>
+    <Capability Name="internetClient" />
+    <rescap:Capability Name="runFullTrust" />
+	<rescap:Capability Name="confirmAppClose" />
+  </Capabilities>
+</Package>

Wino.Calendar.Packaging/Wino.Calendar.Packaging.wapproj

@@ -0,0 +1,77 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Condition="'$(VisualStudioVersion)' == '' or '$(VisualStudioVersion)' &lt; '15.0'">
+    <VisualStudioVersion>15.0</VisualStudioVersion>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x86">
+      <Configuration>Debug</Configuration>
+      <Platform>x86</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x86">
+      <Configuration>Release</Configuration>
+      <Platform>x86</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|AnyCPU">
+      <Configuration>Debug</Configuration>
+      <Platform>AnyCPU</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|AnyCPU">
+      <Configuration>Release</Configuration>
+      <Platform>AnyCPU</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup>
+    <WapProjPath Condition="'$(WapProjPath)'==''">$(MSBuildExtensionsPath)\Microsoft\DesktopBridge\</WapProjPath>
+  </PropertyGroup>
+  <Import Project="$(WapProjPath)\Microsoft.DesktopBridge.props" />
+  <PropertyGroup>
+    <ProjectGuid>7485b18c-f5ab-4abe-ba7f-05b6623c67c8</ProjectGuid>
+    <TargetPlatformVersion>10.0.22621.0</TargetPlatformVersion>
+    <TargetPlatformMinVersion>10.0.17763.0</TargetPlatformMinVersion>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <AppxPackageSigningEnabled>false</AppxPackageSigningEnabled>
+    <NoWarn>$(NoWarn);NU1702</NoWarn>
+    <EntryPointProjectUniqueName>..\Wino.Calendar\Wino.Calendar.csproj</EntryPointProjectUniqueName>
+    <GenerateTemporaryStoreCertificate>True</GenerateTemporaryStoreCertificate>
+  </PropertyGroup>
+  <ItemGroup>
+    <AppxManifest Include="Package.appxmanifest">
+      <SubType>Designer</SubType>
+    </AppxManifest>
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Images\SplashScreen.scale-200.png" />
+    <Content Include="Images\LockScreenLogo.scale-200.png" />
+    <Content Include="Images\Square150x150Logo.scale-200.png" />
+    <Content Include="Images\Square44x44Logo.scale-200.png" />
+    <Content Include="Images\Square44x44Logo.targetsize-24_altform-unplated.png" />
+    <Content Include="Images\StoreLogo.png" />
+    <Content Include="Images\Wide310x150Logo.scale-200.png" />
+    <None Include="Package.StoreAssociation.xml" />
+  </ItemGroup>
+  <Import Project="$(WapProjPath)\Microsoft.DesktopBridge.targets" />
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Windows.SDK.BuildTools" Version="10.0.26100.1742" PrivateAssets="all" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Wino.Calendar\Wino.Calendar.csproj" />
+    <ProjectReference Include="..\Wino.Server\Wino.Server.csproj" />
+  </ItemGroup>
+</Project>

Wino.Calendar.ViewModels/AccountDetailsPageViewModel.cs

@@ -0,0 +1,48 @@
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.Input;
+using Wino.Calendar.ViewModels.Interfaces;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Navigation;
+using Wino.Core.ViewModels;
+using Wino.Mail.ViewModels.Data;
+using Wino.Messaging.UI;
+
+namespace Wino.Calendar.ViewModels
+{
+    public partial class AccountDetailsPageViewModel : CalendarBaseViewModel
+    {
+        private readonly IAccountService _accountService;
+
+        public AccountProviderDetailViewModel Account { get; private set; }
+        public ICalendarDialogService CalendarDialogService { get; }
+        public IAccountCalendarStateService AccountCalendarStateService { get; }
+
+        public AccountDetailsPageViewModel(ICalendarDialogService calendarDialogService, IAccountService accountService, IAccountCalendarStateService accountCalendarStateService)
+        {
+            CalendarDialogService = calendarDialogService;
+            _accountService = accountService;
+            AccountCalendarStateService = accountCalendarStateService;
+        }
+
+        [RelayCommand]
+        private async Task RenameAccount()
+        {
+            if (Account == null)
+                return;
+
+            var updatedAccount = await CalendarDialogService.ShowEditAccountDialogAsync(Account.Account);
+
+            if (updatedAccount != null)
+            {
+                await _accountService.UpdateAccountAsync(updatedAccount);
+
+                ReportUIChange(new AccountUpdatedMessage(updatedAccount));
+            }
+        }
+
+        public override void OnNavigatedTo(NavigationMode mode, object parameters)
+        {
+            base.OnNavigatedTo(mode, parameters);
+        }
+    }
+}

Wino.Calendar.ViewModels/AccountManagementViewModel.cs

@@ -0,0 +1,147 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.Input;
+using Wino.Core.Domain;
+using Wino.Core.Domain.Entities.Shared;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Exceptions;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Authentication;
+using Wino.Core.Domain.Models.Navigation;
+using Wino.Core.Domain.Models.Synchronization;
+using Wino.Core.ViewModels;
+using Wino.Messaging.Server;
+
+namespace Wino.Calendar.ViewModels
+{
+    public partial class AccountManagementViewModel : AccountManagementPageViewModelBase
+    {
+        private readonly IProviderService _providerService;
+
+        public AccountManagementViewModel(ICalendarDialogService dialogService,
+                                          IWinoServerConnectionManager winoServerConnectionManager,
+                                          INavigationService navigationService,
+                                          IAccountService accountService,
+                                          IProviderService providerService,
+                                          IStoreManagementService storeManagementService,
+                                          IAuthenticationProvider authenticationProvider,
+                                          IPreferencesService preferencesService) : base(dialogService, winoServerConnectionManager, navigationService, accountService, providerService, storeManagementService, authenticationProvider, preferencesService)
+        {
+            CalendarDialogService = dialogService;
+            _providerService = providerService;
+        }
+
+        public ICalendarDialogService CalendarDialogService { get; }
+
+        public override async void OnNavigatedTo(NavigationMode mode, object parameters)
+        {
+            base.OnNavigatedTo(mode, parameters);
+
+            await InitializeAccountsAsync();
+        }
+
+        public override async Task InitializeAccountsAsync()
+        {
+            Accounts.Clear();
+
+            var accounts = await AccountService.GetAccountsAsync().ConfigureAwait(false);
+
+            await ExecuteUIThread(() =>
+            {
+                foreach (var account in accounts)
+                {
+                    var accountDetails = GetAccountProviderDetails(account);
+
+                    Accounts.Add(accountDetails);
+                }
+            });
+
+            await ManageStorePurchasesAsync().ConfigureAwait(false);
+        }
+
+        [RelayCommand]
+        private async Task AddNewAccountAsync()
+        {
+            if (IsAccountCreationBlocked)
+            {
+                var isPurchaseClicked = await DialogService.ShowConfirmationDialogAsync(Translator.DialogMessage_AccountLimitMessage, Translator.DialogMessage_AccountLimitTitle, Translator.Buttons_Purchase);
+
+                if (!isPurchaseClicked) return;
+
+                await PurchaseUnlimitedAccountAsync();
+
+                return;
+            }
+
+            var availableProviders = _providerService.GetAvailableProviders();
+
+            var accountCreationDialogResult = await DialogService.ShowAccountProviderSelectionDialogAsync(availableProviders);
+
+            if (accountCreationDialogResult == null) return;
+
+            var accountCreationCancellationTokenSource = new CancellationTokenSource();
+            var accountCreationDialog = CalendarDialogService.GetAccountCreationDialog(accountCreationDialogResult);
+
+            accountCreationDialog.ShowDialog(accountCreationCancellationTokenSource);
+            accountCreationDialog.State = AccountCreationDialogState.SigningIn;
+
+            // For OAuth authentications, we just generate token and assign it to the MailAccount.
+
+            var createdAccount = new MailAccount()
+            {
+                ProviderType = accountCreationDialogResult.ProviderType,
+                Name = accountCreationDialogResult.AccountName,
+                Id = Guid.NewGuid()
+            };
+
+            var tokenInformationResponse = await WinoServerConnectionManager
+                .GetResponseAsync<TokenInformationEx, AuthorizationRequested>(new AuthorizationRequested(accountCreationDialogResult.ProviderType,
+                                                                                                       createdAccount,
+                                                                                                       createdAccount.ProviderType == MailProviderType.Gmail), accountCreationCancellationTokenSource.Token);
+
+            if (accountCreationDialog.State == AccountCreationDialogState.Canceled)
+                throw new AccountSetupCanceledException();
+
+            tokenInformationResponse.ThrowIfFailed();
+
+            await AccountService.CreateAccountAsync(createdAccount, null);
+
+            // Sync profile information if supported.
+            if (createdAccount.IsProfileInfoSyncSupported)
+            {
+                // Start profile information synchronization.
+                // It's only available for Outlook and Gmail synchronizers.
+
+                var profileSyncOptions = new MailSynchronizationOptions()
+                {
+                    AccountId = createdAccount.Id,
+                    Type = MailSynchronizationType.UpdateProfile
+                };
+
+                var profileSynchronizationResponse = await WinoServerConnectionManager.GetResponseAsync<MailSynchronizationResult, NewMailSynchronizationRequested>(new NewMailSynchronizationRequested(profileSyncOptions, SynchronizationSource.Client));
+
+                var profileSynchronizationResult = profileSynchronizationResponse.Data;
+
+                if (profileSynchronizationResult.CompletedState != SynchronizationCompletedState.Success)
+                    throw new Exception(Translator.Exception_FailedToSynchronizeProfileInformation);
+
+                createdAccount.SenderName = profileSynchronizationResult.ProfileInformation.SenderName;
+                createdAccount.Base64ProfilePictureData = profileSynchronizationResult.ProfileInformation.Base64ProfilePictureData;
+
+                await AccountService.UpdateProfileInformationAsync(createdAccount.Id, profileSynchronizationResult.ProfileInformation);
+            }
+
+            accountCreationDialog.State = AccountCreationDialogState.FetchingEvents;
+
+            // Start synchronizing events.
+            var synchronizationOptions = new CalendarSynchronizationOptions()
+            {
+                AccountId = createdAccount.Id,
+                Type = CalendarSynchronizationType.CalendarMetadata
+            };
+
+            var synchronizationResponse = await WinoServerConnectionManager.GetResponseAsync<CalendarSynchronizationResult, NewCalendarSynchronizationRequested>(new NewCalendarSynchronizationRequested(synchronizationOptions, SynchronizationSource.Client));
+        }
+    }
+}

Wino.Calendar.ViewModels/AppShellViewModel.cs

@@ -0,0 +1,367 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Threading;
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using CommunityToolkit.Mvvm.Messaging;
+using Serilog;
+using Wino.Calendar.ViewModels.Data;
+using Wino.Calendar.ViewModels.Interfaces;
+using Wino.Core.Domain.Collections;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Extensions;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Calendar;
+using Wino.Core.Domain.Models.Navigation;
+using Wino.Core.Domain.Models.Synchronization;
+using Wino.Core.ViewModels;
+using Wino.Messaging.Client.Calendar;
+using Wino.Messaging.Client.Navigation;
+using Wino.Messaging.Server;
+
+namespace Wino.Calendar.ViewModels
+{
+    public partial class AppShellViewModel : CalendarBaseViewModel,
+        IRecipient<VisibleDateRangeChangedMessage>,
+        IRecipient<CalendarEnableStatusChangedMessage>,
+        IRecipient<NavigateManageAccountsRequested>,
+        IRecipient<CalendarDisplayTypeChangedMessage>,
+        IRecipient<DetailsPageStateChangedMessage>
+    {
+        public IPreferencesService PreferencesService { get; }
+        public IStatePersistanceService StatePersistenceService { get; }
+        public IAccountCalendarStateService AccountCalendarStateService { get; }
+        public INavigationService NavigationService { get; }
+        public IWinoServerConnectionManager ServerConnectionManager { get; }
+
+        [ObservableProperty]
+        private bool _isEventDetailsPageActive;
+
+        [ObservableProperty]
+        private int _selectedMenuItemIndex = -1;
+
+        [ObservableProperty]
+        private bool isCalendarEnabled;
+
+        /// <summary>
+        /// Gets or sets the active connection status of the Wino server.
+        /// </summary>
+        [ObservableProperty]
+        private WinoServerConnectionStatus activeConnectionStatus;
+
+        /// <summary>
+        /// Gets or sets the display date of the calendar.
+        /// </summary>
+        [ObservableProperty]
+        private DateTimeOffset _displayDate;
+
+        /// <summary>
+        /// Gets or sets the highlighted range in the CalendarView and displayed date range in FlipView.
+        /// </summary>
+        [ObservableProperty]
+        private DateRange highlightedDateRange;
+
+        [ObservableProperty]
+        private ObservableRangeCollection<string> dateNavigationHeaderItems = [];
+
+        [ObservableProperty]
+        private int _selectedDateNavigationHeaderIndex;
+
+        public bool IsVerticalCalendar => StatePersistenceService.CalendarDisplayType == CalendarDisplayType.Month;
+
+        // For updating account calendars asynchronously.
+        private SemaphoreSlim _accountCalendarUpdateSemaphoreSlim = new(1);
+
+        public AppShellViewModel(IPreferencesService preferencesService,
+                                 IStatePersistanceService statePersistanceService,
+                                 IAccountService accountService,
+                                 ICalendarService calendarService,
+                                 IAccountCalendarStateService accountCalendarStateService,
+                                 INavigationService navigationService,
+                                 IWinoServerConnectionManager serverConnectionManager)
+        {
+            _accountService = accountService;
+            _calendarService = calendarService;
+
+            AccountCalendarStateService = accountCalendarStateService;
+            AccountCalendarStateService.AccountCalendarSelectionStateChanged += UpdateAccountCalendarRequested;
+            AccountCalendarStateService.CollectiveAccountGroupSelectionStateChanged += AccountCalendarStateCollectivelyChanged;
+
+            NavigationService = navigationService;
+            ServerConnectionManager = serverConnectionManager;
+            PreferencesService = preferencesService;
+
+            StatePersistenceService = statePersistanceService;
+            StatePersistenceService.StatePropertyChanged += PrefefencesChanged;
+        }
+
+        private void SelectedCalendarItemsChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PrefefencesChanged(object sender, string e)
+        {
+            if (e == nameof(StatePersistenceService.CalendarDisplayType))
+            {
+                Messenger.Send(new CalendarDisplayTypeChangedMessage(StatePersistenceService.CalendarDisplayType));
+
+
+                // Change the calendar.
+                DateClicked(new CalendarViewDayClickedEventArgs(GetDisplayTypeSwitchDate()));
+            }
+        }
+
+        public override async void OnNavigatedTo(NavigationMode mode, object parameters)
+        {
+            base.OnNavigatedTo(mode, parameters);
+
+            UpdateDateNavigationHeaderItems();
+
+            await InitializeAccountCalendarsAsync();
+
+            TodayClicked();
+        }
+
+        private async void AccountCalendarStateCollectivelyChanged(object sender, GroupedAccountCalendarViewModel e)
+        {
+            // When using three-state checkbox, multiple accounts will be selected/unselected at the same time.
+            // Reporting all these changes one by one to the UI is not efficient and may cause problems in the future.
+
+            // Update all calendar states at once.
+            try
+            {
+                await _accountCalendarUpdateSemaphoreSlim.WaitAsync();
+
+                foreach (var calendar in e.AccountCalendars)
+                {
+                    await _calendarService.UpdateAccountCalendarAsync(calendar.AccountCalendar).ConfigureAwait(false);
+                }
+            }
+            catch (Exception ex)
+            {
+                Log.Error(ex, "Error while waiting for account calendar update semaphore.");
+            }
+            finally
+            {
+                _accountCalendarUpdateSemaphoreSlim.Release();
+            }
+        }
+
+        private async void UpdateAccountCalendarRequested(object sender, AccountCalendarViewModel e)
+            => await _calendarService.UpdateAccountCalendarAsync(e.AccountCalendar).ConfigureAwait(false);
+
+        private async Task InitializeAccountCalendarsAsync()
+        {
+            await Dispatcher.ExecuteOnUIThread(() => AccountCalendarStateService.ClearGroupedAccountCalendar());
+
+            var accounts = await _accountService.GetAccountsAsync().ConfigureAwait(false);
+
+            foreach (var account in accounts)
+            {
+                var accountCalendars = await _calendarService.GetAccountCalendarsAsync(account.Id).ConfigureAwait(false);
+                var calendarViewModels = new List<AccountCalendarViewModel>();
+
+                foreach (var calendar in accountCalendars)
+                {
+                    var calendarViewModel = new AccountCalendarViewModel(account, calendar);
+
+                    calendarViewModels.Add(calendarViewModel);
+                }
+
+                var groupedAccountCalendarViewModel = new GroupedAccountCalendarViewModel(account, calendarViewModels);
+
+                await Dispatcher.ExecuteOnUIThread(() =>
+                {
+                    AccountCalendarStateService.AddGroupedAccountCalendar(groupedAccountCalendarViewModel);
+                });
+            }
+        }
+
+        private void ForceNavigateCalendarDate()
+        {
+            if (SelectedMenuItemIndex == -1)
+            {
+                var args = new CalendarPageNavigationArgs()
+                {
+                    NavigationDate = _navigationDate ?? DateTime.Now.Date
+                };
+
+                // Already on calendar. Just navigate.
+                NavigationService.Navigate(WinoPage.CalendarPage, args);
+
+                _navigationDate = null;
+            }
+            else
+            {
+                SelectedMenuItemIndex = -1;
+            }
+        }
+
+        partial void OnSelectedMenuItemIndexChanged(int oldValue, int newValue)
+        {
+            switch (newValue)
+            {
+                case -1:
+                    ForceNavigateCalendarDate();
+                    break;
+                case 0:
+                    NavigationService.Navigate(WinoPage.ManageAccountsPage);
+                    break;
+                case 1:
+                    NavigationService.Navigate(WinoPage.SettingsPage);
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        [RelayCommand]
+        private async Task Sync()
+        {
+            // Sync all calendars.
+            var accounts = await _accountService.GetAccountsAsync().ConfigureAwait(false);
+
+            foreach (var account in accounts)
+            {
+                var t = new NewCalendarSynchronizationRequested(new CalendarSynchronizationOptions()
+                {
+                    AccountId = account.Id,
+                    Type = CalendarSynchronizationType.CalendarMetadata
+                }, SynchronizationSource.Client);
+
+                Messenger.Send(t);
+            }
+        }
+
+        /// <summary>
+        /// When calendar type switches, we need to navigate to the most ideal date.
+        /// This method returns that date.
+        /// </summary>
+        private DateTime GetDisplayTypeSwitchDate()
+        {
+            var settings = PreferencesService.GetCurrentCalendarSettings();
+            switch (StatePersistenceService.CalendarDisplayType)
+            {
+                case CalendarDisplayType.Day:
+                    if (HighlightedDateRange.IsInRange(DateTime.Now)) return DateTime.Now.Date;
+
+                    return HighlightedDateRange.StartDate;
+                case CalendarDisplayType.Week:
+                    if (HighlightedDateRange == null || HighlightedDateRange.IsInRange(DateTime.Now))
+                    {
+                        return DateTime.Now.Date.GetWeekStartDateForDate(settings.FirstDayOfWeek);
+                    }
+
+                    return HighlightedDateRange.StartDate.GetWeekStartDateForDate(settings.FirstDayOfWeek);
+                case CalendarDisplayType.WorkWeek:
+                    break;
+                case CalendarDisplayType.Month:
+                    break;
+                case CalendarDisplayType.Year:
+                    break;
+                default:
+                    break;
+            }
+
+            return DateTime.Today.Date;
+        }
+
+        private DateTime? _navigationDate;
+        private readonly IAccountService _accountService;
+        private readonly ICalendarService _calendarService;
+
+        #region Commands
+
+        [RelayCommand]
+        private void TodayClicked()
+        {
+            _navigationDate = DateTime.Now.Date;
+
+            ForceNavigateCalendarDate();
+        }
+
+        [RelayCommand]
+        public void ManageAccounts() => NavigationService.Navigate(WinoPage.AccountManagementPage);
+
+        [RelayCommand]
+        private Task ReconnectServerAsync() => ServerConnectionManager.ConnectAsync();
+
+        [RelayCommand]
+        private void DateClicked(CalendarViewDayClickedEventArgs clickedDateArgs)
+        {
+            _navigationDate = clickedDateArgs.ClickedDate;
+
+            ForceNavigateCalendarDate();
+        }
+
+        #endregion
+
+        public void Receive(VisibleDateRangeChangedMessage message) => HighlightedDateRange = message.DateRange;
+
+        /// <summary>
+        /// Sets the header navigation items based on visible date range and calendar type.
+        /// </summary>
+        private void UpdateDateNavigationHeaderItems()
+        {
+            DateNavigationHeaderItems.Clear();
+
+            // TODO: From settings
+            var testInfo = new CultureInfo("en-US");
+
+            switch (StatePersistenceService.CalendarDisplayType)
+            {
+                case CalendarDisplayType.Day:
+                case CalendarDisplayType.Week:
+                case CalendarDisplayType.WorkWeek:
+                case CalendarDisplayType.Month:
+                    DateNavigationHeaderItems.ReplaceRange(testInfo.DateTimeFormat.MonthNames);
+                    break;
+                case CalendarDisplayType.Year:
+                    break;
+                default:
+                    break;
+            }
+
+            SetDateNavigationHeaderItems();
+        }
+
+        partial void OnHighlightedDateRangeChanged(DateRange value) => SetDateNavigationHeaderItems();
+
+        private void SetDateNavigationHeaderItems()
+        {
+            if (HighlightedDateRange == null) return;
+
+            if (DateNavigationHeaderItems.Count == 0)
+            {
+                UpdateDateNavigationHeaderItems();
+            }
+
+            // TODO: Year view
+            var monthIndex = HighlightedDateRange.GetMostVisibleMonthIndex();
+
+            SelectedDateNavigationHeaderIndex = Math.Max(monthIndex - 1, -1);
+        }
+
+        public async void Receive(CalendarEnableStatusChangedMessage message)
+            => await ExecuteUIThread(() => IsCalendarEnabled = message.IsEnabled);
+
+        public void Receive(NavigateManageAccountsRequested message) => SelectedMenuItemIndex = 1;
+
+        public void Receive(CalendarDisplayTypeChangedMessage message) => OnPropertyChanged(nameof(IsVerticalCalendar));
+
+        public async void Receive(DetailsPageStateChangedMessage message)
+        {
+            await ExecuteUIThread(() =>
+            {
+                IsEventDetailsPageActive = message.IsActivated;
+
+                // TODO: This is for Wino Mail. Generalize this later on.
+                StatePersistenceService.IsReaderNarrowed = message.IsActivated;
+                StatePersistenceService.IsReadingMail = message.IsActivated;
+            });
+        }
+    }
+}

Wino.Calendar.ViewModels/CalendarPageViewModel.cs

@@ -0,0 +1,871 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using CommunityToolkit.Diagnostics;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using CommunityToolkit.Mvvm.Messaging;
+using MoreLinq;
+using Serilog;
+using Wino.Calendar.ViewModels.Data;
+using Wino.Calendar.ViewModels.Interfaces;
+using Wino.Calendar.ViewModels.Messages;
+using Wino.Core.Domain.Collections;
+using Wino.Core.Domain.Entities.Calendar;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Calendar;
+using Wino.Core.Domain.Models.Calendar.CalendarTypeStrategies;
+using Wino.Core.Domain.Models.Navigation;
+using Wino.Core.ViewModels;
+using Wino.Messaging.Client.Calendar;
+
+namespace Wino.Calendar.ViewModels
+{
+    public partial class CalendarPageViewModel : CalendarBaseViewModel,
+        IRecipient<LoadCalendarMessage>,
+        IRecipient<CalendarItemDeleted>,
+        IRecipient<CalendarSettingsUpdatedMessage>,
+        IRecipient<CalendarItemTappedMessage>,
+        IRecipient<CalendarItemDoubleTappedMessage>,
+        IRecipient<CalendarItemRightTappedMessage>
+    {
+        #region Quick Event Creation
+
+        [ObservableProperty]
+        private bool _isQuickEventDialogOpen;
+
+        [ObservableProperty]
+        [NotifyPropertyChangedFor(nameof(SelectedQuickEventAccountCalendarName))]
+        [NotifyCanExecuteChangedFor(nameof(SaveQuickEventCommand))]
+        private AccountCalendarViewModel _selectedQuickEventAccountCalendar;
+
+        public string SelectedQuickEventAccountCalendarName
+        {
+            get
+            {
+                return SelectedQuickEventAccountCalendar == null ? "Pick a calendar" : SelectedQuickEventAccountCalendar.Name;
+            }
+        }
+
+        [ObservableProperty]
+        private List<string> _hourSelectionStrings;
+
+        // To be able to revert the values when the user enters an invalid time.
+        private string _previousSelectedStartTimeString;
+        private string _previousSelectedEndTimeString;
+
+        [ObservableProperty]
+        private DateTime? _selectedQuickEventDate;
+
+        [ObservableProperty]
+        private bool _isAllDay;
+
+        [ObservableProperty]
+        [NotifyCanExecuteChangedFor(nameof(SaveQuickEventCommand))]
+        private string _selectedStartTimeString;
+
+        [ObservableProperty]
+        [NotifyCanExecuteChangedFor(nameof(SaveQuickEventCommand))]
+        private string _selectedEndTimeString;
+
+        [ObservableProperty]
+        private string _location;
+
+        [ObservableProperty]
+        [NotifyCanExecuteChangedFor(nameof(SaveQuickEventCommand))]
+        private string _eventName;
+
+        public DateTime QuickEventStartTime => SelectedQuickEventDate.Value.Date.Add(CurrentSettings.GetTimeSpan(SelectedStartTimeString).Value);
+        public DateTime QuickEventEndTime => SelectedQuickEventDate.Value.Date.Add(CurrentSettings.GetTimeSpan(SelectedEndTimeString).Value);
+
+        public bool CanSaveQuickEvent => SelectedQuickEventAccountCalendar != null &&
+                                        !string.IsNullOrWhiteSpace(EventName) &&
+                                        !string.IsNullOrWhiteSpace(SelectedStartTimeString) &&
+                                        !string.IsNullOrWhiteSpace(SelectedEndTimeString) &&
+                                        QuickEventEndTime > QuickEventStartTime;
+
+        #endregion
+
+        #region Data Initialization
+
+        [ObservableProperty]
+        private CalendarOrientation _calendarOrientation = CalendarOrientation.Horizontal;
+
+        [ObservableProperty]
+        private DayRangeCollection _dayRanges = [];
+
+        [ObservableProperty]
+        private int _selectedDateRangeIndex;
+
+        [ObservableProperty]
+        private DayRangeRenderModel _selectedDayRange;
+
+        [ObservableProperty]
+        private bool _isCalendarEnabled = true;
+
+        #endregion
+
+        #region Event Details
+
+        public event EventHandler DetailsShowCalendarItemChanged;
+
+        [ObservableProperty]
+        [NotifyPropertyChangedFor(nameof(IsEventDetailsVisible))]
+        private CalendarItemViewModel _displayDetailsCalendarItemViewModel;
+
+        public bool IsEventDetailsVisible => DisplayDetailsCalendarItemViewModel != null;
+
+        #endregion
+
+        // TODO: Get rid of some of the items if we have too many.
+        private const int maxDayRangeSize = 10;
+
+        private readonly ICalendarService _calendarService;
+        private readonly INavigationService _navigationService;
+        private readonly IKeyPressService _keyPressService;
+        private readonly IPreferencesService _preferencesService;
+
+        // Store latest rendered options.
+        private CalendarDisplayType _currentDisplayType;
+        private int _displayDayCount;
+
+        private SemaphoreSlim _calendarLoadingSemaphore = new(1);
+        private bool isLoadMoreBlocked = false;
+
+        [ObservableProperty]
+        private CalendarSettings _currentSettings;
+
+        public IStatePersistanceService StatePersistanceService { get; }
+        public IAccountCalendarStateService AccountCalendarStateService { get; }
+
+        public CalendarPageViewModel(IStatePersistanceService statePersistanceService,
+                                     ICalendarService calendarService,
+                                     INavigationService navigationService,
+                                     IKeyPressService keyPressService,
+                                     IAccountCalendarStateService accountCalendarStateService,
+                                     IPreferencesService preferencesService)
+        {
+            StatePersistanceService = statePersistanceService;
+            AccountCalendarStateService = accountCalendarStateService;
+
+            _calendarService = calendarService;
+            _navigationService = navigationService;
+            _keyPressService = keyPressService;
+            _preferencesService = preferencesService;
+
+            AccountCalendarStateService.AccountCalendarSelectionStateChanged += UpdateAccountCalendarRequested;
+            AccountCalendarStateService.CollectiveAccountGroupSelectionStateChanged += AccountCalendarStateCollectivelyChanged;
+        }
+
+        private void AccountCalendarStateCollectivelyChanged(object sender, GroupedAccountCalendarViewModel e)
+            => FilterActiveCalendars(DayRanges);
+
+        private void UpdateAccountCalendarRequested(object sender, AccountCalendarViewModel e)
+            => FilterActiveCalendars(DayRanges);
+
+        private async void FilterActiveCalendars(IEnumerable<DayRangeRenderModel> dayRangeRenderModels)
+        {
+            await ExecuteUIThread(() =>
+            {
+                var days = dayRangeRenderModels.SelectMany(a => a.CalendarDays);
+
+                days.ForEach(a => a.EventsCollection.FilterByCalendars(AccountCalendarStateService.ActiveCalendars.Select(a => a.Id)));
+
+                DisplayDetailsCalendarItemViewModel = null;
+            });
+        }
+
+        // TODO: Replace when calendar settings are updated.
+        // Should be a field ideally.
+        private BaseCalendarTypeDrawingStrategy GetDrawingStrategy(CalendarDisplayType displayType)
+        {
+            return displayType switch
+            {
+                CalendarDisplayType.Day => new DayCalendarDrawingStrategy(CurrentSettings),
+                CalendarDisplayType.Week => new WeekCalendarDrawingStrategy(CurrentSettings),
+                CalendarDisplayType.Month => new MonthCalendarDrawingStrategy(CurrentSettings),
+                _ => throw new NotImplementedException(),
+            };
+        }
+
+        public override void OnNavigatedFrom(NavigationMode mode, object parameters)
+        {
+            // Do not call base method because that will unregister messenger recipient.
+            // This is a singleton view model and should not be unregistered.
+        }
+
+        public override void OnNavigatedTo(NavigationMode mode, object parameters)
+        {
+            base.OnNavigatedTo(mode, parameters);
+
+            if (mode == NavigationMode.Back) return;
+
+            RefreshSettings();
+
+            // Automatically select the first primary calendar for quick event dialog.
+            SelectedQuickEventAccountCalendar = AccountCalendarStateService.ActiveCalendars.FirstOrDefault(a => a.IsPrimary);
+        }
+
+        [RelayCommand]
+        private void NavigateSeries()
+        {
+            if (DisplayDetailsCalendarItemViewModel == null) return;
+
+            NavigateEvent(DisplayDetailsCalendarItemViewModel, CalendarEventTargetType.Series);
+        }
+
+        [RelayCommand]
+        private void NavigateEventDetails()
+        {
+            if (DisplayDetailsCalendarItemViewModel == null) return;
+
+            NavigateEvent(DisplayDetailsCalendarItemViewModel, CalendarEventTargetType.Single);
+        }
+
+        private void NavigateEvent(CalendarItemViewModel calendarItemViewModel, CalendarEventTargetType calendarEventTargetType)
+        {
+            var target = new CalendarItemTarget(calendarItemViewModel.CalendarItem, calendarEventTargetType);
+            _navigationService.Navigate(WinoPage.EventDetailsPage, target);
+        }
+
+        [RelayCommand(AllowConcurrentExecutions = false, CanExecute = nameof(CanSaveQuickEvent))]
+        private async Task SaveQuickEventAsync()
+        {
+            var durationSeconds = (QuickEventEndTime - QuickEventStartTime).TotalSeconds;
+
+            var testCalendarItem = new CalendarItem
+            {
+                CalendarId = SelectedQuickEventAccountCalendar.Id,
+                StartDate = QuickEventStartTime,
+                DurationInSeconds = durationSeconds,
+                CreatedAt = DateTime.UtcNow,
+                Description = string.Empty,
+                Location = Location,
+                Title = EventName,
+                Id = Guid.NewGuid()
+            };
+
+            IsQuickEventDialogOpen = false;
+            await _calendarService.CreateNewCalendarItemAsync(testCalendarItem, null);
+
+            // TODO: Create the request with the synchronizer.
+        }
+
+        [RelayCommand]
+        private void MoreDetails()
+        {
+            // TODO: Navigate to advanced event creation  page with existing parameters.
+        }
+
+        public void SelectQuickEventTimeRange(TimeSpan startTime, TimeSpan endTime)
+        {
+            IsAllDay = false;
+
+            SelectedStartTimeString = CurrentSettings.GetTimeString(startTime);
+            SelectedEndTimeString = CurrentSettings.GetTimeString(endTime);
+        }
+
+        // Manage event detail popup context and select-unselect the proper items.
+        // Item selection rules are defined in the selection method.
+        partial void OnDisplayDetailsCalendarItemViewModelChanging(CalendarItemViewModel oldValue, CalendarItemViewModel newValue)
+        {
+            if (oldValue != null)
+            {
+                UnselectCalendarItem(oldValue);
+            }
+
+            if (newValue != null)
+            {
+                SelectCalendarItem(newValue);
+            }
+        }
+
+        // Notify view that the detail context changed.
+        // This will align the event detail popup to the selected event.
+        partial void OnDisplayDetailsCalendarItemViewModelChanged(CalendarItemViewModel value)
+            => DetailsShowCalendarItemChanged?.Invoke(this, EventArgs.Empty);
+
+        private void RefreshSettings()
+        {
+            CurrentSettings = _preferencesService.GetCurrentCalendarSettings();
+
+            // Populate the hour selection strings.
+            var timeStrings = new List<string>();
+
+            for (int hour = 0; hour < 24; hour++)
+            {
+                for (int minute = 0; minute < 60; minute += 30)
+                {
+                    var time = new DateTime(1, 1, 1, hour, minute, 0);
+
+                    if (CurrentSettings.DayHeaderDisplayType == DayHeaderDisplayType.TwentyFourHour)
+                    {
+                        timeStrings.Add(time.ToString("HH:mm"));
+                    }
+                    else
+                    {
+                        timeStrings.Add(time.ToString("h:mm tt"));
+                    }
+                }
+            }
+
+            HourSelectionStrings = timeStrings;
+        }
+
+        partial void OnIsCalendarEnabledChanging(bool oldValue, bool newValue) => Messenger.Send(new CalendarEnableStatusChangedMessage(newValue));
+
+        private bool ShouldResetDayRanges(LoadCalendarMessage message)
+        {
+            if (message.ForceRedraw) return true;
+
+            // Never reset if the initiative is from the app.
+            if (message.CalendarInitInitiative == CalendarInitInitiative.App) return false;
+
+            // 1. Display type is different.
+            // 2. Day display count is different.
+            // 3. Display date is not in the visible range.
+
+            if (DayRanges.DisplayRange == null) return false;
+
+            return
+                (_currentDisplayType != StatePersistanceService.CalendarDisplayType ||
+                _displayDayCount != StatePersistanceService.DayDisplayCount ||
+                !(message.DisplayDate >= DayRanges.DisplayRange.StartDate && message.DisplayDate <= DayRanges.DisplayRange.EndDate));
+        }
+
+        private void AdjustCalendarOrientation()
+        {
+            // Orientation only changes when we should reset.
+            // Handle the FlipView orientation here.
+            // We don't want to change the orientation while the item manipulation is going on.
+            // That causes a glitch in the UI.
+
+            bool isRequestedVerticalCalendar = StatePersistanceService.CalendarDisplayType == CalendarDisplayType.Month;
+            bool isLastRenderedVerticalCalendar = _currentDisplayType == CalendarDisplayType.Month;
+
+            if (isRequestedVerticalCalendar && !isLastRenderedVerticalCalendar)
+            {
+                CalendarOrientation = CalendarOrientation.Vertical;
+            }
+            else
+            {
+                CalendarOrientation = CalendarOrientation.Horizontal;
+            }
+        }
+
+        public async void Receive(LoadCalendarMessage message)
+        {
+            await _calendarLoadingSemaphore.WaitAsync();
+
+            try
+            {
+                await ExecuteUIThread(() => IsCalendarEnabled = false);
+
+                if (ShouldResetDayRanges(message))
+                {
+                    Debug.WriteLine("Will reset day ranges.");
+                    await ClearDayRangeModelsAsync();
+                }
+                else if (ShouldScrollToItem(message))
+                {
+                    // Scroll to the selected date.
+                    Messenger.Send(new ScrollToDateMessage(message.DisplayDate));
+                    Debug.WriteLine("Scrolling to selected date.");
+                    return;
+                }
+
+                AdjustCalendarOrientation();
+
+                // This will replace the whole collection because the user initiated a new render.
+                await RenderDatesAsync(message.CalendarInitInitiative,
+                                       message.DisplayDate,
+                                       CalendarLoadDirection.Replace);
+
+                // Scroll to the current hour.
+                Messenger.Send(new ScrollToHourMessage(TimeSpan.FromHours(DateTime.Now.Hour)));
+            }
+            catch (Exception ex)
+            {
+                Log.Error(ex, "Error while loading calendar.");
+                Debugger.Break();
+            }
+            finally
+            {
+                _calendarLoadingSemaphore.Release();
+
+                await ExecuteUIThread(() => IsCalendarEnabled = true);
+            }
+        }
+
+
+        private async Task AddDayRangeModelAsync(DayRangeRenderModel dayRangeRenderModel)
+        {
+            if (dayRangeRenderModel == null) return;
+
+            await ExecuteUIThread(() =>
+            {
+                DayRanges.Add(dayRangeRenderModel);
+            });
+        }
+
+        private async Task InsertDayRangeModelAsync(DayRangeRenderModel dayRangeRenderModel, int index)
+        {
+            if (dayRangeRenderModel == null) return;
+
+            await ExecuteUIThread(() =>
+            {
+                DayRanges.Insert(index, dayRangeRenderModel);
+            });
+        }
+
+        private async Task RemoveDayRangeModelAsync(DayRangeRenderModel dayRangeRenderModel)
+        {
+            if (dayRangeRenderModel == null) return;
+
+            await ExecuteUIThread(() =>
+            {
+                DayRanges.Remove(dayRangeRenderModel);
+            });
+        }
+
+        private async Task ClearDayRangeModelsAsync()
+        {
+            await ExecuteUIThread(() =>
+            {
+                DayRanges.Clear();
+            });
+        }
+
+        private async Task RenderDatesAsync(CalendarInitInitiative calendarInitInitiative,
+                                            DateTime? loadingDisplayDate = null,
+                                            CalendarLoadDirection calendarLoadDirection = CalendarLoadDirection.Replace)
+        {
+            isLoadMoreBlocked = calendarLoadDirection == CalendarLoadDirection.Replace;
+
+            // This is the part we arrange the flip view calendar logic.
+
+            /* Loading for a month of the selected date is fine.
+             * If the selected date is in the loaded range, we'll just change the selected flip index to scroll.
+             * If the selected date is not in the loaded range:
+             * 1. Detect the direction of the scroll.
+             * 2. Load the next month.
+             * 3. Replace existing month with the new month.
+             */
+
+            // 2 things are important: How many items should 1 flip have, and, where we should start loading?
+
+            // User initiated renders must always have a date to start with.
+            if (calendarInitInitiative == CalendarInitInitiative.User) Guard.IsNotNull(loadingDisplayDate, nameof(loadingDisplayDate));
+
+            var strategy = GetDrawingStrategy(StatePersistanceService.CalendarDisplayType);
+            var displayDate = loadingDisplayDate.GetValueOrDefault();
+
+            // How many days should be placed in 1 flip view item?
+            int eachFlipItemCount = strategy.GetRenderDayCount(displayDate, StatePersistanceService.DayDisplayCount);
+
+            DateRange flipLoadRange = null;
+
+
+            if (calendarInitInitiative == CalendarInitInitiative.User || DayRanges.DisplayRange == null)
+            {
+                flipLoadRange = strategy.GetRenderDateRange(displayDate, StatePersistanceService.DayDisplayCount);
+            }
+            else
+            {
+                // App is trying to load.
+                // This should be based on direction. We'll load the next or previous range.
+                // DisplayDate is either the start or end date of the current visible range.
+
+                if (calendarLoadDirection == CalendarLoadDirection.Previous)
+                {
+                    flipLoadRange = strategy.GetPreviousDateRange(DayRanges.DisplayRange, StatePersistanceService.DayDisplayCount);
+                }
+                else
+                {
+                    flipLoadRange = strategy.GetNextDateRange(DayRanges.DisplayRange, StatePersistanceService.DayDisplayCount);
+                }
+            }
+
+            // Create day ranges for each flip item until we reach the total days to load.
+            int totalFlipItemCount = (int)Math.Ceiling((double)flipLoadRange.TotalDays / eachFlipItemCount);
+
+            List<DayRangeRenderModel> renderModels = new();
+
+            for (int i = 0; i < totalFlipItemCount; i++)
+            {
+                var startDate = flipLoadRange.StartDate.AddDays(i * eachFlipItemCount);
+                var endDate = startDate.AddDays(eachFlipItemCount);
+
+                var range = new DateRange(startDate, endDate);
+                var renderOptions = new CalendarRenderOptions(range, CurrentSettings);
+
+                var dayRangeHeaderModel = new DayRangeRenderModel(renderOptions);
+                renderModels.Add(dayRangeHeaderModel);
+            }
+
+            // Dates are loaded. Now load the events for them.
+            foreach (var renderModel in renderModels)
+            {
+                await InitializeCalendarEventsForDayRangeAsync(renderModel).ConfigureAwait(false);
+            }
+
+            // Filter by active calendars. This is a quick operation, and things are not on the UI yet.
+            FilterActiveCalendars(renderModels);
+
+            CalendarLoadDirection animationDirection = calendarLoadDirection;
+
+            //bool removeCurrent = calendarLoadDirection == CalendarLoadDirection.Replace;
+
+            if (calendarLoadDirection == CalendarLoadDirection.Replace)
+            {
+                // New date ranges are being replaced.
+                // We must preserve existing selection if any, add the items before/after the current one, remove the current one.
+                // This will make sure the new dates are animated in the correct direction.
+
+                isLoadMoreBlocked = true;
+
+                // Remove all other dates except this one.
+                var rangesToRemove = DayRanges.Where(a => a != SelectedDayRange).ToList();
+
+                foreach (var range in rangesToRemove)
+                {
+                    await RemoveDayRangeModelAsync(range);
+                }
+
+                animationDirection = displayDate <= SelectedDayRange?.CalendarRenderOptions.DateRange.StartDate ?
+                    CalendarLoadDirection.Previous : CalendarLoadDirection.Next;
+            }
+
+            if (animationDirection == CalendarLoadDirection.Next)
+            {
+                foreach (var item in renderModels)
+                {
+                    await AddDayRangeModelAsync(item);
+                }
+            }
+            else if (animationDirection == CalendarLoadDirection.Previous)
+            {
+                // Wait for the animation to finish.
+                // Otherwise it somehow shutters a little, which is annoying.
+
+                // if (!removeCurrent) await Task.Delay(350);
+
+                // Insert each render model in reverse order.
+                for (int i = renderModels.Count - 1; i >= 0; i--)
+                {
+                    await InsertDayRangeModelAsync(renderModels[i], 0);
+                }
+            }
+
+            Debug.WriteLine($"Flip count: ({DayRanges.Count})");
+
+            foreach (var item in DayRanges)
+            {
+                Debug.WriteLine($"- {item.CalendarRenderOptions.DateRange.ToString()}");
+            }
+
+            //if (removeCurrent)
+            //{
+            //    await RemoveDayRangeModelAsync(SelectedDayRange);
+            //}
+
+            // TODO...
+            // await TryConsolidateItemsAsync();
+
+            isLoadMoreBlocked = false;
+
+            // Only scroll if the render is initiated by user.
+            // Otherwise we'll scroll to the app rendered invisible date range.
+            if (calendarInitInitiative == CalendarInitInitiative.User)
+            {
+                // Save the current settings for the page for later comparison.
+                _currentDisplayType = StatePersistanceService.CalendarDisplayType;
+                _displayDayCount = StatePersistanceService.DayDisplayCount;
+
+                Messenger.Send(new ScrollToDateMessage(displayDate));
+            }
+        }
+
+        protected override async void OnCalendarItemAdded(CalendarItem calendarItem)
+        {
+            base.OnCalendarItemAdded(calendarItem);
+
+            // Check if event falls into the current date range.
+
+
+            if (DayRanges.DisplayRange == null) return;
+
+            // Check whether this event falls into any of the loaded date ranges.
+            var allDaysForEvent = DayRanges.SelectMany(a => a.CalendarDays).Where(a => a.Period.OverlapsWith(calendarItem.Period));
+
+            foreach (var calendarDay in allDaysForEvent)
+            {
+                var calendarItemViewModel = new CalendarItemViewModel(calendarItem);
+
+                await ExecuteUIThread(() =>
+                {
+                    calendarDay.EventsCollection.AddCalendarItem(calendarItemViewModel);
+                });
+            }
+
+            FilterActiveCalendars(DayRanges);
+        }
+
+        private async Task InitializeCalendarEventsForDayRangeAsync(DayRangeRenderModel dayRangeRenderModel)
+        {
+            // Clear all events first for all days.
+            foreach (var day in dayRangeRenderModel.CalendarDays)
+            {
+                await ExecuteUIThread(() =>
+                {
+                    day.EventsCollection.Clear();
+                });
+            }
+
+            // Initialization is done for all calendars, regardless whether they are actively selected or not.
+            // This is because the filtering is cached internally of the calendar items in CalendarEventCollection.
+            var allCalendars = AccountCalendarStateService.GroupedAccountCalendars.SelectMany(a => a.AccountCalendars);
+
+            foreach (var calendarViewModel in allCalendars)
+            {
+                // Check all the events for the given date range and calendar.
+                // Then find the day representation for all the events returned, and add to the collection.
+
+                var events = await _calendarService.GetCalendarEventsAsync(calendarViewModel, dayRangeRenderModel).ConfigureAwait(false);
+
+                foreach (var @event in events)
+                {
+                    // Find the days that the event falls into.
+                    var allDaysForEvent = dayRangeRenderModel.CalendarDays.Where(a => a.Period.OverlapsWith(@event.Period));
+
+                    foreach (var calendarDay in allDaysForEvent)
+                    {
+                        var calendarItemViewModel = new CalendarItemViewModel(@event);
+                        await ExecuteUIThread(() =>
+                        {
+                            calendarDay.EventsCollection.AddCalendarItem(calendarItemViewModel);
+                        });
+                    }
+                }
+            }
+        }
+
+        private async Task TryConsolidateItemsAsync()
+        {
+            // Check if trimming is necessary
+            if (DayRanges.Count > maxDayRangeSize)
+            {
+                Debug.WriteLine("Trimming items.");
+
+                isLoadMoreBlocked = true;
+
+                var removeCount = DayRanges.Count - maxDayRangeSize;
+
+                await Task.Delay(500);
+
+                // Right shifted, remove from the start.
+                if (SelectedDateRangeIndex > DayRanges.Count / 2)
+                {
+                    DayRanges.RemoveRange(DayRanges.Take(removeCount).ToList());
+                }
+                else
+                {
+                    // Left shifted, remove from the end.
+                    DayRanges.RemoveRange(DayRanges.Skip(DayRanges.Count - removeCount).Take(removeCount));
+                }
+
+                SelectedDateRangeIndex = DayRanges.IndexOf(SelectedDayRange);
+            }
+        }
+
+        private bool ShouldScrollToItem(LoadCalendarMessage message)
+        {
+            // Never scroll if the initiative is from the app.
+            if (message.CalendarInitInitiative == CalendarInitInitiative.App) return false;
+
+            // Nothing to scroll.
+            if (DayRanges.Count == 0) return false;
+
+            if (DayRanges.DisplayRange == null) return false;
+
+            var selectedDate = message.DisplayDate;
+
+            return selectedDate >= DayRanges.DisplayRange.StartDate && selectedDate <= DayRanges.DisplayRange.EndDate;
+        }
+
+        partial void OnIsAllDayChanged(bool value)
+        {
+            if (value)
+            {
+                SelectedStartTimeString = HourSelectionStrings.FirstOrDefault();
+                SelectedEndTimeString = HourSelectionStrings.FirstOrDefault();
+            }
+            else
+            {
+                SelectedStartTimeString = _previousSelectedStartTimeString;
+                SelectedEndTimeString = _previousSelectedEndTimeString;
+            }
+        }
+
+        partial void OnSelectedStartTimeStringChanged(string newValue)
+        {
+            var parsedTime = CurrentSettings.GetTimeSpan(newValue);
+
+            if (parsedTime == null)
+            {
+                SelectedStartTimeString = _previousSelectedStartTimeString;
+            }
+            else if (IsAllDay)
+            {
+                _previousSelectedStartTimeString = newValue;
+            }
+        }
+
+        partial void OnSelectedEndTimeStringChanged(string newValue)
+        {
+            var parsedTime = CurrentSettings.GetTimeSpan(newValue);
+
+            if (parsedTime == null)
+            {
+                SelectedEndTimeString = _previousSelectedStartTimeString;
+            }
+            else if (IsAllDay)
+            {
+                _previousSelectedEndTimeString = newValue;
+            }
+        }
+
+        partial void OnSelectedDayRangeChanged(DayRangeRenderModel value)
+        {
+            DisplayDetailsCalendarItemViewModel = null;
+
+            if (DayRanges.Count == 0 || SelectedDateRangeIndex < 0) return;
+
+            var selectedRange = DayRanges[SelectedDateRangeIndex];
+
+            Messenger.Send(new VisibleDateRangeChangedMessage(new DateRange(selectedRange.Period.Start, selectedRange.Period.End)));
+
+            if (isLoadMoreBlocked) return;
+
+            _ = LoadMoreAsync();
+        }
+
+        private async Task LoadMoreAsync()
+        {
+            try
+            {
+                await _calendarLoadingSemaphore.WaitAsync();
+
+                // Depending on the selected index, we'll load more dates.
+                // Day ranges may change while the async update is in progress.
+                // Therefore we wait for semaphore to be released before we continue.
+                // There is no need to load more if the current index is not in ideal position.
+
+                if (SelectedDateRangeIndex == 0)
+                {
+                    await RenderDatesAsync(CalendarInitInitiative.App, calendarLoadDirection: CalendarLoadDirection.Previous);
+                }
+                else if (SelectedDateRangeIndex == DayRanges.Count - 1)
+                {
+                    await RenderDatesAsync(CalendarInitInitiative.App, calendarLoadDirection: CalendarLoadDirection.Next);
+                }
+            }
+            catch (Exception)
+            {
+                Debugger.Break();
+            }
+            finally
+            {
+                _calendarLoadingSemaphore.Release();
+            }
+        }
+
+        public void Receive(CalendarSettingsUpdatedMessage message)
+        {
+            RefreshSettings();
+
+            // TODO: This might need throttling due to slider in the settings page for hour height.
+            // or make sure the slider does not update on each tick but on focus lost.
+
+            // Messenger.Send(new LoadCalendarMessage(DateTime.UtcNow.Date, CalendarInitInitiative.App, true));
+        }
+
+        private IEnumerable<CalendarItemViewModel> GetCalendarItems(CalendarItemViewModel calendarItemViewModel, CalendarDayModel selectedDay)
+        {
+            // All-day and multi-day events are selected collectively.
+            // Recurring events must be selected as a single instance.
+            // We need to find the day that the event is in, and then select the event.
+
+            if (!calendarItemViewModel.IsRecurringEvent)
+            {
+                return [calendarItemViewModel];
+            }
+            else
+            {
+                return DayRanges
+                    .SelectMany(a => a.CalendarDays)
+                    .Select(b => b.EventsCollection.GetCalendarItem(calendarItemViewModel.Id))
+                    .Where(c => c != null)
+                    .Cast<CalendarItemViewModel>()
+                    .Distinct();
+            }
+        }
+
+        private void UnselectCalendarItem(CalendarItemViewModel calendarItemViewModel, CalendarDayModel calendarDay = null)
+        {
+            if (calendarItemViewModel == null) return;
+
+            var itemsToUnselect = GetCalendarItems(calendarItemViewModel, calendarDay);
+
+            foreach (var item in itemsToUnselect)
+            {
+                item.IsSelected = false;
+            }
+        }
+
+        private void SelectCalendarItem(CalendarItemViewModel calendarItemViewModel, CalendarDayModel calendarDay = null)
+        {
+            if (calendarItemViewModel == null) return;
+
+            var itemsToSelect = GetCalendarItems(calendarItemViewModel, calendarDay);
+
+            foreach (var item in itemsToSelect)
+            {
+                item.IsSelected = true;
+            }
+        }
+
+        public void Receive(CalendarItemTappedMessage message)
+        {
+            if (message.CalendarItemViewModel == null) return;
+
+            DisplayDetailsCalendarItemViewModel = message.CalendarItemViewModel;
+        }
+
+        public void Receive(CalendarItemDoubleTappedMessage message) => NavigateEvent(message.CalendarItemViewModel, CalendarEventTargetType.Single);
+
+        public void Receive(CalendarItemRightTappedMessage message)
+        {
+
+        }
+
+        public async void Receive(CalendarItemDeleted message)
+        {
+            // Each deleted recurrence will report for it's own.
+
+            await ExecuteUIThread(() =>
+            {
+                var deletedItem = message.CalendarItem;
+
+                // Event might be spreaded into multiple days.
+                // Remove from all.
+
+                // var calendarItems = GetCalendarItems(deletedItem.Id);
+            });
+        }
+    }
+}

Wino.Calendar.ViewModels/CalendarSettingsPageViewModel.cs

@@ -0,0 +1,127 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Messaging;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Translations;
+using Wino.Core.ViewModels;
+using Wino.Messaging.Client.Calendar;
+
+namespace Wino.Calendar.ViewModels
+{
+    public partial class CalendarSettingsPageViewModel : CalendarBaseViewModel
+    {
+        [ObservableProperty]
+        private double _cellHourHeight;
+
+        [ObservableProperty]
+        private int _selectedFirstDayOfWeekIndex;
+
+        [ObservableProperty]
+        private bool _is24HourHeaders;
+
+        [ObservableProperty]
+        private TimeSpan _workingHourStart;
+
+        [ObservableProperty]
+        private TimeSpan _workingHourEnd;
+
+        [ObservableProperty]
+        private List<string> _dayNames = [];
+
+        [ObservableProperty]
+        private int _workingDayStartIndex;
+
+        [ObservableProperty]
+        private int _workingDayEndIndex;
+
+        public IPreferencesService PreferencesService { get; }
+
+        private readonly bool _isLoaded = false;
+
+        public CalendarSettingsPageViewModel(IPreferencesService preferencesService)
+        {
+            PreferencesService = preferencesService;
+
+            var currentLanguageLanguageCode = WinoTranslationDictionary.GetLanguageFileNameRelativePath(preferencesService.CurrentLanguage);
+
+            var cultureInfo = new CultureInfo(currentLanguageLanguageCode);
+
+            // Populate the day names list
+            for (var i = 0; i < 7; i++)
+            {
+                _dayNames.Add(cultureInfo.DateTimeFormat.DayNames[i]);
+            }
+
+            var cultureFirstDayName = cultureInfo.DateTimeFormat.GetDayName(preferencesService.FirstDayOfWeek);
+
+            _selectedFirstDayOfWeekIndex = _dayNames.IndexOf(cultureFirstDayName);
+            _is24HourHeaders = preferencesService.Prefer24HourTimeFormat;
+            _workingHourStart = preferencesService.WorkingHourStart;
+            _workingHourEnd = preferencesService.WorkingHourEnd;
+            _cellHourHeight = preferencesService.HourHeight;
+
+            _workingDayStartIndex = _dayNames.IndexOf(cultureInfo.DateTimeFormat.GetDayName(preferencesService.WorkingDayStart));
+            _workingDayEndIndex = _dayNames.IndexOf(cultureInfo.DateTimeFormat.GetDayName(preferencesService.WorkingDayEnd));
+
+            _isLoaded = true;
+        }
+
+        partial void OnCellHourHeightChanged(double oldValue, double newValue) => SaveSettings();
+        partial void OnIs24HourHeadersChanged(bool value) => SaveSettings();
+        partial void OnSelectedFirstDayOfWeekIndexChanged(int value) => SaveSettings();
+        partial void OnWorkingHourStartChanged(TimeSpan value) => SaveSettings();
+        partial void OnWorkingHourEndChanged(TimeSpan value) => SaveSettings();
+        partial void OnWorkingDayStartIndexChanged(int value) => SaveSettings();
+        partial void OnWorkingDayEndIndexChanged(int value) => SaveSettings();
+
+        public void SaveSettings()
+        {
+            if (!_isLoaded) return;
+
+            PreferencesService.FirstDayOfWeek = SelectedFirstDayOfWeekIndex switch
+            {
+                0 => DayOfWeek.Sunday,
+                1 => DayOfWeek.Monday,
+                2 => DayOfWeek.Tuesday,
+                3 => DayOfWeek.Wednesday,
+                4 => DayOfWeek.Thursday,
+                5 => DayOfWeek.Friday,
+                6 => DayOfWeek.Saturday,
+                _ => throw new ArgumentOutOfRangeException()
+            };
+
+            PreferencesService.WorkingDayStart = WorkingDayStartIndex switch
+            {
+                0 => DayOfWeek.Sunday,
+                1 => DayOfWeek.Monday,
+                2 => DayOfWeek.Tuesday,
+                3 => DayOfWeek.Wednesday,
+                4 => DayOfWeek.Thursday,
+                5 => DayOfWeek.Friday,
+                6 => DayOfWeek.Saturday,
+                _ => throw new ArgumentOutOfRangeException()
+            };
+
+            PreferencesService.WorkingDayEnd = WorkingDayEndIndex switch
+            {
+                0 => DayOfWeek.Sunday,
+                1 => DayOfWeek.Monday,
+                2 => DayOfWeek.Tuesday,
+                3 => DayOfWeek.Wednesday,
+                4 => DayOfWeek.Thursday,
+                5 => DayOfWeek.Friday,
+                6 => DayOfWeek.Saturday,
+                _ => throw new ArgumentOutOfRangeException()
+            };
+
+            PreferencesService.Prefer24HourTimeFormat = Is24HourHeaders;
+            PreferencesService.WorkingHourStart = WorkingHourStart;
+            PreferencesService.WorkingHourEnd = WorkingHourEnd;
+            PreferencesService.HourHeight = CellHourHeight;
+
+            Messenger.Send(new CalendarSettingsUpdatedMessage());
+        }
+    }
+}

Wino.Calendar.ViewModels/CalendarViewModelContainerSetup.cs

@@ -0,0 +1,13 @@
+using Microsoft.Extensions.DependencyInjection;
+using Wino.Core;
+
+namespace Wino.Calendar.ViewModels
+{
+    public static class CalendarViewModelContainerSetup
+    {
+        public static void RegisterCalendarViewModelServices(this IServiceCollection services)
+        {
+            services.RegisterCoreServices();
+        }
+    }
+}

Wino.Calendar.ViewModels/Data/AccountCalendarViewModel.cs

@@ -0,0 +1,70 @@
+using System;
+using CommunityToolkit.Mvvm.ComponentModel;
+using Wino.Core.Domain.Entities.Calendar;
+using Wino.Core.Domain.Entities.Shared;
+using Wino.Core.Domain.Interfaces;
+
+namespace Wino.Calendar.ViewModels.Data
+{
+    public partial class AccountCalendarViewModel : ObservableObject, IAccountCalendar
+    {
+        public MailAccount Account { get; }
+        public AccountCalendar AccountCalendar { get; }
+
+        public AccountCalendarViewModel(MailAccount account, AccountCalendar accountCalendar)
+        {
+            Account = account;
+            AccountCalendar = accountCalendar;
+
+            IsChecked = accountCalendar.IsExtended;
+        }
+
+        [ObservableProperty]
+        private bool _isChecked;
+
+        partial void OnIsCheckedChanged(bool value) => IsExtended = value;
+
+        public string Name
+        {
+            get => AccountCalendar.Name;
+            set => SetProperty(AccountCalendar.Name, value, AccountCalendar, (u, n) => u.Name = n);
+        }
+
+        public string TextColorHex
+        {
+            get => AccountCalendar.TextColorHex;
+            set => SetProperty(AccountCalendar.TextColorHex, value, AccountCalendar, (u, t) => u.TextColorHex = t);
+        }
+
+        public string BackgroundColorHex
+        {
+            get => AccountCalendar.BackgroundColorHex;
+            set => SetProperty(AccountCalendar.BackgroundColorHex, value, AccountCalendar, (u, b) => u.BackgroundColorHex = b);
+        }
+
+        public bool IsExtended
+        {
+            get => AccountCalendar.IsExtended;
+            set => SetProperty(AccountCalendar.IsExtended, value, AccountCalendar, (u, i) => u.IsExtended = i);
+        }
+
+        public bool IsPrimary
+        {
+            get => AccountCalendar.IsPrimary;
+            set => SetProperty(AccountCalendar.IsPrimary, value, AccountCalendar, (u, i) => u.IsPrimary = i);
+        }
+
+        public Guid AccountId
+        {
+            get => AccountCalendar.AccountId;
+            set => SetProperty(AccountCalendar.AccountId, value, AccountCalendar, (u, a) => u.AccountId = a);
+        }
+
+        public string RemoteCalendarId
+        {
+            get => AccountCalendar.RemoteCalendarId;
+            set => SetProperty(AccountCalendar.RemoteCalendarId, value, AccountCalendar, (u, r) => u.RemoteCalendarId = r);
+        }
+        public Guid Id { get => ((IAccountCalendar)AccountCalendar).Id; set => ((IAccountCalendar)AccountCalendar).Id = value; }
+    }
+}

Wino.Calendar.ViewModels/Data/CalendarItemViewModel.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.ObjectModel;
+using CommunityToolkit.Mvvm.ComponentModel;
+using Itenso.TimePeriod;
+using Wino.Core.Domain.Entities.Calendar;
+using Wino.Core.Domain.Interfaces;
+
+namespace Wino.Calendar.ViewModels.Data
+{
+    public partial class CalendarItemViewModel : ObservableObject, ICalendarItem, ICalendarItemViewModel
+    {
+        public CalendarItem CalendarItem { get; }
+
+        public string Title => CalendarItem.Title;
+
+        public Guid Id => CalendarItem.Id;
+
+        public IAccountCalendar AssignedCalendar => CalendarItem.AssignedCalendar;
+
+        public DateTime StartDate { get => CalendarItem.StartDate; set => CalendarItem.StartDate = value; }
+
+        public DateTime EndDate => CalendarItem.EndDate;
+
+        public double DurationInSeconds { get => CalendarItem.DurationInSeconds; set => CalendarItem.DurationInSeconds = value; }
+
+        public ITimePeriod Period => CalendarItem.Period;
+
+        public bool IsAllDayEvent => CalendarItem.IsAllDayEvent;
+        public bool IsMultiDayEvent => CalendarItem.IsMultiDayEvent;
+        public bool IsRecurringEvent => CalendarItem.IsRecurringEvent;
+        public bool IsRecurringChild => CalendarItem.IsRecurringChild;
+        public bool IsRecurringParent => CalendarItem.IsRecurringParent;
+
+        [ObservableProperty]
+        private bool _isSelected;
+
+        public ObservableCollection<CalendarEventAttendee> Attendees { get; } = new ObservableCollection<CalendarEventAttendee>();
+
+        public CalendarItemViewModel(CalendarItem calendarItem)
+        {
+            CalendarItem = calendarItem;
+        }
+
+        public override string ToString() => CalendarItem.Title;
+    }
+}

Wino.Calendar.ViewModels/Data/GroupedAccountCalendarViewModel.cs

@@ -0,0 +1,146 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.Linq;
+using CommunityToolkit.Mvvm.ComponentModel;
+using Wino.Core.Domain.Entities.Shared;
+
+namespace Wino.Calendar.ViewModels.Data
+{
+    public partial class GroupedAccountCalendarViewModel : ObservableObject
+    {
+        public event EventHandler CollectiveSelectionStateChanged;
+        public event EventHandler<AccountCalendarViewModel> CalendarSelectionStateChanged;
+
+        public MailAccount Account { get; }
+        public ObservableCollection<AccountCalendarViewModel> AccountCalendars { get; }
+
+        public GroupedAccountCalendarViewModel(MailAccount account, IEnumerable<AccountCalendarViewModel> calendarViewModels)
+        {
+            Account = account;
+            AccountCalendars = new ObservableCollection<AccountCalendarViewModel>(calendarViewModels);
+
+            ManageIsCheckedState();
+
+            foreach (var calendarViewModel in calendarViewModels)
+            {
+                calendarViewModel.PropertyChanged += CalendarPropertyChanged;
+            }
+
+            AccountCalendars.CollectionChanged += CalendarListUpdated;
+        }
+
+        private void CalendarListUpdated(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
+        {
+            if (e.Action == NotifyCollectionChangedAction.Add)
+            {
+                foreach (AccountCalendarViewModel calendar in e.NewItems)
+                {
+                    calendar.PropertyChanged += CalendarPropertyChanged;
+                }
+            }
+            else if (e.Action == NotifyCollectionChangedAction.Remove)
+            {
+                foreach (AccountCalendarViewModel calendar in e.OldItems)
+                {
+                    calendar.PropertyChanged -= CalendarPropertyChanged;
+                }
+            }
+            else if (e.Action == NotifyCollectionChangedAction.Reset)
+            {
+                foreach (AccountCalendarViewModel calendar in e.OldItems)
+                {
+                    calendar.PropertyChanged -= CalendarPropertyChanged;
+                }
+            }
+        }
+
+        private void CalendarPropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
+        {
+            if (sender is AccountCalendarViewModel viewModel)
+            {
+                if (e.PropertyName == nameof(AccountCalendarViewModel.IsChecked))
+                {
+                    ManageIsCheckedState();
+                    UpdateCalendarCheckedState(viewModel, viewModel.IsChecked, true);
+                }
+            }
+        }
+
+        [ObservableProperty]
+        private bool _isExpanded = true;
+
+        [ObservableProperty]
+        private bool? isCheckedState = true;
+
+        private bool _isExternalPropChangeBlocked = false;
+
+        private void ManageIsCheckedState()
+        {
+            if (_isExternalPropChangeBlocked) return;
+
+            _isExternalPropChangeBlocked = true;
+
+            if (AccountCalendars.All(c => c.IsChecked))
+            {
+                IsCheckedState = true;
+            }
+            else if (AccountCalendars.All(c => !c.IsChecked))
+            {
+                IsCheckedState = false;
+            }
+            else
+            {
+                IsCheckedState = null;
+            }
+
+            _isExternalPropChangeBlocked = false;
+        }
+
+        partial void OnIsCheckedStateChanged(bool? newValue)
+        {
+            if (_isExternalPropChangeBlocked) return;
+
+            // Update is triggered by user on the three-state checkbox.
+            // We should not report all changes one by one.
+
+            _isExternalPropChangeBlocked = true;
+
+            if (newValue == null)
+            {
+                // Only primary calendars must be checked.
+
+                foreach (var calendar in AccountCalendars)
+                {
+                    UpdateCalendarCheckedState(calendar, calendar.IsPrimary);
+                }
+            }
+            else
+            {
+                foreach (var calendar in AccountCalendars)
+                {
+                    UpdateCalendarCheckedState(calendar, newValue.GetValueOrDefault());
+                }
+            }
+
+            _isExternalPropChangeBlocked = false;
+
+            CollectiveSelectionStateChanged?.Invoke(this, EventArgs.Empty);
+        }
+
+        private void UpdateCalendarCheckedState(AccountCalendarViewModel accountCalendarViewModel, bool newValue, bool ignoreValueCheck = false)
+        {
+            var currentValue = accountCalendarViewModel.IsChecked;
+
+            if (currentValue == newValue && !ignoreValueCheck) return;
+
+            accountCalendarViewModel.IsChecked = newValue;
+
+            // No need to report.
+            if (_isExternalPropChangeBlocked == true) return;
+
+            CalendarSelectionStateChanged?.Invoke(this, accountCalendarViewModel);
+        }
+    }
+}

Wino.Calendar.ViewModels/EventDetailsPageViewModel.cs

@@ -0,0 +1,116 @@
+using System;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using CommunityToolkit.Mvvm.Messaging;
+using Wino.Calendar.ViewModels.Data;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Calendar;
+using Wino.Core.Domain.Models.Navigation;
+using Wino.Core.ViewModels;
+using Wino.Messaging.Client.Calendar;
+
+namespace Wino.Calendar.ViewModels
+{
+    public partial class EventDetailsPageViewModel : CalendarBaseViewModel
+    {
+        private readonly ICalendarService _calendarService;
+        private readonly INativeAppService _nativeAppService;
+        private readonly IPreferencesService _preferencesService;
+
+        public CalendarSettings CurrentSettings { get; }
+
+        #region Details
+
+        [ObservableProperty]
+        [NotifyPropertyChangedFor(nameof(CanViewSeries))]
+        private CalendarItemViewModel _currentEvent;
+
+        [ObservableProperty]
+        private CalendarItemViewModel _seriesParent;
+
+        public bool CanViewSeries => CurrentEvent?.IsRecurringChild ?? false;
+
+        #endregion
+
+        public EventDetailsPageViewModel(ICalendarService calendarService, INativeAppService nativeAppService, IPreferencesService preferencesService)
+        {
+            _calendarService = calendarService;
+            _nativeAppService = nativeAppService;
+            _preferencesService = preferencesService;
+
+            CurrentSettings = _preferencesService.GetCurrentCalendarSettings();
+        }
+
+        public override async void OnNavigatedTo(NavigationMode mode, object parameters)
+        {
+            base.OnNavigatedTo(mode, parameters);
+
+            Messenger.Send(new DetailsPageStateChangedMessage(true));
+
+            if (parameters == null || parameters is not CalendarItemTarget args)
+                return;
+
+            await LoadCalendarItemTargetAsync(args);
+        }
+
+        private async Task LoadCalendarItemTargetAsync(CalendarItemTarget target)
+        {
+            try
+            {
+                var currentEventItem = await _calendarService.GetCalendarItemTargetAsync(target);
+
+                if (currentEventItem == null)
+                    return;
+
+                CurrentEvent = new CalendarItemViewModel(currentEventItem);
+
+                var attendees = await _calendarService.GetAttendeesAsync(currentEventItem.EventTrackingId);
+
+                foreach (var item in attendees)
+                {
+                    CurrentEvent.Attendees.Add(item);
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine(ex.Message);
+            }
+        }
+
+        public override void OnNavigatedFrom(NavigationMode mode, object parameters)
+        {
+            base.OnNavigatedFrom(mode, parameters);
+
+            Messenger.Send(new DetailsPageStateChangedMessage(false));
+        }
+
+        [RelayCommand]
+        private async Task SaveAsync()
+        {
+
+        }
+
+        [RelayCommand]
+        private async Task DeleteAsync()
+        {
+
+        }
+
+        [RelayCommand]
+        private Task JoinOnline()
+        {
+            if (CurrentEvent == null || string.IsNullOrEmpty(CurrentEvent.CalendarItem.HtmlLink)) return Task.CompletedTask;
+
+            return _nativeAppService.LaunchUriAsync(new Uri(CurrentEvent.CalendarItem.HtmlLink));
+        }
+
+        [RelayCommand]
+        private async Task Respond(CalendarItemStatus status)
+        {
+            if (CurrentEvent == null) return;
+        }
+    }
+}

Wino.Calendar.ViewModels/Interfaces/IAccountCalendarStateService.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Linq;
+using Wino.Calendar.ViewModels.Data;
+using Wino.Core.Domain.Entities.Shared;
+
+namespace Wino.Calendar.ViewModels.Interfaces
+{
+    public interface IAccountCalendarStateService : INotifyPropertyChanged
+    {
+        ReadOnlyObservableCollection<GroupedAccountCalendarViewModel> GroupedAccountCalendars { get; }
+
+        event EventHandler<GroupedAccountCalendarViewModel> CollectiveAccountGroupSelectionStateChanged;
+        event EventHandler<AccountCalendarViewModel> AccountCalendarSelectionStateChanged;
+
+        public void AddGroupedAccountCalendar(GroupedAccountCalendarViewModel groupedAccountCalendar);
+        public void RemoveGroupedAccountCalendar(GroupedAccountCalendarViewModel groupedAccountCalendar);
+        public void ClearGroupedAccountCalendar();
+
+        public void AddAccountCalendar(AccountCalendarViewModel accountCalendar);
+        public void RemoveAccountCalendar(AccountCalendarViewModel accountCalendar);
+
+        /// <summary>
+        /// Enumeration of currently selected calendars.
+        /// </summary>
+        IEnumerable<AccountCalendarViewModel> ActiveCalendars { get; }
+        IEnumerable<IGrouping<MailAccount, AccountCalendarViewModel>> GroupedAccountCalendarsEnumerable { get; }
+    }
+}

Wino.Calendar.ViewModels/Messages/CalendarItemDoubleTappedMessage.cs

@@ -0,0 +1,14 @@
+using Wino.Calendar.ViewModels.Data;
+
+namespace Wino.Calendar.ViewModels.Messages
+{
+    public class CalendarItemDoubleTappedMessage
+    {
+        public CalendarItemDoubleTappedMessage(CalendarItemViewModel calendarItemViewModel)
+        {
+            CalendarItemViewModel = calendarItemViewModel;
+        }
+
+        public CalendarItemViewModel CalendarItemViewModel { get; }
+    }
+}

Wino.Calendar.ViewModels/Messages/CalendarItemRightTappedMessage.cs

@@ -0,0 +1,14 @@
+using Wino.Calendar.ViewModels.Data;
+
+namespace Wino.Calendar.ViewModels.Messages
+{
+    public class CalendarItemRightTappedMessage
+    {
+        public CalendarItemRightTappedMessage(CalendarItemViewModel calendarItemViewModel)
+        {
+            CalendarItemViewModel = calendarItemViewModel;
+        }
+
+        public CalendarItemViewModel CalendarItemViewModel { get; }
+    }
+}

Wino.Calendar.ViewModels/Messages/CalendarItemTappedMessage.cs

@@ -0,0 +1,17 @@
+using Wino.Calendar.ViewModels.Data;
+using Wino.Core.Domain.Models.Calendar;
+
+namespace Wino.Calendar.ViewModels.Messages
+{
+    public class CalendarItemTappedMessage
+    {
+        public CalendarItemTappedMessage(CalendarItemViewModel calendarItemViewModel, CalendarDayModel clickedPeriod)
+        {
+            CalendarItemViewModel = calendarItemViewModel;
+            ClickedPeriod = clickedPeriod;
+        }
+
+        public CalendarItemViewModel CalendarItemViewModel { get; }
+        public CalendarDayModel ClickedPeriod { get; }
+    }
+}

Wino.Calendar.ViewModels/Wino.Calendar.ViewModels.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<TargetFramework>netstandard2.0</TargetFramework>
+		<LangVersion>12</LangVersion>
+		<Platforms>AnyCPU;x64;x86</Platforms>
+		<AccelerateBuildsInVisualStudio>true</AccelerateBuildsInVisualStudio>
+		<ProduceReferenceAssembly>true</ProduceReferenceAssembly>
+	</PropertyGroup>
+
+	<ItemGroup>
+	  <PackageReference Include="TimePeriodLibrary.NET" Version="2.1.5" />
+	</ItemGroup>
+
+	<ItemGroup>
+	  <ProjectReference Include="..\Wino.Core.Domain\Wino.Core.Domain.csproj" />
+	  <ProjectReference Include="..\Wino.Core.ViewModels\Wino.Core.ViewModels.csproj" />
+	  <ProjectReference Include="..\Wino.Core\Wino.Core.csproj" />
+	  <ProjectReference Include="..\Wino.Messages\Wino.Messaging.csproj" />
+	  <ProjectReference Include="..\Wino.Services\Wino.Services.csproj" />
+	</ItemGroup>
+
+</Project>

Wino.Calendar.sln

@@ -0,0 +1,308 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.12.35424.110
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Wino.Core.Domain", "Wino.Core.Domain\Wino.Core.Domain.csproj", "{814400B6-5A05-4596-B451-3A116A147DC1}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Wino.Core.UWP", "Wino.Core.UWP\Wino.Core.UWP.csproj", "{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Wino.Core.ViewModels", "Wino.Core.ViewModels\Wino.Core.ViewModels.csproj", "{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Wino.Messaging", "Wino.Messages\Wino.Messaging.csproj", "{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Wino.Server", "Wino.Server\Wino.Server.csproj", "{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Wino.Core", "Wino.Core\Wino.Core.csproj", "{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Wino.Calendar", "Wino.Calendar\Wino.Calendar.csproj", "{600F4979-DB7E-409D-B7DA-B60BE4C55C35}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Wino.SourceGenerators", "Wino.SourceGenerators\Wino.SourceGenerators.csproj", "{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}"
+EndProject
+Project("{C7167F0D-BC9F-4E6E-AFE1-012C56B48DB5}") = "Wino.Calendar.Packaging", "Wino.Calendar.Packaging\Wino.Calendar.Packaging.wapproj", "{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Wino.Calendar.ViewModels", "Wino.Calendar.ViewModels\Wino.Calendar.ViewModels.csproj", "{CF850F8C-5042-4376-9CBA-C8F2BB554083}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Wino.Services", "Wino.Services\Wino.Services.csproj", "{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Wino.Authentication", "Wino.Authentication\Wino.Authentication.csproj", "{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Debug|ARM = Debug|ARM
+		Debug|ARM64 = Debug|ARM64
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|Any CPU = Release|Any CPU
+		Release|ARM = Release|ARM
+		Release|ARM64 = Release|ARM64
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{814400B6-5A05-4596-B451-3A116A147DC1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{814400B6-5A05-4596-B451-3A116A147DC1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{814400B6-5A05-4596-B451-3A116A147DC1}.Debug|ARM.ActiveCfg = Debug|Any CPU
+		{814400B6-5A05-4596-B451-3A116A147DC1}.Debug|ARM.Build.0 = Debug|Any CPU
+		{814400B6-5A05-4596-B451-3A116A147DC1}.Debug|ARM64.ActiveCfg = Debug|Any CPU
+		{814400B6-5A05-4596-B451-3A116A147DC1}.Debug|ARM64.Build.0 = Debug|Any CPU
+		{814400B6-5A05-4596-B451-3A116A147DC1}.Debug|x64.ActiveCfg = Debug|x64
+		{814400B6-5A05-4596-B451-3A116A147DC1}.Debug|x64.Build.0 = Debug|x64
+		{814400B6-5A05-4596-B451-3A116A147DC1}.Debug|x86.ActiveCfg = Debug|x86
+		{814400B6-5A05-4596-B451-3A116A147DC1}.Debug|x86.Build.0 = Debug|x86
+		{814400B6-5A05-4596-B451-3A116A147DC1}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{814400B6-5A05-4596-B451-3A116A147DC1}.Release|Any CPU.Build.0 = Release|Any CPU
+		{814400B6-5A05-4596-B451-3A116A147DC1}.Release|ARM.ActiveCfg = Release|Any CPU
+		{814400B6-5A05-4596-B451-3A116A147DC1}.Release|ARM.Build.0 = Release|Any CPU
+		{814400B6-5A05-4596-B451-3A116A147DC1}.Release|ARM64.ActiveCfg = Release|Any CPU
+		{814400B6-5A05-4596-B451-3A116A147DC1}.Release|ARM64.Build.0 = Release|Any CPU
+		{814400B6-5A05-4596-B451-3A116A147DC1}.Release|x64.ActiveCfg = Release|x64
+		{814400B6-5A05-4596-B451-3A116A147DC1}.Release|x64.Build.0 = Release|x64
+		{814400B6-5A05-4596-B451-3A116A147DC1}.Release|x86.ActiveCfg = Release|x86
+		{814400B6-5A05-4596-B451-3A116A147DC1}.Release|x86.Build.0 = Release|x86
+		{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}.Debug|ARM.ActiveCfg = Debug|Any CPU
+		{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}.Debug|ARM.Build.0 = Debug|Any CPU
+		{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}.Debug|ARM64.Build.0 = Debug|ARM64
+		{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}.Debug|x64.ActiveCfg = Debug|x64
+		{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}.Debug|x64.Build.0 = Debug|x64
+		{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}.Debug|x86.ActiveCfg = Debug|x86
+		{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}.Debug|x86.Build.0 = Debug|x86
+		{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}.Release|Any CPU.Build.0 = Release|Any CPU
+		{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}.Release|ARM.ActiveCfg = Release|Any CPU
+		{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}.Release|ARM.Build.0 = Release|Any CPU
+		{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}.Release|ARM64.ActiveCfg = Release|ARM64
+		{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}.Release|ARM64.Build.0 = Release|ARM64
+		{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}.Release|x64.ActiveCfg = Release|x64
+		{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}.Release|x64.Build.0 = Release|x64
+		{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}.Release|x86.ActiveCfg = Release|x86
+		{395F19BA-1E42-495C-9DB5-1A6F537FCCB8}.Release|x86.Build.0 = Release|x86
+		{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}.Debug|ARM.ActiveCfg = Debug|Any CPU
+		{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}.Debug|ARM.Build.0 = Debug|Any CPU
+		{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}.Debug|ARM64.ActiveCfg = Debug|Any CPU
+		{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}.Debug|ARM64.Build.0 = Debug|Any CPU
+		{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}.Debug|x64.ActiveCfg = Debug|x64
+		{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}.Debug|x64.Build.0 = Debug|x64
+		{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}.Debug|x86.ActiveCfg = Debug|x86
+		{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}.Debug|x86.Build.0 = Debug|x86
+		{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}.Release|Any CPU.Build.0 = Release|Any CPU
+		{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}.Release|ARM.ActiveCfg = Release|Any CPU
+		{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}.Release|ARM.Build.0 = Release|Any CPU
+		{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}.Release|ARM64.ActiveCfg = Release|Any CPU
+		{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}.Release|ARM64.Build.0 = Release|Any CPU
+		{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}.Release|x64.ActiveCfg = Release|x64
+		{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}.Release|x64.Build.0 = Release|x64
+		{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}.Release|x86.ActiveCfg = Release|x86
+		{510CD96C-B3FF-4EC9-A67B-845C842E6BEC}.Release|x86.Build.0 = Release|x86
+		{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}.Debug|ARM.ActiveCfg = Debug|Any CPU
+		{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}.Debug|ARM.Build.0 = Debug|Any CPU
+		{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}.Debug|ARM64.ActiveCfg = Debug|Any CPU
+		{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}.Debug|ARM64.Build.0 = Debug|Any CPU
+		{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}.Debug|x64.ActiveCfg = Debug|x64
+		{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}.Debug|x64.Build.0 = Debug|x64
+		{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}.Debug|x86.ActiveCfg = Debug|x86
+		{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}.Debug|x86.Build.0 = Debug|x86
+		{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}.Release|Any CPU.Build.0 = Release|Any CPU
+		{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}.Release|ARM.ActiveCfg = Release|Any CPU
+		{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}.Release|ARM.Build.0 = Release|Any CPU
+		{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}.Release|ARM64.ActiveCfg = Release|Any CPU
+		{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}.Release|ARM64.Build.0 = Release|Any CPU
+		{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}.Release|x64.ActiveCfg = Release|x64
+		{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}.Release|x64.Build.0 = Release|x64
+		{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}.Release|x86.ActiveCfg = Release|x86
+		{AB588CFD-4B0C-4A1F-B711-1999E3D092D0}.Release|x86.Build.0 = Release|x86
+		{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}.Debug|Any CPU.ActiveCfg = Debug|x64
+		{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}.Debug|Any CPU.Build.0 = Debug|x64
+		{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}.Debug|ARM.ActiveCfg = Debug|x64
+		{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}.Debug|ARM.Build.0 = Debug|x64
+		{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}.Debug|ARM64.Build.0 = Debug|ARM64
+		{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}.Debug|x64.ActiveCfg = Debug|x64
+		{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}.Debug|x64.Build.0 = Debug|x64
+		{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}.Debug|x86.ActiveCfg = Debug|x86
+		{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}.Debug|x86.Build.0 = Debug|x86
+		{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}.Release|Any CPU.ActiveCfg = Release|x64
+		{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}.Release|Any CPU.Build.0 = Release|x64
+		{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}.Release|ARM.ActiveCfg = Release|x64
+		{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}.Release|ARM.Build.0 = Release|x64
+		{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}.Release|ARM64.ActiveCfg = Release|ARM64
+		{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}.Release|ARM64.Build.0 = Release|ARM64
+		{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}.Release|x64.ActiveCfg = Release|x64
+		{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}.Release|x64.Build.0 = Release|x64
+		{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}.Release|x86.ActiveCfg = Release|x86
+		{92DA33FC-9252-40C5-BF71-67ACB0B56F2B}.Release|x86.Build.0 = Release|x86
+		{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}.Debug|ARM.ActiveCfg = Debug|Any CPU
+		{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}.Debug|ARM.Build.0 = Debug|Any CPU
+		{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}.Debug|ARM64.ActiveCfg = Debug|Any CPU
+		{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}.Debug|ARM64.Build.0 = Debug|Any CPU
+		{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}.Debug|x64.ActiveCfg = Debug|x64
+		{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}.Debug|x64.Build.0 = Debug|x64
+		{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}.Debug|x86.ActiveCfg = Debug|x86
+		{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}.Debug|x86.Build.0 = Debug|x86
+		{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}.Release|Any CPU.Build.0 = Release|Any CPU
+		{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}.Release|ARM.ActiveCfg = Release|Any CPU
+		{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}.Release|ARM.Build.0 = Release|Any CPU
+		{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}.Release|ARM64.ActiveCfg = Release|Any CPU
+		{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}.Release|ARM64.Build.0 = Release|Any CPU
+		{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}.Release|x64.ActiveCfg = Release|x64
+		{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}.Release|x64.Build.0 = Release|x64
+		{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}.Release|x86.ActiveCfg = Release|x86
+		{87FFCBF4-DC17-4F09-90D6-102CF4C72BAF}.Release|x86.Build.0 = Release|x86
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Debug|Any CPU.ActiveCfg = Debug|x64
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Debug|Any CPU.Build.0 = Debug|x64
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Debug|Any CPU.Deploy.0 = Debug|x64
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Debug|ARM.ActiveCfg = Debug|ARM
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Debug|ARM.Build.0 = Debug|ARM
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Debug|ARM.Deploy.0 = Debug|ARM
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Debug|ARM64.Build.0 = Debug|ARM64
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Debug|x64.ActiveCfg = Debug|x64
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Debug|x64.Build.0 = Debug|x64
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Debug|x64.Deploy.0 = Debug|x64
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Debug|x86.ActiveCfg = Debug|x86
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Debug|x86.Build.0 = Debug|x86
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Debug|x86.Deploy.0 = Debug|x86
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Release|Any CPU.ActiveCfg = Release|x64
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Release|Any CPU.Build.0 = Release|x64
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Release|Any CPU.Deploy.0 = Release|x64
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Release|ARM.ActiveCfg = Release|ARM
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Release|ARM.Build.0 = Release|ARM
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Release|ARM.Deploy.0 = Release|ARM
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Release|ARM64.ActiveCfg = Release|ARM64
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Release|ARM64.Build.0 = Release|ARM64
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Release|ARM64.Deploy.0 = Release|ARM64
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Release|x64.ActiveCfg = Release|x64
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Release|x64.Build.0 = Release|x64
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Release|x64.Deploy.0 = Release|x64
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Release|x86.ActiveCfg = Release|x86
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Release|x86.Build.0 = Release|x86
+		{600F4979-DB7E-409D-B7DA-B60BE4C55C35}.Release|x86.Deploy.0 = Release|x86
+		{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}.Debug|ARM.ActiveCfg = Debug|Any CPU
+		{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}.Debug|ARM.Build.0 = Debug|Any CPU
+		{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}.Debug|ARM64.ActiveCfg = Debug|Any CPU
+		{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}.Debug|ARM64.Build.0 = Debug|Any CPU
+		{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}.Debug|x64.Build.0 = Debug|Any CPU
+		{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}.Debug|x86.Build.0 = Debug|Any CPU
+		{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}.Release|ARM.ActiveCfg = Release|Any CPU
+		{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}.Release|ARM.Build.0 = Release|Any CPU
+		{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}.Release|ARM64.ActiveCfg = Release|Any CPU
+		{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}.Release|ARM64.Build.0 = Release|Any CPU
+		{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}.Release|x64.ActiveCfg = Release|Any CPU
+		{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}.Release|x64.Build.0 = Release|Any CPU
+		{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}.Release|x86.ActiveCfg = Release|Any CPU
+		{8A7EB697-D722-4E0F-B20E-9FC88373ADB5}.Release|x86.Build.0 = Release|Any CPU
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Debug|ARM.ActiveCfg = Debug|ARM
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Debug|ARM.Build.0 = Debug|ARM
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Debug|ARM.Deploy.0 = Debug|ARM
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Debug|ARM64.Build.0 = Debug|ARM64
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Debug|x64.ActiveCfg = Debug|x64
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Debug|x64.Build.0 = Debug|x64
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Debug|x64.Deploy.0 = Debug|x64
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Debug|x86.ActiveCfg = Debug|x86
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Debug|x86.Build.0 = Debug|x86
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Debug|x86.Deploy.0 = Debug|x86
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Release|Any CPU.Build.0 = Release|Any CPU
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Release|Any CPU.Deploy.0 = Release|Any CPU
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Release|ARM.ActiveCfg = Release|ARM
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Release|ARM.Build.0 = Release|ARM
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Release|ARM.Deploy.0 = Release|ARM
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Release|ARM64.ActiveCfg = Release|ARM64
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Release|ARM64.Build.0 = Release|ARM64
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Release|ARM64.Deploy.0 = Release|ARM64
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Release|x64.ActiveCfg = Release|x64
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Release|x64.Build.0 = Release|x64
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Release|x64.Deploy.0 = Release|x64
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Release|x86.ActiveCfg = Release|x86
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Release|x86.Build.0 = Release|x86
+		{7485B18C-F5AB-4ABE-BA7F-05B6623C67C8}.Release|x86.Deploy.0 = Release|x86
+		{CF850F8C-5042-4376-9CBA-C8F2BB554083}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CF850F8C-5042-4376-9CBA-C8F2BB554083}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{CF850F8C-5042-4376-9CBA-C8F2BB554083}.Debug|ARM.ActiveCfg = Debug|Any CPU
+		{CF850F8C-5042-4376-9CBA-C8F2BB554083}.Debug|ARM.Build.0 = Debug|Any CPU
+		{CF850F8C-5042-4376-9CBA-C8F2BB554083}.Debug|ARM64.ActiveCfg = Debug|Any CPU
+		{CF850F8C-5042-4376-9CBA-C8F2BB554083}.Debug|ARM64.Build.0 = Debug|Any CPU
+		{CF850F8C-5042-4376-9CBA-C8F2BB554083}.Debug|x64.ActiveCfg = Debug|x64
+		{CF850F8C-5042-4376-9CBA-C8F2BB554083}.Debug|x64.Build.0 = Debug|x64
+		{CF850F8C-5042-4376-9CBA-C8F2BB554083}.Debug|x86.ActiveCfg = Debug|x86
+		{CF850F8C-5042-4376-9CBA-C8F2BB554083}.Debug|x86.Build.0 = Debug|x86
+		{CF850F8C-5042-4376-9CBA-C8F2BB554083}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CF850F8C-5042-4376-9CBA-C8F2BB554083}.Release|Any CPU.Build.0 = Release|Any CPU
+		{CF850F8C-5042-4376-9CBA-C8F2BB554083}.Release|ARM.ActiveCfg = Release|Any CPU
+		{CF850F8C-5042-4376-9CBA-C8F2BB554083}.Release|ARM.Build.0 = Release|Any CPU
+		{CF850F8C-5042-4376-9CBA-C8F2BB554083}.Release|ARM64.ActiveCfg = Release|Any CPU
+		{CF850F8C-5042-4376-9CBA-C8F2BB554083}.Release|ARM64.Build.0 = Release|Any CPU
+		{CF850F8C-5042-4376-9CBA-C8F2BB554083}.Release|x64.ActiveCfg = Release|x64
+		{CF850F8C-5042-4376-9CBA-C8F2BB554083}.Release|x64.Build.0 = Release|x64
+		{CF850F8C-5042-4376-9CBA-C8F2BB554083}.Release|x86.ActiveCfg = Release|x86
+		{CF850F8C-5042-4376-9CBA-C8F2BB554083}.Release|x86.Build.0 = Release|x86
+		{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}.Debug|ARM.ActiveCfg = Debug|Any CPU
+		{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}.Debug|ARM.Build.0 = Debug|Any CPU
+		{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}.Debug|ARM64.ActiveCfg = Debug|Any CPU
+		{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}.Debug|ARM64.Build.0 = Debug|Any CPU
+		{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}.Debug|x64.Build.0 = Debug|Any CPU
+		{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}.Debug|x86.Build.0 = Debug|Any CPU
+		{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}.Release|Any CPU.Build.0 = Release|Any CPU
+		{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}.Release|ARM.ActiveCfg = Release|Any CPU
+		{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}.Release|ARM.Build.0 = Release|Any CPU
+		{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}.Release|ARM64.ActiveCfg = Release|Any CPU
+		{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}.Release|ARM64.Build.0 = Release|Any CPU
+		{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}.Release|x64.ActiveCfg = Release|Any CPU
+		{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}.Release|x64.Build.0 = Release|Any CPU
+		{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}.Release|x86.ActiveCfg = Release|Any CPU
+		{BBA49030-7277-48CF-B2FE-3D01CB6B6C81}.Release|x86.Build.0 = Release|Any CPU
+		{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}.Debug|ARM.ActiveCfg = Debug|Any CPU
+		{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}.Debug|ARM.Build.0 = Debug|Any CPU
+		{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}.Debug|ARM64.ActiveCfg = Debug|Any CPU
+		{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}.Debug|ARM64.Build.0 = Debug|Any CPU
+		{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}.Debug|x64.ActiveCfg = Debug|x64
+		{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}.Debug|x64.Build.0 = Debug|x64
+		{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}.Debug|x86.ActiveCfg = Debug|x86
+		{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}.Debug|x86.Build.0 = Debug|x86
+		{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}.Release|Any CPU.Build.0 = Release|Any CPU
+		{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}.Release|ARM.ActiveCfg = Release|Any CPU
+		{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}.Release|ARM.Build.0 = Release|Any CPU
+		{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}.Release|ARM64.ActiveCfg = Release|Any CPU
+		{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}.Release|ARM64.Build.0 = Release|Any CPU
+		{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}.Release|x64.ActiveCfg = Release|x64
+		{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}.Release|x64.Build.0 = Release|x64
+		{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}.Release|x86.ActiveCfg = Release|x86
+		{16A979C2-F308-464F-9B2A-0AF8ED5EDB43}.Release|x86.Build.0 = Release|x86
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Wino.Calendar/Activation/DefaultActivationHandler.cs

@@ -0,0 +1,24 @@
+using System.Threading.Tasks;
+using Windows.ApplicationModel.Activation;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+using Windows.UI.Xaml.Media.Animation;
+using Wino.Activation;
+using Wino.Calendar.Views;
+
+namespace Wino.Calendar.Activation
+{
+    public class DefaultActivationHandler : ActivationHandler<IActivatedEventArgs>
+    {
+        protected override Task HandleInternalAsync(IActivatedEventArgs args)
+        {
+            (Window.Current.Content as Frame).Navigate(typeof(AppShell), null, new DrillInNavigationTransitionInfo());
+
+            return Task.CompletedTask;
+        }
+
+        // Only navigate if Frame content doesn't exist.
+        protected override bool CanHandleInternal(IActivatedEventArgs args)
+            => (Window.Current?.Content as Frame)?.Content == null;
+    }
+}

Wino.Calendar/App.xaml

@@ -0,0 +1,31 @@
+<core:WinoApplication
+    x:Class="Wino.Calendar.App"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:controls="using:Microsoft.UI.Xaml.Controls"
+    xmlns:core="using:Wino.Core.UWP"
+    xmlns:coreStyles="using:Wino.Core.UWP.Styles"
+    xmlns:local="using:Wino.Calendar"
+    xmlns:styles="using:Wino.Calendar.Styles">
+    <Application.Resources>
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+                <XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls" />
+
+                <core:CoreGeneric />
+
+                <styles:WinoCalendarResources />
+
+                <ResourceDictionary Source="Styles/CalendarThemeResources.xaml" />
+
+                <ResourceDictionary Source="Styles/WinoDayTimelineCanvas.xaml" />
+                <ResourceDictionary Source="Styles/WinoCalendarView.xaml" />
+                <ResourceDictionary Source="Styles/WinoCalendarTypeSelectorControl.xaml" />
+
+                <!--  Last item must always be the default theme.  -->
+                <ResourceDictionary Source="ms-appx:///Wino.Core.UWP/AppThemes/Mica.xaml" />
+            </ResourceDictionary.MergedDictionaries>
+        </ResourceDictionary>
+    </Application.Resources>
+</core:WinoApplication>
+

Wino.Calendar/App.xaml.cs

@@ -0,0 +1,164 @@
+using System;
+using System.Collections.Generic;
+using CommunityToolkit.Mvvm.Messaging;
+using Microsoft.Extensions.DependencyInjection;
+using Serilog;
+using Windows.ApplicationModel;
+using Windows.ApplicationModel.Activation;
+using Windows.ApplicationModel.AppService;
+using Windows.ApplicationModel.Background;
+using Windows.UI.Core.Preview;
+using Wino.Activation;
+using Wino.Calendar.Activation;
+using Wino.Calendar.Services;
+using Wino.Calendar.ViewModels;
+using Wino.Calendar.ViewModels.Interfaces;
+using Wino.Core.Domain;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Exceptions;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Synchronization;
+using Wino.Core.UWP;
+using Wino.Core.ViewModels;
+using Wino.Messaging.Client.Connection;
+using Wino.Messaging.Server;
+using Wino.Services;
+
+namespace Wino.Calendar
+{
+    public sealed partial class App : WinoApplication, IRecipient<NewCalendarSynchronizationRequested>
+    {
+        public override string AppCenterKey => "dfdad6ab-95f9-44cc-9112-45ec6730c49e";
+
+        private BackgroundTaskDeferral connectionBackgroundTaskDeferral;
+        private BackgroundTaskDeferral toastActionBackgroundTaskDeferral;
+
+        public App()
+        {
+            InitializeComponent();
+
+            WeakReferenceMessenger.Default.Register(this);
+        }
+
+        public override IServiceProvider ConfigureServices()
+        {
+            var services = new ServiceCollection();
+
+            services.RegisterSharedServices();
+            services.RegisterCalendarViewModelServices();
+            services.RegisterCoreUWPServices();
+            services.RegisterCoreViewModels();
+
+            RegisterUWPServices(services);
+            RegisterViewModels(services);
+            RegisterActivationHandlers(services);
+
+            return services.BuildServiceProvider();
+        }
+
+        #region Dependency Injection
+
+        private void RegisterActivationHandlers(IServiceCollection services)
+        {
+            //services.AddTransient<ProtocolActivationHandler>();
+            //services.AddTransient<ToastNotificationActivationHandler>();
+            //services.AddTransient<FileActivationHandler>();
+        }
+
+        private void RegisterUWPServices(IServiceCollection services)
+        {
+            services.AddSingleton<INavigationService, NavigationService>();
+            services.AddSingleton<ICalendarDialogService, DialogService>();
+            services.AddTransient<ISettingsBuilderService, SettingsBuilderService>();
+            services.AddTransient<IProviderService, ProviderService>();
+            services.AddSingleton<IAuthenticatorConfig, CalendarAuthenticatorConfig>();
+            services.AddSingleton<IAccountCalendarStateService, AccountCalendarStateService>();
+        }
+
+        private void RegisterViewModels(IServiceCollection services)
+        {
+            services.AddSingleton(typeof(AppShellViewModel));
+            services.AddSingleton(typeof(CalendarPageViewModel));
+            services.AddTransient(typeof(CalendarSettingsPageViewModel));
+            services.AddTransient(typeof(AccountManagementViewModel));
+            services.AddTransient(typeof(PersonalizationPageViewModel));
+            services.AddTransient(typeof(AccountDetailsPageViewModel));
+            services.AddTransient(typeof(EventDetailsPageViewModel));
+        }
+
+        #endregion
+
+        protected override void OnApplicationCloseRequested(object sender, SystemNavigationCloseRequestedPreviewEventArgs e)
+        {
+            // TODO: Check server running.
+        }
+
+        protected override async void OnLaunched(LaunchActivatedEventArgs args)
+        {
+            LogActivation($"OnLaunched -> {args.GetType().Name}, Kind -> {args.Kind}, PreviousExecutionState -> {args.PreviousExecutionState}, IsPrelaunch -> {args.PrelaunchActivated}");
+
+            if (!args.PrelaunchActivated)
+            {
+                await ActivateWinoAsync(args);
+            }
+        }
+
+        protected override IEnumerable<ActivationHandler> GetActivationHandlers()
+        {
+            return null;
+        }
+
+        protected override ActivationHandler<IActivatedEventArgs> GetDefaultActivationHandler()
+            => new DefaultActivationHandler();
+
+        protected override void OnBackgroundActivated(BackgroundActivatedEventArgs args)
+        {
+            base.OnBackgroundActivated(args);
+
+            if (args.TaskInstance.TriggerDetails is AppServiceTriggerDetails appServiceTriggerDetails)
+            {
+                LogActivation("OnBackgroundActivated -> AppServiceTriggerDetails received.");
+
+                // Only accept connections from callers in the same package
+                if (appServiceTriggerDetails.CallerPackageFamilyName == Package.Current.Id.FamilyName)
+                {
+                    // Connection established from the fulltrust process
+
+                    connectionBackgroundTaskDeferral = args.TaskInstance.GetDeferral();
+                    args.TaskInstance.Canceled += OnConnectionBackgroundTaskCanceled;
+
+                    AppServiceConnectionManager.Connection = appServiceTriggerDetails.AppServiceConnection;
+
+                    WeakReferenceMessenger.Default.Send(new WinoServerConnectionEstablished());
+                }
+            }
+        }
+
+        public void OnConnectionBackgroundTaskCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
+        {
+            sender.Canceled -= OnConnectionBackgroundTaskCanceled;
+
+            Log.Information($"Server connection background task was canceled. Reason: {reason}");
+
+            connectionBackgroundTaskDeferral?.Complete();
+            connectionBackgroundTaskDeferral = null;
+
+            AppServiceConnectionManager.Connection = null;
+        }
+
+        public async void Receive(NewCalendarSynchronizationRequested message)
+        {
+            try
+            {
+                var synchronizationResultResponse = await AppServiceConnectionManager.GetResponseAsync<CalendarSynchronizationResult, NewCalendarSynchronizationRequested>(message);
+                synchronizationResultResponse.ThrowIfFailed();
+            }
+            catch (WinoServerException serverException)
+            {
+                var dialogService = Services.GetService<ICalendarDialogService>();
+
+                dialogService.InfoBarMessage(Translator.Info_SyncFailedTitle, serverException.Message, InfoBarMessageType.Error);
+            }
+        }
+    }
+}

Wino.Calendar/Args/TimelineCellSelectedArgs.cs

@@ -0,0 +1,41 @@
+using System;
+using Windows.Foundation;
+
+namespace Wino.Calendar.Args
+{
+    /// <summary>
+    /// When a new timeline cell is selected.
+    /// </summary>
+    public class TimelineCellSelectedArgs : EventArgs
+    {
+        public TimelineCellSelectedArgs(DateTime clickedDate, Point canvasPoint, Point positionerPoint, Size cellSize)
+        {
+            ClickedDate = clickedDate;
+            CanvasPoint = canvasPoint;
+            PositionerPoint = positionerPoint;
+            CellSize = cellSize;
+        }
+
+        /// <summary>
+        /// Clicked date and time information for the cell.
+        /// </summary>
+        public DateTime ClickedDate { get; set; }
+
+        /// <summary>
+        /// Position relative to the cell drawing part of the canvas.
+        /// Used to detect clicked cell from the position.
+        /// </summary>
+        public Point CanvasPoint { get; }
+
+        /// <summary>
+        /// Position relative to the main root positioner element of the drawing canvas.
+        /// Used to show the create event dialog teaching tip in correct position.
+        /// </summary>
+        public Point PositionerPoint { get; }
+
+        /// <summary>
+        /// Size of the cell.
+        /// </summary>
+        public Size CellSize { get; }
+    }
+}

Wino.Calendar/Args/TimelineCellUnselectedArgs.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Wino.Calendar.Args
+{
+    /// <summary>
+    /// When selected timeline cell is unselected.
+    /// </summary>
+    public class TimelineCellUnselectedArgs : EventArgs { }
+}

Wino.Calendar/Controls/CalendarItemCommandBarFlyout.cs

@@ -0,0 +1,31 @@
+using Microsoft.UI.Xaml.Controls;
+using Windows.UI.Xaml;
+using Wino.Calendar.ViewModels.Data;
+
+namespace Wino.Calendar.Controls
+{
+    public class CalendarItemCommandBarFlyout : CommandBarFlyout
+    {
+        public static readonly DependencyProperty ItemProperty = DependencyProperty.Register(nameof(Item), typeof(CalendarItemViewModel), typeof(CalendarItemCommandBarFlyout), new PropertyMetadata(null, new PropertyChangedCallback(OnItemChanged)));
+
+        public CalendarItemViewModel Item
+        {
+            get { return (CalendarItemViewModel)GetValue(ItemProperty); }
+            set { SetValue(ItemProperty, value); }
+        }
+
+
+        private static void OnItemChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            if (d is CalendarItemCommandBarFlyout flyout)
+            {
+                flyout.UpdateMenuItems();
+            }
+        }
+
+        private void UpdateMenuItems()
+        {
+
+        }
+    }
+}

Wino.Calendar/Controls/CalendarItemControl.xaml

@@ -0,0 +1,160 @@
+<UserControl
+    x:Class="Wino.Calendar.Controls.CalendarItemControl"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:controls="using:Wino.Core.UWP.Controls"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:helpers="using:Wino.Helpers"
+    xmlns:local="using:Wino.Calendar.Controls"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:muxc="using:Microsoft.UI.Xaml.Controls"
+    d:DesignHeight="300"
+    d:DesignWidth="400"
+    CanDrag="True"
+    DragStarting="ControlDragStarting"
+    DropCompleted="ControlDropped"
+    mc:Ignorable="d">
+
+    <Grid
+        x:Name="MainGrid"
+        CornerRadius="4"
+        DoubleTapped="ControlDoubleTapped"
+        RightTapped="ControlRightTapped"
+        Tapped="ControlTapped"
+        ToolTipService.ToolTip="{x:Bind CalendarItemTitle, Mode=OneWay}">
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="*" />
+            <ColumnDefinition Width="Auto" />
+        </Grid.ColumnDefinitions>
+
+        <Grid.ContextFlyout>
+            <local:CalendarItemCommandBarFlyout Placement="Top">
+                <local:CalendarItemCommandBarFlyout.PrimaryCommands>
+                    <AppBarButton Icon="Save" Label="save" />
+                    <AppBarButton Icon="Delete" Label="Delet" />
+                </local:CalendarItemCommandBarFlyout.PrimaryCommands>
+            </local:CalendarItemCommandBarFlyout>
+        </Grid.ContextFlyout>
+
+        <Grid
+            x:Name="MainBackground"
+            Grid.ColumnSpan="2"
+            Background="{x:Bind helpers:XamlHelpers.GetSolidColorBrushFromHex(CalendarItem.AssignedCalendar.BackgroundColorHex), Mode=OneWay}" />
+
+        <Rectangle
+            x:Name="MainBorder"
+            Grid.ColumnSpan="2"
+            Canvas.ZIndex="2"
+            Stroke="{ThemeResource CalendarItemBorderBrush}"
+            StrokeThickness="0" />
+
+        <TextBlock
+            x:Name="EventTitleTextblock"
+            Margin="2,0"
+            HorizontalAlignment="Stretch"
+            VerticalAlignment="Center"
+            CharacterSpacing="8"
+            FontSize="13"
+            Foreground="{x:Bind helpers:XamlHelpers.GetReadableTextColor(CalendarItem.AssignedCalendar.BackgroundColorHex), Mode=OneWay}"
+            HorizontalTextAlignment="Center"
+            Text="{x:Bind CalendarItemTitle, Mode=OneWay}"
+            TextTrimming="CharacterEllipsis" />
+
+        <!--  TODO: Event attributes  -->
+        <StackPanel
+            x:Name="AttributeStack"
+            Grid.Column="1"
+            Margin="0,4,0,0"
+            HorizontalAlignment="Right"
+            VerticalAlignment="Top"
+            Orientation="Horizontal"
+            Spacing="6">
+            <controls:WinoFontIcon
+                FontSize="12"
+                Foreground="{x:Bind helpers:XamlHelpers.GetReadableTextColor(CalendarItem.AssignedCalendar.BackgroundColorHex), Mode=OneWay}"
+                Icon="CalendarEventRepeat"
+                Visibility="{x:Bind CalendarItem.IsRecurringEvent, Mode=OneWay}" />
+
+            <controls:WinoFontIcon
+                FontSize="12"
+                Foreground="{x:Bind helpers:XamlHelpers.GetReadableTextColor(CalendarItem.AssignedCalendar.BackgroundColorHex), Mode=OneWay}"
+                Icon="CalendarEventMuiltiDay"
+                Visibility="{x:Bind CalendarItem.IsMultiDayEvent, Mode=OneWay}" />
+        </StackPanel>
+
+        <VisualStateManager.VisualStateGroups>
+            <VisualStateGroup x:Name="SelectionStates">
+                <VisualState x:Name="NonSelected" />
+                <VisualState x:Name="Selected">
+                    <VisualState.Setters>
+                        <Setter Target="MainBorder.StrokeThickness" Value="1" />
+                        <Setter Target="MainBorder.Margin" Value="1" />
+                        <Setter Target="MainBorder.Stroke" Value="{ThemeResource CalendarItemSelectedBorderBrush}" />
+                    </VisualState.Setters>
+                    <VisualState.StateTriggers>
+                        <StateTrigger IsActive="{x:Bind CalendarItem.IsSelected, Mode=OneWay, FallbackValue=False}" />
+                    </VisualState.StateTriggers>
+                </VisualState>
+            </VisualStateGroup>
+            <VisualStateGroup x:Name="DraggingStates">
+                <VisualState x:Name="NotDragging" />
+                <VisualState x:Name="Dragging">
+                    <VisualState.StateTriggers>
+                        <StateTrigger IsActive="{x:Bind IsDragging, Mode=OneWay}" />
+                    </VisualState.StateTriggers>
+                    <VisualState.Setters>
+                        <Setter Target="MainBorder.StrokeThickness" Value="2" />
+                        <Setter Target="MainBorder.Stroke" Value="{ThemeResource CalendarItemDraggingBorderBrush}" />
+                        <Setter Target="MainBorder.StrokeDashArray" Value="2.5" />
+                    </VisualState.Setters>
+                </VisualState>
+            </VisualStateGroup>
+            <VisualStateGroup x:Name="EventDurationStates">
+                <!--  Regular event template in the panel.  -->
+                <VisualState x:Name="RegularEvent" />
+
+                <!--  All-Day template for top area.  -->
+                <VisualState x:Name="AllDayEvent">
+                    <VisualState.Setters>
+
+                        <Setter Target="AttributeStack.VerticalAlignment" Value="Center" />
+                        <Setter Target="MainGrid.MinHeight" Value="30" />
+                        <Setter Target="MainBorder.StrokeThickness" Value="0" />
+                    </VisualState.Setters>
+                </VisualState>
+
+                <!--  Multi-Day template for top area.  -->
+                <VisualState x:Name="CustomAreaMultiDayEvent">
+                    <VisualState.Setters>
+                        <Setter Target="MainBackground.Opacity" Value="1" />
+                        <Setter Target="MainBorder.StrokeThickness" Value="0" />
+                        <Setter Target="AttributeStack.Visibility" Value="Visible" />
+                        <Setter Target="AttributeStack.Margin" Value="0,0,4,0" />
+                        <Setter Target="AttributeStack.VerticalAlignment" Value="Center" />
+                        <Setter Target="MainGrid.MinHeight" Value="30" />
+                        <Setter Target="EventTitleTextblock.HorizontalAlignment" Value="Stretch" />
+                        <Setter Target="EventTitleTextblock.HorizontalTextAlignment" Value="Left" />
+                        <Setter Target="EventTitleTextblock.Margin" Value="6,0" />
+                    </VisualState.Setters>
+                </VisualState>
+
+                <!--
+                    Ghost rendering for multi-day events in the panel.
+                    All-Multi day area template is CustomAreaMultiDayEvent
+                -->
+
+                <VisualState x:Name="MultiDayEvent">
+                    <VisualState.Setters>
+                        <Setter Target="MainGrid.CornerRadius" Value="0" />
+                        <Setter Target="MainBackground.Opacity" Value="0.2" />
+                        <Setter Target="MainGrid.IsHitTestVisible" Value="False" />
+                        <Setter Target="MainBorder.StrokeThickness" Value="0" />
+                        <Setter Target="AttributeStack.Visibility" Value="Collapsed" />
+                        <Setter Target="EventTitleTextblock.Visibility" Value="Collapsed" />
+                    </VisualState.Setters>
+                </VisualState>
+            </VisualStateGroup>
+        </VisualStateManager.VisualStateGroups>
+    </Grid>
+</UserControl>
+

Wino.Calendar/Controls/CalendarItemControl.xaml.cs

@@ -0,0 +1,198 @@
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.Messaging;
+using Itenso.TimePeriod;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+using Windows.UI.Xaml.Input;
+using Wino.Calendar.ViewModels.Data;
+using Wino.Calendar.ViewModels.Messages;
+using Wino.Core.Domain;
+using Wino.Core.Domain.Models.Calendar;
+
+namespace Wino.Calendar.Controls
+{
+    public sealed partial class CalendarItemControl : UserControl
+    {
+        // Single tap has a delay to report double taps properly.
+        private bool isSingleTap = false;
+
+        public static readonly DependencyProperty CalendarItemProperty = DependencyProperty.Register(nameof(CalendarItem), typeof(CalendarItemViewModel), typeof(CalendarItemControl), new PropertyMetadata(null, new PropertyChangedCallback(OnCalendarItemChanged)));
+        public static readonly DependencyProperty IsDraggingProperty = DependencyProperty.Register(nameof(IsDragging), typeof(bool), typeof(CalendarItemControl), new PropertyMetadata(false));
+        public static readonly DependencyProperty IsCustomEventAreaProperty = DependencyProperty.Register(nameof(IsCustomEventArea), typeof(bool), typeof(CalendarItemControl), new PropertyMetadata(false));
+        public static readonly DependencyProperty CalendarItemTitleProperty = DependencyProperty.Register(nameof(CalendarItemTitle), typeof(string), typeof(CalendarItemControl), new PropertyMetadata(string.Empty));
+        public static readonly DependencyProperty DisplayingDateProperty = DependencyProperty.Register(nameof(DisplayingDate), typeof(CalendarDayModel), typeof(CalendarItemControl), new PropertyMetadata(null, new PropertyChangedCallback(OnDisplayDateChanged)));
+
+        /// <summary>
+        /// Whether the control is displaying as regular event or all-multi day area in the day control.
+        /// </summary>
+        public bool IsCustomEventArea
+        {
+            get { return (bool)GetValue(IsCustomEventAreaProperty); }
+            set { SetValue(IsCustomEventAreaProperty, value); }
+        }
+
+        /// <summary>
+        /// Day that the calendar item is rendered at.
+        /// It's needed for title manipulation and some other adjustments later on.
+        /// </summary>
+        public CalendarDayModel DisplayingDate
+        {
+            get { return (CalendarDayModel)GetValue(DisplayingDateProperty); }
+            set { SetValue(DisplayingDateProperty, value); }
+        }
+
+        public string CalendarItemTitle
+        {
+            get { return (string)GetValue(CalendarItemTitleProperty); }
+            set { SetValue(CalendarItemTitleProperty, value); }
+        }
+
+        public CalendarItemViewModel CalendarItem
+        {
+            get { return (CalendarItemViewModel)GetValue(CalendarItemProperty); }
+            set { SetValue(CalendarItemProperty, value); }
+        }
+
+        public bool IsDragging
+        {
+            get { return (bool)GetValue(IsDraggingProperty); }
+            set { SetValue(IsDraggingProperty, value); }
+        }
+
+        public CalendarItemControl()
+        {
+            InitializeComponent();
+        }
+
+        private static void OnDisplayDateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            if (d is CalendarItemControl control)
+            {
+                control.UpdateControlVisuals();
+            }
+        }
+
+        private static void OnCalendarItemChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            if (d is CalendarItemControl control)
+            {
+                control.UpdateControlVisuals();
+            }
+        }
+
+        private void UpdateControlVisuals()
+        {
+            // Depending on the calendar item's duration and attributes, we might need to change the display title.
+            // 1. Multi-Day events should display the start date and end date.
+            // 2. Multi-Day events that occupy the whole day just shows 'all day'.
+            // 3. Other events should display the title.
+
+            if (CalendarItem == null) return;
+            if (DisplayingDate == null) return;
+
+            if (CalendarItem.IsMultiDayEvent)
+            {
+                // Multi day events are divided into 3 categories:
+                // 1. All day events
+                // 2. Events that started after the period.
+                // 3. Events that started before the period and finishes within the period.
+
+                var periodRelation = CalendarItem.Period.GetRelation(DisplayingDate.Period);
+
+                if (periodRelation == Itenso.TimePeriod.PeriodRelation.StartInside ||
+                    periodRelation == PeriodRelation.EnclosingStartTouching)
+                {
+                    // hour -> title
+                    CalendarItemTitle = $"{DisplayingDate.CalendarRenderOptions.CalendarSettings.GetTimeString(CalendarItem.StartDate.TimeOfDay)} -> {CalendarItem.Title}";
+                }
+                else if (
+                    periodRelation == PeriodRelation.EndInside ||
+                    periodRelation == PeriodRelation.EnclosingEndTouching)
+                {
+                    // title <- hour
+                    CalendarItemTitle = $"{CalendarItem.Title} <- {DisplayingDate.CalendarRenderOptions.CalendarSettings.GetTimeString(CalendarItem.EndDate.TimeOfDay)}";
+                }
+                else if (periodRelation == PeriodRelation.Enclosing)
+                {
+                    // This event goes all day and it's multi-day.
+                    // Item must be hidden in the calendar but displayed on the custom area at the top.
+
+                    CalendarItemTitle = $"{Translator.CalendarItemAllDay} {CalendarItem.Title}";
+                }
+                else
+                {
+                    // Not expected, but there it is.
+                    CalendarItemTitle = CalendarItem.Title;
+                }
+
+                // Debug.WriteLine($"{CalendarItem.Title} Period relation with {DisplayingDate.Period.ToString()}: {periodRelation}");
+            }
+            else
+            {
+                CalendarItemTitle = CalendarItem.Title;
+            }
+
+            UpdateVisualStates();
+        }
+
+        private void UpdateVisualStates()
+        {
+            if (CalendarItem == null) return;
+
+            if (CalendarItem.IsAllDayEvent)
+            {
+                VisualStateManager.GoToState(this, "AllDayEvent", true);
+            }
+            else if (CalendarItem.IsMultiDayEvent)
+            {
+                if (IsCustomEventArea)
+                {
+                    VisualStateManager.GoToState(this, "CustomAreaMultiDayEvent", true);
+                }
+                else
+                {
+                    // Hide it.
+                    VisualStateManager.GoToState(this, "MultiDayEvent", true);
+                }
+            }
+            else
+            {
+                VisualStateManager.GoToState(this, "RegularEvent", true);
+            }
+        }
+
+        private void ControlDragStarting(UIElement sender, DragStartingEventArgs args) => IsDragging = true;
+
+        private void ControlDropped(UIElement sender, DropCompletedEventArgs args) => IsDragging = false;
+
+        private async void ControlTapped(object sender, TappedRoutedEventArgs e)
+        {
+            if (CalendarItem == null) return;
+
+            isSingleTap = true;
+
+            await Task.Delay(100);
+
+            if (isSingleTap)
+            {
+                WeakReferenceMessenger.Default.Send(new CalendarItemTappedMessage(CalendarItem, DisplayingDate));
+            }
+        }
+
+        private void ControlDoubleTapped(object sender, DoubleTappedRoutedEventArgs e)
+        {
+            if (CalendarItem == null) return;
+
+            isSingleTap = false;
+
+            WeakReferenceMessenger.Default.Send(new CalendarItemDoubleTappedMessage(CalendarItem));
+        }
+
+        private void ControlRightTapped(object sender, RightTappedRoutedEventArgs e)
+        {
+            if (CalendarItem == null) return;
+
+            WeakReferenceMessenger.Default.Send(new CalendarItemRightTappedMessage(CalendarItem));
+        }
+    }
+}